Rewrite load_whole_resource using the fetch stack.

components/net_traits/lib.rs

@@ -542,22 +542,28 @@ pub enum ProgressMsg {
 }
 
 /// Convenience function for synchronously loading a whole resource.
-pub fn load_whole_resource(context: LoadContext,
+pub fn load_whole_resource(request: RequestInit,
-                           core_resource_thread: &CoreResourceThread,
+                           core_resource_thread: &CoreResourceThread)
-                           url: Url,
+                           -> Result<(Metadata, Vec<u8>), NetworkError> {
-                           load_origin: &LoadOrigin)
+    let (action_sender, action_receiver) = ipc::channel().unwrap();
-        -> Result<(Metadata, Vec<u8>), NetworkError> {
+    core_resource_thread.send(CoreResourceMsg::Fetch(request, action_sender)).unwrap();
-    let (start_chan, start_port) = ipc::channel().unwrap();
-    let load_data = LoadData::new(context, url, load_origin);
-    core_resource_thread.send(CoreResourceMsg::Load(load_data, LoadConsumer::Channel(start_chan), None)).unwrap();
-    let response = start_port.recv().unwrap();
 
     let mut buf = vec!();
+    let mut metadata = None;
     loop {
-        match response.progress_port.recv().unwrap() {
+        match action_receiver.recv().unwrap() {
-            ProgressMsg::Payload(data) => buf.extend_from_slice(&data),
+            FetchResponseMsg::ProcessRequestBody |
-            ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)),
+            FetchResponseMsg::ProcessRequestEOF => (),
-            ProgressMsg::Done(Err(e)) => return Err(e)
+            FetchResponseMsg::ProcessResponse(Ok(m)) => {
+                metadata = Some(match m {
+                    FetchMetadata::Unfiltered(m) => m,
+                    FetchMetadata::Filtered { unsafe_, .. } => unsafe_
+                })
+            },
+            FetchResponseMsg::ProcessResponseChunk(data) => buf.extend_from_slice(&data),
+            FetchResponseMsg::ProcessResponseEOF(Ok(())) => return Ok((metadata.unwrap(), buf)),
+            FetchResponseMsg::ProcessResponse(Err(e)) |
+            FetchResponseMsg::ProcessResponseEOF(Err(e)) => return Err(e)
         }
     }
 }

components/script/dom/dedicatedworkerglobalscope.rs

@@ -27,7 +27,8 @@ use js::jsapi::{JSAutoCompartment, JSContext};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
 use msg::constellation_msg::PipelineId;
-use net_traits::{IpcSend, LoadContext, load_whole_resource};
+use net_traits::{IpcSend, load_whole_resource};
+use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
 use rand::random;
 use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, StackRootTLS, get_reports, new_rt_and_cx};
 use script_runtime::ScriptThreadEventCategory::WorkerEvent;
