Integrate service worker manager thread

components/net/file_loader.rs

@@ -7,7 +7,7 @@ use mime_classifier::MimeClassifier;
 use mime_guess::guess_mime_type;
 use msg::constellation_msg::{PipelineId, ReferrerPolicy};
 use net_traits::ProgressMsg::{Done, Payload};
-use net_traits::{LoadConsumer, LoadData, Metadata, NetworkError, LoadOrigin, RequestSource};
+use net_traits::{LoadConsumer, LoadData, Metadata, NetworkError, LoadOrigin};
 use resource_thread::{CancellationListener, ProgressSender};
 use resource_thread::{send_error, start_sending_sniffed_opt};
 use std::borrow::ToOwned;
@@ -39,9 +39,6 @@ impl LoadOrigin for FileLoadOrigin {
     fn referrer_policy(&self) -> Option<ReferrerPolicy> {
         None
     }
-    fn request_source(&self) -> RequestSource {
-        RequestSource::None
-    }
     fn pipeline_id(&self) -> Option<PipelineId> {
         None
     }

components/net/http_loader.rs

@@ -24,7 +24,7 @@ use hyper::method::Method;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper::net::Fresh;
 use hyper::status::{StatusClass, StatusCode};
-use ipc_channel::ipc;
+use ipc_channel::ipc::{self, IpcSender};
 use log;
 use mime_classifier::MimeClassifier;
 use msg::constellation_msg::{PipelineId, ReferrerPolicy};
@@ -32,7 +32,7 @@ use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::hosts::replace_hosts;
 use net_traits::response::HttpsState;
 use net_traits::{CookieSource, IncludeSubdomains, LoadConsumer, LoadContext, LoadData};
-use net_traits::{Metadata, NetworkError, RequestSource, CustomResponse};
+use net_traits::{Metadata, NetworkError, CustomResponse, CustomResponseMediator};
 use openssl;
 use openssl::ssl::error::{SslError, OpensslError};
 use profile_traits::time::{ProfilerCategory, profile, ProfilerChan, TimerMetadata};
@@ -59,6 +59,7 @@ pub fn factory(user_agent: String,
                http_state: HttpState,
                devtools_chan: Option<Sender<DevtoolsControlMsg>>,
                profiler_chan: ProfilerChan,
+               constellation_chan: Option<IpcSender<CustomResponseMediator>>,
                connector: Arc<Pool<Connector>>)
                -> Box<FnBox(LoadData,
                             LoadConsumer,
@@ -78,6 +79,7 @@ pub fn factory(user_agent: String,
                                   connector,
                                   http_state,
                                   devtools_chan,
+                                  constellation_chan,
                                   cancel_listener,
                                   user_agent)
             })
