Removed util.

12 files changed, 33 insertions, 34 deletions

diff --git a/components/net/Cargo.toml b/components/net/Cargo.toml
index 758f9b3aa20..a6949734bf3 100644
--- a/components/net/Cargo.toml
+++ b/components/net/Cargo.toml
@@ -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"
 
diff --git a/components/net/chrome_loader.rs b/components/net/chrome_loader.rs
index 6ddb096548a..83b5b59da4a 100644
--- a/components/net/chrome_loader.rs
+++ b/components/net/chrome_loader.rs
@@ -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");
diff --git a/components/net/connector.rs b/components/net/connector.rs
index 4040c929dc5..3e4a8071f28 100644
--- a/components/net/connector.rs
+++ b/components/net/connector.rs
@@ -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>;
 
diff --git a/components/net/content_blocker.rs b/components/net/content_blocker.rs
index c30961263dc..eb7f8e1a130 100644
--- a/components/net/content_blocker.rs
+++ b/components/net/content_blocker.rs
@@ -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());
diff --git a/components/net/filemanager_thread.rs b/components/net/filemanager_thread.rs
index 641b1394539..0fa1aeeca9c 100644
--- a/components/net/filemanager_thread.rs
+++ b/components/net/filemanager_thread.rs
@@ -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);
diff --git a/components/net/hsts.rs b/components/net/hsts.rs
index 662ec7b8088..6b8665bd2e5 100644
--- a/components/net/hsts.rs
+++ b/components/net/hsts.rs
@@ -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 {
diff --git a/components/net/http_loader.rs b/components/net/http_loader.rs
index 6199c45209f..f42d49617c1 100644
--- a/components/net/http_loader.rs
+++ b/components/net/http_loader.rs
@@ -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
diff --git a/components/net/image_cache_thread.rs b/components/net/image_cache_thread.rs
index 5976ec50885..b466374d381 100644
--- a/components/net/image_cache_thread.rs
+++ b/components/net/image_cache_thread.rs
@@ -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)
 }
diff --git a/components/net/lib.rs b/components/net/lib.rs
index e5f3951d542..c1925df8616 100644
--- a/components/net/lib.rs
+++ b/components/net/lib.rs
@@ -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;
diff --git a/components/net/resource_thread.rs b/components/net/resource_thread.rs
index aef1ee314d2..7055f928ad7 100644
--- a/components/net/resource_thread.rs
+++ b/components/net/resource_thread.rs
@@ -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,
diff --git a/components/net/storage_thread.rs b/components/net/storage_thread.rs
index cdf70aa6b3b..88726d5702b 100644
--- a/components/net/storage_thread.rs
+++ b/components/net/storage_thread.rs
@@ -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
     }
 }
diff --git a/components/net/websocket_loader.rs b/components/net/websocket_loader.rs
index c9b67dc7f0f..d0ce7d61836 100644
--- a/components/net/websocket_loader.rs
+++ b/components/net/websocket_loader.rs
@@ -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");
 }