From c3c6df69b44dccf038e04ac93f783d1da97c163e Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Wed, 12 Oct 2016 16:44:02 +0200 Subject: [PATCH] Rewrite load_whole_resource using the fetch stack. --- components/net_traits/lib.rs | 32 ++++++++++------- .../script/dom/dedicatedworkerglobalscope.rs | 25 ++++++++++--- .../script/dom/serviceworkerglobalscope.rs | 27 ++++++++++---- components/script/dom/workerglobalscope.rs | 35 +++++++++---------- 4 files changed, 76 insertions(+), 43 deletions(-) diff --git a/components/net_traits/lib.rs b/components/net_traits/lib.rs index 39c5d0f8776..7b666a0cde8 100644 --- a/components/net_traits/lib.rs +++ b/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, - core_resource_thread: &CoreResourceThread, - url: Url, - load_origin: &LoadOrigin) - -> Result<(Metadata, Vec), NetworkError> { - 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(); +pub fn load_whole_resource(request: RequestInit, + core_resource_thread: &CoreResourceThread) + -> Result<(Metadata, Vec), NetworkError> { + let (action_sender, action_receiver) = ipc::channel().unwrap(); + core_resource_thread.send(CoreResourceMsg::Fetch(request, action_sender)).unwrap(); let mut buf = vec!(); + let mut metadata = None; loop { - match response.progress_port.recv().unwrap() { - ProgressMsg::Payload(data) => buf.extend_from_slice(&data), - ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)), - ProgressMsg::Done(Err(e)) => return Err(e) + match action_receiver.recv().unwrap() { + FetchResponseMsg::ProcessRequestBody | + FetchResponseMsg::ProcessRequestEOF => (), + 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) } } } diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs index 1dd69a26159..86aac32df1b 100644 --- a/components/script/dom/dedicatedworkerglobalscope.rs +++ b/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(), - worker_url, - &worker_load_origin) { + + let WorkerScriptLoadOrigin { referrer_url, referrer_policy, pipeline_id } = 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, diff --git a/components/script/dom/serviceworkerglobalscope.rs b/components/script/dom/serviceworkerglobalscope.rs index 10d01d4b41a..021e93399b8 100644 --- a/components/script/dom/serviceworkerglobalscope.rs +++ b/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(), - script_url, - &worker_load_origin) { + + let WorkerScriptLoadOrigin { referrer_url, referrer_policy, pipeline_id } = 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; diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs index 8cd09b3fdbe..2efa2920cb8 100644 --- a/components/script/dom/workerglobalscope.rs +++ b/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, LoadOrigin}; -use net_traits::{LoadContext, load_whole_resource}; +use net_traits::{IpcSend, load_whole_resource}; +use net_traits::request::{CredentialsMode, Destination, RequestInit as NetRequestInit, Type as RequestType}; 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 { - None - } - fn referrer_policy(&self) -> Option { - None - } - fn pipeline_id(&self) -> Option { - Some(self.upcast::().pipeline_id()) - } -} - impl WorkerGlobalScopeMethods for WorkerGlobalScope { // https://html.spec.whatwg.org/multipage/#dom-workerglobalscope-self fn Self_(&self) -> Root { @@ -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::(); - let (url, source) = match load_whole_resource(LoadContext::Script, - &global_scope.resource_threads().sender(), - url, - self) { + let request = NetRequestInit { + url: url.clone(), + type_: RequestType::Script, + destination: Destination::Script, + credentials_mode: CredentialsMode::Include, + use_url_credentials: true, + origin: self.worker_url.clone(), + pipeline_id: Some(self.upcast::().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())