@@ -131,6 +133,7 @@ fn load_for_consumer(load_data: LoadData,
                      connector: Arc<Pool<Connector>>,
                      http_state: HttpState,
                      devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+                     constellation_chan: Option<IpcSender<CustomResponseMediator>>,
                      cancel_listener: CancellationListener,
                      user_agent: String) {
     let factory = NetworkHttpRequestFactory {
@@ -140,7 +143,7 @@ fn load_for_consumer(load_data: LoadData,
     let ui_provider = TFDProvider;
     match load(&load_data, &ui_provider, &http_state,
                devtools_chan, &factory,
-               user_agent, &cancel_listener) {
+               user_agent, &cancel_listener, constellation_chan) {
         Err(error) => {
             match error.error {
                 LoadErrorType::ConnectionAborted { .. } => unreachable!(),
@@ -860,7 +863,8 @@ pub fn load<A, B>(load_data: &LoadData,
                   devtools_chan: Option<Sender<DevtoolsControlMsg>>,
                   request_factory: &HttpRequestFactory<R=A>,
                   user_agent: String,
-                  cancel_listener: &CancellationListener)
+                  cancel_listener: &CancellationListener,
+                  constellation_chan: Option<IpcSender<CustomResponseMediator>>)
                   -> Result<StreamedResponse, LoadError> where A: HttpRequest + 'static, B: UIProvider {
     let max_redirects = PREFS.get("network.http.redirection-limit").as_i64().unwrap() as u32;
     let mut iters = 0;
@@ -878,17 +882,19 @@ pub fn load<A, B>(load_data: &LoadData,
     }
 
     let (msg_sender, msg_receiver) = ipc::channel().unwrap();
-    match load_data.source {
-        RequestSource::Window(ref sender) | RequestSource::Worker(ref sender) => {
-            sender.send(msg_sender.clone()).unwrap();
-            let received_msg = msg_receiver.recv().unwrap();
-            if let Some(custom_response) = received_msg {
-                let metadata = Metadata::default(doc_url.clone());
-                let readable_response = to_readable_response(custom_response);
-                return StreamedResponse::from_http_response(box readable_response, metadata);
-            }
+    let response_mediator = CustomResponseMediator {
+        response_chan: msg_sender,
+        load_url: doc_url.clone()
+    };
+    if let Some(sender) = constellation_chan {
+        let _ = sender.send(response_mediator);
+        if let Ok(Some(custom_response)) = msg_receiver.try_recv() {
+            let metadata = Metadata::default(doc_url.clone());
+            let readable_response = to_readable_response(custom_response);
+            return StreamedResponse::from_http_response(box readable_response, metadata);
         }
-        RequestSource::None => {}
+    } else {
+        debug!("Did not receive a custom response");
     }
 
     // If the URL is a view-source scheme then the scheme data contains the

components/net/image_cache_thread.rs

@@ -11,7 +11,7 @@ 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, CoreResourceMsg, LoadConsumer, LoadData, CoreResourceThread, LoadOrigin};
-use net_traits::{ResponseAction, LoadContext, NetworkError, RequestSource};
+use net_traits::{ResponseAction, LoadContext, NetworkError};
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
@@ -313,9 +313,6 @@ impl LoadOrigin for ImageCacheOrigin {
     fn referrer_policy(&self) -> Option<ReferrerPolicy> {
         None
     }
-    fn request_source(&self) -> RequestSource {
-        RequestSource::None
-    }
     fn pipeline_id(&self) -> Option<PipelineId> {
         None
     }

components/net/resource_thread.rs

@@ -30,7 +30,7 @@ use net_traits::request::{Request, RequestInit};
 use net_traits::storage_thread::StorageThreadMsg;
 use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResponseAction, CoreResourceThread};
 use net_traits::{CoreResourceMsg, CookieSource, FetchResponseMsg, FetchTaskTarget, LoadConsumer};
-use net_traits::{LoadData, LoadResponse, NetworkError, ResourceId};
+use net_traits::{LoadData, LoadResponse, NetworkError, ResourceId, CustomResponseMediator};
 use net_traits::{WebSocketCommunicate, WebSocketConnectData, ResourceThreads};
 use profile_traits::time::ProfilerChan;
 use rustc_serialize::json;
@@ -202,7 +202,7 @@ pub fn new_core_resource_thread(user_agent: String,
 }
 
 struct ResourceChannelManager {
-    resource_manager: CoreResourceManager,
+    resource_manager: CoreResourceManager
 }
 
 fn create_resource_groups() -> (ResourceGroup, ResourceGroup) {
@@ -279,6 +279,9 @@ impl ResourceChannelManager {
                 let mut cookie_jar = group.cookie_jar.write().unwrap();
                 consumer.send(cookie_jar.cookies_for_url(&url, source)).unwrap();
             }
+            CoreResourceMsg::NetworkMediator(mediator_chan) => {
+                self.resource_manager.constellation_chan = Some(mediator_chan)
+            }
             CoreResourceMsg::GetCookiesDataForUrl(url, consumer, source) => {
                 let mut cookie_jar = group.cookie_jar.write().unwrap();
                 let cookies = cookie_jar.cookies_data_for_url(&url, source).collect();
@@ -456,6 +459,7 @@ pub struct CoreResourceManager {
     user_agent: String,
     mime_classifier: Arc<MimeClassifier>,
     devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+    constellation_chan: Option<IpcSender<CustomResponseMediator>>,
     profiler_chan: ProfilerChan,
     filemanager_chan: IpcSender<FileManagerThreadMsg>,
     cancel_load_map: HashMap<ResourceId, Sender<()>>,
@@ -471,6 +475,7 @@ impl CoreResourceManager {
             user_agent: user_agent,
             mime_classifier: Arc::new(MimeClassifier::new()),
             devtools_chan: devtools_channel,
+            constellation_chan: None,
             profiler_chan: profiler_chan,
             filemanager_chan: filemanager_chan,
             cancel_load_map: HashMap::new(),
@@ -542,6 +547,7 @@ impl CoreResourceManager {
                                      http_state,
                                      self.devtools_chan.clone(),
                                      self.profiler_chan.clone(),
+                                     self.constellation_chan.clone(),
                                      resource_grp.connector.clone())
             },
             "data" => from_factory(data_loader::factory),