@@ -160,10 +161,24 @@ impl DedicatedWorkerGlobalScope {
 
             let roots = RootCollection::new();
             let _stack_roots_tls = StackRootTLS::new(&roots);
-            let (metadata, bytes) = match load_whole_resource(LoadContext::Script,
+
-                                                              &init.resource_threads.sender(),
+            let WorkerScriptLoadOrigin { referrer_url, referrer_policy, pipeline_id } = worker_load_origin;
-                                                              worker_url,
+
-                                                              &worker_load_origin) {
+            let request = RequestInit {
+                url: worker_url.clone(),
+                type_: RequestType::Script,
+                destination: Destination::Worker,
+                credentials_mode: CredentialsMode::Include,
+                use_url_credentials: true,
+                origin: worker_url,
+                pipeline_id: pipeline_id,
+                referrer_url: referrer_url,
+                referrer_policy: referrer_policy,
+                .. RequestInit::default()
+            };
+
+            let (metadata, bytes) = match load_whole_resource(request,
+                                                              &init.resource_threads.sender()) {
                 Err(_) => {
                     println!("error loading script {}", serialized_worker_url);
                     parent_sender.send(CommonScriptMsg::RunnableMsg(WorkerEvent,

components/script/dom/serviceworkerglobalscope.rs

@@ -23,10 +23,11 @@ use ipc_channel::router::ROUTER;
 use js::jsapi::{JS_SetInterruptCallback, JSAutoCompartment, JSContext};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
-use net_traits::{LoadContext, load_whole_resource, IpcSend, CustomResponseMediator};
+use net_traits::{load_whole_resource, IpcSend, CustomResponseMediator};
+use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
 use rand::random;
 use script_runtime::{CommonScriptMsg, StackRootTLS, get_reports, new_rt_and_cx, ScriptChan};
-use script_traits::{TimerEvent, WorkerGlobalScopeInit, ScopeThings, ServiceWorkerMsg};
+use script_traits::{TimerEvent, WorkerGlobalScopeInit, ScopeThings, ServiceWorkerMsg, WorkerScriptLoadOrigin};
 use std::sync::mpsc::{Receiver, RecvError, Select, Sender, channel};
 use std::thread;
 use std::time::Duration;
@@ -151,10 +152,24 @@ impl ServiceWorkerGlobalScope {
             thread_state::initialize(SCRIPT | IN_WORKER);
             let roots = RootCollection::new();
             let _stack_roots_tls = StackRootTLS::new(&roots);
-            let (url, source) = match load_whole_resource(LoadContext::Script,
+
-                                                          &init.resource_threads.sender(),
+            let WorkerScriptLoadOrigin { referrer_url, referrer_policy, pipeline_id } = worker_load_origin;
-                                                          script_url,
+
-                                                          &worker_load_origin) {
+            let request = RequestInit {
+                url: script_url.clone(),
+                type_: RequestType::Script,
+                destination: Destination::ServiceWorker,
+                credentials_mode: CredentialsMode::Include,
+                use_url_credentials: true,
+                origin: script_url,
+                pipeline_id: pipeline_id,
+                referrer_url: referrer_url,
+                referrer_policy: referrer_policy,
+                .. RequestInit::default()
+            };
+
+            let (url, source) = match load_whole_resource(request,
+                                                          &init.resource_threads.sender()) {
                 Err(_) => {
                     println!("error loading script {}", serialized_worker_url);
                     return;

components/script/dom/workerglobalscope.rs

@@ -27,9 +27,8 @@ use ipc_channel::ipc::IpcSender;
 use js::jsapi::{HandleValue, JSAutoCompartment, JSContext, JSRuntime};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
-use msg::constellation_msg::{PipelineId, ReferrerPolicy};
+use net_traits::{IpcSend, load_whole_resource};
-use net_traits::{IpcSend, LoadOrigin};
+use net_traits::request::{CredentialsMode, Destination, RequestInit as NetRequestInit, Type as RequestType};
-use net_traits::{LoadContext, load_whole_resource};
 use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, maybe_take_panic_result};
 use script_runtime::{ScriptThreadEventCategory, PromiseJobQueue, EnqueuedPromiseCallback};
 use script_thread::{Runnable, RunnableWrapper};
@@ -179,18 +178,6 @@ impl WorkerGlobalScope {
     }
 }
 
-impl LoadOrigin for WorkerGlobalScope {
-    fn referrer_url(&self) -> Option<Url> {
-        None
-    }
-    fn referrer_policy(&self) -> Option<ReferrerPolicy> {
-        None
-    }
-    fn pipeline_id(&self) -> Option<PipelineId> {
-        Some(self.upcast::<GlobalScope>().pipeline_id())
-    }
-}
-
 impl WorkerGlobalScopeMethods for WorkerGlobalScope {
     // https://html.spec.whatwg.org/multipage/#dom-workerglobalscope-self
     fn Self_(&self) -> Root<WorkerGlobalScope> {
@@ -221,10 +208,20 @@ impl WorkerGlobalScopeMethods for WorkerGlobalScope {
         rooted!(in(self.runtime.cx()) let mut rval = UndefinedValue());
         for url in urls {
             let global_scope = self.upcast::<GlobalScope>();
-            let (url, source) = match load_whole_resource(LoadContext::Script,
+            let request = NetRequestInit {
-                                                          &global_scope.resource_threads().sender(),
+                url: url.clone(),
-                                                          url,
+                type_: RequestType::Script,
-                                                          self) {
+                destination: Destination::Script,
+                credentials_mode: CredentialsMode::Include,
+                use_url_credentials: true,
+                origin: self.worker_url.clone(),
+                pipeline_id: Some(self.upcast::<GlobalScope>().pipeline_id()),
+                referrer_url: None,
+                referrer_policy: None,
+                .. NetRequestInit::default()
+            };
+            let (url, source) = match load_whole_resource(request,
+                                                          &global_scope.resource_threads().sender()) {
                 Err(_) => return Err(Error::Network),
                 Ok((metadata, bytes)) => {
                     (metadata.final_url, String::from_utf8(bytes).unwrap())