Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Removed util.

Browse source
This commit is contained in:
Alan Jeffrey 2016-12-14 10:37:58 -06:00
parent 01b6ad55bd
commit 9be4fd56ce
133 changed files with 396 additions and 352 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/net/Cargo.toml
View file

@ -34,12 +34,12 @@ profile_traits = {path = "../profile_traits"}
rustc-serialize = "0.3"
serde = "0.8"
serde_derive = "0.8"
servo_config = {path = "../config"}
servo_url = {path = "../url"}
threadpool = "1.0"
time = "0.1.17"
unicase = "1.4.0"
url = {version = "1.2", features = ["heap_size", "rustc-serialize"]}
util = {path = "../util"}
uuid = {version = "0.3.1", features = ["v4"]}
websocket = "0.17"

2
components/net/chrome_loader.rs
View file

@ -2,10 +2,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use servo_config::resource_files::resources_dir_path;
use servo_url::ServoUrl;
use std::fs::canonicalize;
use url::percent_encoding::percent_decode;
use util::resource_files::resources_dir_path;
pub fn resolve_chrome_url(url: &ServoUrl) -> Result<ServoUrl, ()> {
assert_eq!(url.scheme(), "chrome");

2
components/net/connector.rs
View file

@ -6,8 +6,8 @@ use hyper::client::Pool;
use hyper::net::{HttpStream, HttpsConnector, SslClient};
use openssl::ssl::{SSL_OP_NO_COMPRESSION, SSL_OP_NO_SSLV2, SSL_OP_NO_SSLV3, SSL_VERIFY_PEER};
use openssl::ssl::{Ssl, SslContext, SslMethod, SslStream};
use servo_config::resource_files::resources_dir_path;
use std::sync::Arc;
use util::resource_files::resources_dir_path;
pub type Connector = HttpsConnector<ServoSslClient>;

2
components/net/content_blocker.rs
View file

@ -3,9 +3,9 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use content_blocker_parser::{RuleList, parse_list};
use servo_config::resource_files::read_resource_file;
use std::str;
use std::sync::Arc;
use util::resource_files::read_resource_file;
lazy_static! {
pub static ref BLOCKED_CONTENT_RULES: Arc<Option<RuleList>> = Arc::new(create_rule_list());

20
components/net/filemanager_thread.rs
View file

@ -7,6 +7,7 @@ use mime_guess::guess_mime_type_opt;
use net_traits::blob_url_store::{BlobBuf, BlobURLStoreError};
use net_traits::filemanager_thread::{FileManagerResult, FileManagerThreadMsg, FileOrigin, FilterPattern};
use net_traits::filemanager_thread::{FileManagerThreadError, ReadFileProgress, RelativePos, SelectedFile};
use servo_config::prefs::PREFS;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
@ -14,11 +15,10 @@ use std::ops::Index;
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
use std::sync::atomic::{self, AtomicBool, AtomicUsize, Ordering};
use std::thread;
#[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
use tinyfiledialogs;
use url::Url;
use util::prefs::PREFS;
use util::thread::spawn_named;
use uuid::Uuid;
/// The provider of file-dialog UI should implement this trait.
@ -129,12 +129,12 @@ impl FileManager {
check_url_validity: bool,
origin: FileOrigin) {
let store = self.store.clone();
spawn_named("read file".to_owned(), move || {
thread::Builder::new().name("read file".to_owned()).spawn(move || {
if let Err(e) = store.try_read_file(&sender, id, check_url_validity,
origin) {
let _ = sender.send(Err(FileManagerThreadError::BlobURLStoreError(e)));
}
})
}).expect("Thread spawning failed");
}
pub fn promote_memory(&self,
@ -143,9 +143,9 @@ impl FileManager {
sender: IpcSender<Result<Uuid, BlobURLStoreError>>,
origin: FileOrigin) {
let store = self.store.clone();
spawn_named("transfer memory".to_owned(), move || {
thread::Builder::new().name("transfer memory".to_owned()).spawn(move || {
store.promote_memory(blob_buf, set_valid, sender, origin);
})
}).expect("Thread spawning failed");
}
/// Message handler
@ -157,15 +157,15 @@ impl FileManager {
match msg {
FileManagerThreadMsg::SelectFile(filter, sender, origin, opt_test_path) => {
let store = self.store.clone();
spawn_named("select file".to_owned(), move || {
thread::Builder::new().name("select file".to_owned()).spawn(move || {
store.select_file(filter, sender, origin, opt_test_path, ui);
});
}).expect("Thread spawning failed");
}
FileManagerThreadMsg::SelectFiles(filter, sender, origin, opt_test_paths) => {
let store = self.store.clone();
spawn_named("select files".to_owned(), move || {
thread::Builder::new().name("select files".to_owned()).spawn(move || {
store.select_files(filter, sender, origin, opt_test_paths, ui);
})
}).expect("Thread spawning failed");
}
FileManagerThreadMsg::ReadFile(sender, id, check_url_validity, origin) => {
self.read_file(sender, id, check_url_validity, origin);

2
components/net/hsts.rs
View file

@ -4,11 +4,11 @@
use net_traits::IncludeSubdomains;
use rustc_serialize::json::decode;
use servo_config::resource_files::read_resource_file;
use std::net::{Ipv4Addr, Ipv6Addr};
use std::str::from_utf8;
use time;
use url::Url;
use util::resource_files::read_resource_file;
#[derive(RustcDecodable, RustcEncodable, Clone)]
pub struct HstsEntry {

6
components/net/http_loader.rs
View file

@ -47,11 +47,11 @@ use std::ops::Deref;
use std::rc::Rc;
use std::sync::{Arc, RwLock};
use std::sync::mpsc::{channel, Sender};
use std::thread;
use time;
use time::Tm;
use unicase::UniCase;
use url::Origin as UrlOrigin;
use util::thread::spawn_named;
use uuid;
fn read_block<R: Read>(reader: &mut R) -> Result<Data, ()> {
@ -1071,7 +1071,7 @@ fn http_network_fetch(request: Rc<Request>,
let devtools_sender = context.devtools_chan.clone();
let meta_status = meta.status.clone();
let meta_headers = meta.headers.clone();
spawn_named(format!("fetch worker thread"), move || {
thread::Builder::new().name(format!("fetch worker thread")).spawn(move || {
match StreamedResponse::from_http_response(res) {
Ok(mut res) => {
*res_body.lock().unwrap() = ResponseBody::Receiving(vec![]);
@ -1123,7 +1123,7 @@ fn http_network_fetch(request: Rc<Request>,
let _ = done_sender.send(Data::Done);
}
}
});
}).expect("Thread spawning failed");
// TODO these substeps aren't possible yet
// Substep 1

8
components/net/image_cache_thread.rs
View file

@ -11,6 +11,7 @@ use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheCommand, ImageCac
use net_traits::image_cache_thread::{ImageCacheResult, ImageOrMetadataAvailable, ImageResponse, UsePlaceholder};
use net_traits::image_cache_thread::ImageResponder;
use net_traits::request::{Destination, RequestInit, Type as RequestType};
use servo_config::resource_files::resources_dir_path;
use servo_url::ServoUrl;
use std::borrow::ToOwned;
use std::collections::HashMap;
@ -20,9 +21,8 @@ use std::io::{self, Read};
use std::mem;
use std::sync::Arc;
use std::sync::mpsc::{Receiver, Sender, channel};
use std::thread;
use threadpool::ThreadPool;
use util::resource_files::resources_dir_path;
use util::thread::spawn_named;
use webrender_traits;
///
@ -648,9 +648,9 @@ pub fn new_image_cache_thread(core_resource_thread: CoreResourceThread,
webrender_api: webrender_traits::RenderApi) -> ImageCacheThread {
let (ipc_command_sender, ipc_command_receiver) = ipc::channel().unwrap();
spawn_named("ImageCacheThread".to_owned(), move || {
thread::Builder::new().name("ImageCacheThread".to_owned()).spawn(move || {
ImageCache::run(core_resource_thread, webrender_api, ipc_command_receiver)
});
}).expect("Thread spawning failed");
ImageCacheThread::new(ipc_command_sender)
}

2
components/net/lib.rs
View file

@ -35,6 +35,7 @@ extern crate profile_traits;
extern crate rustc_serialize;
#[macro_use]
extern crate serde_derive;
extern crate servo_config;
extern crate servo_url;
extern crate threadpool;
extern crate time;
@ -42,7 +43,6 @@ extern crate time;
extern crate tinyfiledialogs;
extern crate unicase;
extern crate url;
extern crate util;
extern crate uuid;
extern crate webrender_traits;
extern crate websocket;

10
components/net/resource_thread.rs
View file

@ -37,8 +37,8 @@ use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::{Arc, RwLock};
use std::sync::mpsc::Sender;
use std::thread;
use storage_thread::StorageThreadFactory;
use util::thread::spawn_named;
use websocket_loader;
const TFD_PROVIDER: &'static TFDProvider = &TFDProvider;
@ -76,7 +76,7 @@ pub fn new_core_resource_thread(user_agent: Cow<'static, str>,
-> (CoreResourceThread, CoreResourceThread) {
let (public_setup_chan, public_setup_port) = ipc::channel().unwrap();
let (private_setup_chan, private_setup_port) = ipc::channel().unwrap();
spawn_named("ResourceManager".to_owned(), move || {
thread::Builder::new().name("ResourceManager".to_owned()).spawn(move || {
let resource_manager = CoreResourceManager::new(
user_agent, devtools_chan, profiler_chan
);
@ -87,7 +87,7 @@ pub fn new_core_resource_thread(user_agent: Cow<'static, str>,
};
channel_manager.start(public_setup_port,
private_setup_port);
});
}).expect("Thread spawning failed");
(public_setup_chan, private_setup_chan)
}
@ -343,7 +343,7 @@ impl CoreResourceManager {
let ua = self.user_agent.clone();
let dc = self.devtools_chan.clone();
let filemanager = self.filemanager.clone();
spawn_named(format!("fetch thread for {}", init.url), move || {
thread::Builder::new().name(format!("fetch thread for {}", init.url)).spawn(move || {
let request = Request::from_init(init);
// XXXManishearth: Check origin against pipeline id (also ensure that the mode is allowed)
// todo load context / mimesniff in fetch
@ -357,7 +357,7 @@ impl CoreResourceManager {
filemanager: filemanager,
};
fetch(Rc::new(request), &mut target, &context);
})
}).expect("Thread spawning failed");
}
fn websocket_connect(&self,

6
components/net/storage_thread.rs
View file

@ -10,7 +10,7 @@ use std::borrow::ToOwned;
use std::collections::BTreeMap;
use std::collections::HashMap;
use std::path::PathBuf;
use util::thread::spawn_named;
use std::thread;
const QUOTA_SIZE_LIMIT: usize = 5 * 1024 * 1024;
@ -22,9 +22,9 @@ impl StorageThreadFactory for IpcSender<StorageThreadMsg> {
/// Create a storage thread
fn new(config_dir: Option<PathBuf>) -> IpcSender<StorageThreadMsg> {
let (chan, port) = ipc::channel().unwrap();
spawn_named("StorageManager".to_owned(), move || {
thread::Builder::new().name("StorageManager".to_owned()).spawn(move || {
StorageManager::new(port, config_dir).start();
});
}).expect("Thread spawning failed");
chan
}
}

5
components/net/websocket_loader.rs
View file

@ -14,7 +14,6 @@ use std::ascii::AsciiExt;
use std::sync::{Arc, Mutex, RwLock};
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use util::thread::spawn_named;
use websocket::{Client, Message};
use websocket::header::{Headers, Origin, WebSocketProtocol};
use websocket::message::Type;
@ -64,7 +63,7 @@ fn establish_a_websocket_connection(resource_url: &ServoUrl, net_url: (Host, Str
}
pub fn init(connect: WebSocketCommunicate, connect_data: WebSocketConnectData, cookie_jar: Arc<RwLock<CookieStorage>>) {
spawn_named(format!("WebSocket connection to {}", connect_data.resource_url), move || {
thread::Builder::new().name(format!("WebSocket connection to {}", connect_data.resource_url)).spawn(move || {
// Step 8: Protocols.
// Step 9.
@ -162,5 +161,5 @@ pub fn init(connect: WebSocketCommunicate, connect_data: WebSocketConnectData, c
}
}
});
});
}).expect("Thread spawning failed");
}