servo: Merge #17491 - Introduce service-worker mode (from KiChjang:update-fetch); r=jdm

Bringing in the spec changes from whatwg/fetch#435.

Source-Repo: https://github.com/servo/servo
Source-Revision: e2a26e7bd0d8089a441bc3072cf15351b0ef1252

--HG--
extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear
extra : subtree_revision : 05549195b43020dcd02768bcd79cef5f7ed4b813

Author: KiChjang

servo/components/net/http_loader.rs

@@ -34,7 +34,7 @@ use msg::constellation_msg::PipelineId;
 use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
 use net_traits::request::{CacheMode, CredentialsMode, Destination, Origin};
 use net_traits::request::{RedirectMode, Referrer, Request, RequestMode};
-use net_traits::request::{ResponseTainting, Type};
+use net_traits::request::{ResponseTainting, ServiceWorkersMode, Type};
 use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
 use resource_thread::AuthCache;
 use servo_url::{ImmutableOrigin, ServoUrl};
@@ -521,15 +521,29 @@ pub fn http_fetch(request: &mut Request,
     // nothing to do, since actual_response is a function on response
 
     // Step 3
-    if !request.skip_service_worker && !request.is_service_worker_global_scope {
+    if request.service_workers_mode != ServiceWorkersMode::None {
         // Substep 1
-        // TODO (handle fetch unimplemented)
+        if request.service_workers_mode == ServiceWorkersMode::All {
+            // TODO (handle fetch unimplemented)
+        }
 
+        // Substep 2
+        if response.is_none() && request.is_subresource_request() && match request.origin {
+            Origin::Origin(ref origin) if *origin == request.url().origin() => true,
+            _ => false,
+        } {
+            // TODO (handle foreign fetch unimplemented)
+        }
+
+        // Substep 3
         if let Some(ref res) = response {
-            // Substep 2
+            // Subsubstep 1
+            // TODO: transmit body for request
+
+            // Subsubstep 2
             // nothing to do, since actual_response is a function on response
 
-            // Substep 3
+            // Subsubstep 3
             if (res.response_type == ResponseType::Opaque &&
                 request.mode != RequestMode::NoCors) ||
                (res.response_type == ResponseType::OpaqueRedirect &&
@@ -539,7 +553,7 @@ pub fn http_fetch(request: &mut Request,
                 return Response::network_error(NetworkError::Internal("Request failed".into()));
             }
 
-            // Substep 4
+            // Subsubstep 4
             // TODO: set response's CSP list on actual_response
         }
     }
@@ -576,7 +590,9 @@ pub fn http_fetch(request: &mut Request,
         }
 
         // Substep 2
-        request.skip_service_worker = true;
+        if request.redirect_mode == RedirectMode::Follow {
+            request.service_workers_mode = ServiceWorkersMode::Foreign;
+        }
 
         // Substep 3
         let mut fetch_result = http_network_or_cache_fetch(
@@ -1238,8 +1254,7 @@ fn cors_preflight_fetch(request: &Request,
                         context: &FetchContext)
                         -> Response {
     // Step 1
-    let mut preflight = Request::new(request.current_url(), Some(request.origin.clone()),
-                                     request.is_service_worker_global_scope, request.pipeline_id);
+    let mut preflight = Request::new(request.current_url(), Some(request.origin.clone()), request.pipeline_id);
     preflight.method = Method::Options;
     preflight.initiator = request.initiator.clone();
     preflight.type_ = request.type_.clone();

servo/components/net_traits/request.rs

@@ -97,6 +97,14 @@ pub enum CacheMode {
     OnlyIfCached,
 }
 
+/// [Service-workers mode](https://fetch.spec.whatwg.org/#request-service-workers-mode)
+#[derive(Copy, Clone, PartialEq, Serialize, Deserialize, HeapSizeOf)]
+pub enum ServiceWorkersMode {
+    All,
+    Foreign,
+    None,
+}
+
 /// [Redirect mode](https://fetch.spec.whatwg.org/#concept-request-redirect-mode)
 #[derive(Copy, Clone, PartialEq, Serialize, Deserialize, HeapSizeOf)]
 pub enum RedirectMode {
@@ -140,6 +148,7 @@ pub struct RequestInit {
     pub headers: Headers,
     pub unsafe_request: bool,
     pub body: Option<Vec<u8>>,
+    pub service_workers_mode: ServiceWorkersMode,
     // TODO: client object
     pub type_: Type,
     pub destination: Destination,
@@ -170,6 +179,7 @@ impl Default for RequestInit {
             headers: Headers::new(),
             unsafe_request: false,
             body: None,
+            service_workers_mode: ServiceWorkersMode::All,
             type_: Type::None,
             destination: Destination::None,
             synchronous: false,
@@ -208,12 +218,12 @@ pub struct Request {
     /// https://fetch.spec.whatwg.org/#concept-request-body
     pub body: Option<Vec<u8>>,
     // TODO: client object
-    pub is_service_worker_global_scope: bool,
     pub window: Window,
     // TODO: target browsing context
     /// https://fetch.spec.whatwg.org/#request-keepalive-flag
     pub keep_alive: bool,
-    pub skip_service_worker: bool,
+    // https://fetch.spec.whatwg.org/#request-service-workers-mode
+    pub service_workers_mode: ServiceWorkersMode,
     /// https://fetch.spec.whatwg.org/#concept-request-initiator
     pub initiator: Initiator,
     /// https://fetch.spec.whatwg.org/#concept-request-type
@@ -257,7 +267,6 @@ pub struct Request {
 impl Request {
     pub fn new(url: ServoUrl,
                origin: Option<Origin>,
-               is_service_worker_global_scope: bool,
                pipeline_id: Option<PipelineId>)
                -> Request {
         Request {
@@ -267,10 +276,9 @@ impl Request {
             headers: Headers::new(),
             unsafe_request: false,
             body: None,
-            is_service_worker_global_scope: is_service_worker_global_scope,
             window: Window::Client,
             keep_alive: false,
-            skip_service_worker: false,
+            service_workers_mode: ServiceWorkersMode::All,
             initiator: Initiator::None,
             type_: Type::None,
             destination: Destination::None,
@@ -295,12 +303,12 @@ impl Request {
     pub fn from_init(init: RequestInit) -> Request {
         let mut req = Request::new(init.url.clone(),
                                    Some(Origin::Origin(init.origin.origin())),
-                                   false,
                                    init.pipeline_id);
         req.method = init.method;
         req.headers = init.headers;
         req.unsafe_request = init.unsafe_request;
         req.body = init.body;
+        req.service_workers_mode = init.service_workers_mode;
         req.type_ = init.type_;
         req.destination = init.destination;
         req.synchronous = init.synchronous;

servo/components/script/dom/request.rs

@@ -55,14 +55,11 @@ pub struct Request {
 
 impl Request {
     fn new_inherited(global: &GlobalScope,
-                     url: ServoUrl,
-                     is_service_worker_global_scope: bool) -> Request {
+                     url: ServoUrl) -> Request {
         Request {
             reflector_: Reflector::new(),
             request: DOMRefCell::new(
-                net_request_from_global(global,
-                                        url,
-                                        is_service_worker_global_scope)),
+                net_request_from_global(global, url)),
             body_used: Cell::new(false),
             headers: Default::default(),
             mime_type: DOMRefCell::new("".to_string().into_bytes()),
@@ -71,11 +68,9 @@ impl Request {
     }
 
     pub fn new(global: &GlobalScope,
-               url: ServoUrl,
-               is_service_worker_global_scope: bool) -> Root<Request> {
+               url: ServoUrl) -> Root<Request> {
         reflect_dom_object(box Request::new_inherited(global,
-                                                      url,
-                                                      is_service_worker_global_scope),
+                                                      url),
                            global, RequestBinding::Wrap)
     }
 
@@ -111,9 +106,7 @@ impl Request {
                     return Err(Error::Type("Url includes credentials".to_string()))
                 }
                 // Step 5.4
-                temporary_request = net_request_from_global(global,
-                                                            url,
-                                                            false);
+                temporary_request = net_request_from_global(global, url);
                 // Step 5.5
                 fallback_mode = Some(NetTraitsRequestMode::CorsMode);
                 // Step 5.6
@@ -152,9 +145,7 @@ impl Request {
 
         // Step 12
         let mut request: NetTraitsRequest;
-        request = net_request_from_global(global,
-                                          temporary_request.current_url(),
-                                          false);
+        request = net_request_from_global(global, temporary_request.current_url());
         request.method = temporary_request.method;
         request.headers = temporary_request.headers.clone();
         request.unsafe_request = true;
@@ -293,9 +284,7 @@ impl Request {
         }
 
         // Step 26
-        let r = Request::from_net_request(global,
-                                          false,
-                                          request);
+        let r = Request::from_net_request(global, request);
         r.headers.or_init(|| Headers::for_request(&r.global()));
 
         // Step 27
@@ -421,23 +410,20 @@ impl Request {
 
 impl Request {
     fn from_net_request(global: &GlobalScope,
-                        is_service_worker_global_scope: bool,
                         net_request: NetTraitsRequest) -> Root<Request> {
         let r = Request::new(global,
-                             net_request.current_url(),
-                             is_service_worker_global_scope);
+                             net_request.current_url());
         *r.request.borrow_mut() = net_request;
         r
     }
 
     fn clone_from(r: &Request) -> Fallible<Root<Request>> {
         let req = r.request.borrow();
         let url = req.url();
-        let is_service_worker_global_scope = req.is_service_worker_global_scope;
         let body_used = r.body_used.get();
         let mime_type = r.mime_type.borrow().clone();
         let headers_guard = r.Headers().get_guard();
-        let r_clone = Request::new(&r.global(), url, is_service_worker_global_scope);
+        let r_clone = Request::new(&r.global(), url);
         r_clone.request.borrow_mut().pipeline_id = req.pipeline_id;
         {
             let mut borrowed_r_request = r_clone.request.borrow_mut();
@@ -457,13 +443,11 @@ impl Request {
 }
 
 fn net_request_from_global(global: &GlobalScope,
-                           url: ServoUrl,
-                           is_service_worker_global_scope: bool) -> NetTraitsRequest {
+                           url: ServoUrl) -> NetTraitsRequest {
     let origin = Origin::Origin(global.get_url().origin());
     let pipeline_id = global.pipeline_id();
     NetTraitsRequest::new(url,
                           Some(origin),
-                          is_service_worker_global_scope,
                           Some(pipeline_id))
 }
 

servo/components/script/fetch.rs

@@ -7,6 +7,7 @@ use dom::bindings::codegen::Bindings::RequestBinding::RequestInit;
 use dom::bindings::codegen::Bindings::ResponseBinding::ResponseBinding::ResponseMethods;
 use dom::bindings::codegen::Bindings::ResponseBinding::ResponseType as DOMResponseType;
 use dom::bindings::error::Error;
+use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::{Trusted, TrustedPromise};
 use dom::bindings::reflector::DomObject;
@@ -16,13 +17,14 @@ use dom::headers::Guard;
 use dom::promise::Promise;
 use dom::request::Request;
 use dom::response::Response;
+use dom::serviceworkerglobalscope::ServiceWorkerGlobalScope;
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use js::jsapi::JSAutoCompartment;
 use net_traits::{FetchResponseListener, NetworkError};
 use net_traits::{FilteredMetadata, FetchMetadata, Metadata};
 use net_traits::CoreResourceMsg::Fetch as NetTraitsFetch;
-use net_traits::request::Request as NetTraitsRequest;
+use net_traits::request::{Request as NetTraitsRequest, ServiceWorkersMode};
 use net_traits::request::RequestInit as NetTraitsRequestInit;
 use network_listener::{NetworkListener, PreInvoke};
 use servo_url::ServoUrl;
@@ -83,12 +85,17 @@ pub fn Fetch(global: &GlobalScope, input: RequestInfo, init: RootedTraceableBox<
         },
         Ok(r) => r.get_request(),
     };
-    let request_init = request_init_from_request(request);
+    let mut request_init = request_init_from_request(request);
 
     // Step 3
-    response.Headers().set_guard(Guard::Immutable);
+    if global.downcast::<ServiceWorkerGlobalScope>().is_some() {
+        request_init.service_workers_mode = ServiceWorkersMode::Foreign;
+    }
 
     // Step 4
+    response.Headers().set_guard(Guard::Immutable);
+
+    // Step 5
     let (action_sender, action_receiver) = ipc::channel().unwrap();
     let fetch_context = Arc::new(Mutex::new(FetchContext {
         fetch_promise: Some(TrustedPromise::new(promise.clone())),

servo/tests/unit/net/data_loader.rs

@@ -19,7 +19,7 @@ fn assert_parse(url:          &'static str,
                 data:         Option<&[u8]>) {
     let url = ServoUrl::parse(url).unwrap();
     let origin = Origin::Origin(url.origin());
-    let mut request = Request::new(url, Some(origin), false, None);
+    let mut request = Request::new(url, Some(origin), None);
 
     let response = fetch(&mut request, None);