Implement trait-based ResourceThreads and clean up related naming issues

Changes include:

- Introduce an IpcSend trait to abstract over a collection of IpcSenders
- Implement ResourceThreads collection to abstract the resource-related
  sub threads across the component
- Rename original ResourceThread and ControlMsg into an unifed CoreResource__
  to accommodate above changes and avoid confusions

components/net/filemanager_thread.rs

@@ -18,7 +18,7 @@ pub struct FileManager {
 }
 
 impl FileManager {
-    pub fn new(recv: IpcReceiver<FileManagerThreadMsg>) -> FileManager {
+    fn new(recv: IpcReceiver<FileManagerThreadMsg>) -> FileManager {
         FileManager {
             receiver: recv,
             idmap: RefCell::new(HashMap::new()),
@@ -36,7 +36,7 @@ impl FileManager {
     }
 
     /// Start the file manager event loop
-    pub fn start(&mut self) {
+    fn start(&mut self) {
         loop {
             match self.receiver.recv().unwrap() {
                 FileManagerThreadMsg::SelectFile(sender) => self.select_file(sender),

components/net/image_cache_thread.rs

@@ -9,7 +9,7 @@ use net_traits::image::base::{Image, ImageMetadata, load_from_memory, PixelForma
 use net_traits::image_cache_thread::ImageResponder;
 use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheCommand, ImageCacheThread, ImageState};
 use net_traits::image_cache_thread::{ImageCacheResult, ImageOrMetadataAvailable, ImageResponse, UsePlaceholder};
-use net_traits::{AsyncResponseTarget, ControlMsg, LoadConsumer, LoadData, ResourceThread};
+use net_traits::{AsyncResponseTarget, CoreResourceMsg, LoadConsumer, LoadData, CoreResourceThread};
 use net_traits::{ResponseAction, LoadContext, NetworkError};
 use std::borrow::ToOwned;
 use std::collections::HashMap;
@@ -240,7 +240,7 @@ struct ImageCache {
     thread_pool: ThreadPool,
 
     // Resource thread handle
-    resource_thread: ResourceThread,
+    core_resource_thread: CoreResourceThread,
 
     // Images that are loading over network, or decoding.
     pending_loads: AllPendingLoads,
@@ -305,7 +305,7 @@ fn convert_format(format: PixelFormat) -> webrender_traits::ImageFormat {
 }
 
 impl ImageCache {
-    fn run(resource_thread: ResourceThread,
+    fn run(core_resource_thread: CoreResourceThread,
            webrender_api: Option<webrender_traits::RenderApi>,
            ipc_command_receiver: IpcReceiver<ImageCacheCommand>) {
         // Preload the placeholder image, used when images fail to load.
@@ -338,7 +338,7 @@ impl ImageCache {
             thread_pool: ThreadPool::new(4),
             pending_loads: AllPendingLoads::new(),
             completed_loads: HashMap::new(),
-            resource_thread: resource_thread,
+            core_resource_thread: core_resource_thread,
             placeholder_image: placeholder_image,
             webrender_api: webrender_api,
         };
@@ -525,7 +525,7 @@ impl ImageCache {
                         let response_target = AsyncResponseTarget {
                             sender: action_sender,
                         };
-                        let msg = ControlMsg::Load(load_data,
+                        let msg = CoreResourceMsg::Load(load_data,
                                                    LoadConsumer::Listener(response_target),
                                                    None);
                         let progress_sender = self.progress_sender.clone();
@@ -536,7 +536,7 @@ impl ImageCache {
                                 key: load_key,
                             }).unwrap();
                         });
-                        self.resource_thread.send(msg).unwrap();
+                        self.core_resource_thread.send(msg).unwrap();
                     }
                     CacheResult::Hit => {
                         // Request is already on its way.
@@ -611,12 +611,12 @@ impl ImageCache {
 }
 
 /// Create a new image cache.
-pub fn new_image_cache_thread(resource_thread: ResourceThread,
+pub fn new_image_cache_thread(core_resource_thread: CoreResourceThread,
                               webrender_api: Option<webrender_traits::RenderApi>) -> ImageCacheThread {
     let (ipc_command_sender, ipc_command_receiver) = ipc::channel().unwrap();
 
     spawn_named("ImageCacheThread".to_owned(), move || {
-        ImageCache::run(resource_thread, webrender_api, ipc_command_receiver)
+        ImageCache::run(core_resource_thread, webrender_api, ipc_command_receiver)
     });
 
     ImageCacheThread::new(ipc_command_sender)

components/net/lib.rs

@@ -2,12 +2,13 @@
  * 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/. */
 
+#![feature(custom_attribute)]
+#![feature(custom_derive)]
 #![feature(box_syntax)]
 #![feature(fnbox)]
 #![feature(fs_time)]
 #![feature(mpsc_select)]
 #![feature(plugin)]
-#![feature(plugin)]
 #![plugin(plugins)]
 
 #![deny(unsafe_code)]

components/net/resource_thread.rs

@@ -20,9 +20,9 @@ use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use mime_classifier::{ApacheBugFlag, MIMEClassifier, NoSniffFlag};
 use net_traits::LoadContext;
 use net_traits::ProgressMsg::Done;
-use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResourceThread, ResponseAction};
-use net_traits::{ControlMsg, CookieSource, LoadConsumer, LoadData, LoadResponse, ResourceId};
-use net_traits::{NetworkError, WebSocketCommunicate, WebSocketConnectData};
+use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResponseAction, CoreResourceThread};
+use net_traits::{CoreResourceMsg, CookieSource, LoadConsumer, LoadData, LoadResponse, ResourceId};
+use net_traits::{NetworkError, WebSocketCommunicate, WebSocketConnectData, ResourceThreads};
 use profile_traits::time::ProfilerChan;
 use rustc_serialize::json;
 use rustc_serialize::{Decodable, Encodable};
@@ -36,6 +36,7 @@ use std::io::prelude::*;
 use std::path::Path;
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::sync::{Arc, RwLock};
+use storage_thread::StorageThreadFactory;
 use url::Url;
 use util::opts;
 use util::prefs;
@@ -149,15 +150,23 @@ fn start_sending_opt(start_chan: LoadConsumer, metadata: Metadata,
     }
 }
 
-/// Create a ResourceThread
-pub fn new_resource_thread(user_agent: String,
-                           devtools_chan: Option<Sender<DevtoolsControlMsg>>,
-                           profiler_chan: ProfilerChan) -> ResourceThread {
+pub fn new_resource_threads(user_agent: String,
+                            devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+                            profiler_chan: ProfilerChan) -> ResourceThreads {
+    ResourceThreads::new(new_core_resource_thread(user_agent, devtools_chan, profiler_chan),
+                         StorageThreadFactory::new())
+}
+
+
+/// Create a CoreResourceThread
+pub fn new_core_resource_thread(user_agent: String,
+                                devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+                                profiler_chan: ProfilerChan) -> CoreResourceThread {
     let hsts_preload = HstsList::from_servo_preload();
     let (setup_chan, setup_port) = ipc::channel().unwrap();
     let setup_chan_clone = setup_chan.clone();
     spawn_named("ResourceManager".to_owned(), move || {
-        let resource_manager = ResourceManager::new(
+        let resource_manager = CoreResourceManager::new(
             user_agent, hsts_preload, devtools_chan, profiler_chan
         );
 
@@ -171,35 +180,35 @@ pub fn new_resource_thread(user_agent: String,
 }
 
 struct ResourceChannelManager {
-    from_client: IpcReceiver<ControlMsg>,
-    resource_manager: ResourceManager
+    from_client: IpcReceiver<CoreResourceMsg>,
+    resource_manager: CoreResourceManager
 }
 
 impl ResourceChannelManager {
-    fn start(&mut self, control_sender: ResourceThread) {
+    fn start(&mut self, control_sender: CoreResourceThread) {
         loop {
             match self.from_client.recv().unwrap() {
-                ControlMsg::Load(load_data, consumer, id_sender) =>
+                CoreResourceMsg::Load(load_data, consumer, id_sender) =>
                     self.resource_manager.load(load_data, consumer, id_sender, control_sender.clone()),
-                ControlMsg::WebsocketConnect(connect, connect_data) =>
+                CoreResourceMsg::WebsocketConnect(connect, connect_data) =>
                     self.resource_manager.websocket_connect(connect, connect_data),
-                ControlMsg::SetCookiesForUrl(request, cookie_list, source) =>
+                CoreResourceMsg::SetCookiesForUrl(request, cookie_list, source) =>
                     self.resource_manager.set_cookies_for_url(request, cookie_list, source),
-                ControlMsg::GetCookiesForUrl(url, consumer, source) => {
+                CoreResourceMsg::GetCookiesForUrl(url, consumer, source) => {
                     let cookie_jar = &self.resource_manager.cookie_jar;
                     let mut cookie_jar = cookie_jar.write().unwrap();
                     consumer.send(cookie_jar.cookies_for_url(&url, source)).unwrap();
                 }
-                ControlMsg::Cancel(res_id) => {
+                CoreResourceMsg::Cancel(res_id) => {
                     if let Some(cancel_sender) = self.resource_manager.cancel_load_map.get(&res_id) {
                         let _ = cancel_sender.send(());
                     }
                     self.resource_manager.cancel_load_map.remove(&res_id);
                 }
-                ControlMsg::Synchronize(sender) => {
+                CoreResourceMsg::Synchronize(sender) => {
                     let _ = sender.send(());
                 }
-                ControlMsg::Exit => {
+                CoreResourceMsg::Exit => {
                     if let Some(ref profile_dir) = opts::get().profile_dir {
                         match self.resource_manager.auth_cache.read() {
                             Ok(auth_cache) => write_json_to_file(&*auth_cache, profile_dir, "auth_cache.json"),
@@ -283,12 +292,12 @@ pub struct CancellableResource {
     resource_id: ResourceId,
     /// If we haven't initiated any cancel requests, then the loaders ask
     /// the listener to remove the `ResourceId` in the `HashMap` of
-    /// `ResourceManager` once they finish loading
-    resource_thread: ResourceThread,
+    /// `CoreResourceManager` once they finish loading
+    resource_thread: CoreResourceThread,
 }
 
 impl CancellableResource {
-    pub fn new(receiver: Receiver<()>, res_id: ResourceId, res_thread: ResourceThread) -> CancellableResource {
+    pub fn new(receiver: Receiver<()>, res_id: ResourceId, res_thread: CoreResourceThread) -> CancellableResource {
         CancellableResource {
             cancel_receiver: receiver,
             resource_id: res_id,
@@ -333,7 +342,7 @@ impl Drop for CancellationListener {
     fn drop(&mut self) {
         if let Some(ref resource) = self.cancel_resource {
             // Ensure that the resource manager stops tracking this request now that it's terminated.
-            let _ = resource.resource_thread.send(ControlMsg::Cancel(resource.resource_id));
+            let _ = resource.resource_thread.send(CoreResourceMsg::Cancel(resource.resource_id));
         }
     }
 }
@@ -360,7 +369,7 @@ pub struct AuthCache {
     pub entries: HashMap<Url, AuthCacheEntry>,
 }
 
-pub struct ResourceManager {
+pub struct CoreResourceManager {
     user_agent: String,
     cookie_jar: Arc<RwLock<CookieStorage>>,
     auth_cache: Arc<RwLock<AuthCache>>,
@@ -373,11 +382,11 @@ pub struct ResourceManager {
     next_resource_id: ResourceId,
 }
 
-impl ResourceManager {
+impl CoreResourceManager {
     pub fn new(user_agent: String,
                mut hsts_list: HstsList,
                devtools_channel: Option<Sender<DevtoolsControlMsg>>,
-               profiler_chan: ProfilerChan) -> ResourceManager {
+               profiler_chan: ProfilerChan) -> CoreResourceManager {
         let mut auth_cache = AuthCache::new();
         let mut cookie_jar = CookieStorage::new();
         if let Some(ref profile_dir) = opts::get().profile_dir {
@@ -385,7 +394,7 @@ impl ResourceManager {
             read_json_from_file(&mut hsts_list, profile_dir, "hsts_list.json");
             read_json_from_file(&mut cookie_jar, profile_dir, "cookie_jar.json");
         }
-        ResourceManager {
+        CoreResourceManager {
             user_agent: user_agent,
             cookie_jar: Arc::new(RwLock::new(cookie_jar)),
             auth_cache: Arc::new(RwLock::new(auth_cache)),
@@ -416,7 +425,7 @@ impl ResourceManager {
             load_data: LoadData,
             consumer: LoadConsumer,
             id_sender: Option<IpcSender<ResourceId>>,
-            resource_thread: ResourceThread) {
+            resource_thread: CoreResourceThread) {
 
         fn from_factory(factory: fn(LoadData, LoadConsumer, Arc<MIMEClassifier>, CancellationListener))
                         -> Box<FnBox(LoadData,