Redirect document loads manually

components/net/http_loader.rs

@@ -674,14 +674,14 @@ pub fn http_fetch(request: &mut Request,
 }
 
 /// [HTTP redirect fetch](https://fetch.spec.whatwg.org#http-redirect-fetch)
-fn http_redirect_fetch(request: &mut Request,
-                       cache: &mut CorsCache,
-                       response: Response,
-                       cors_flag: bool,
-                       target: Target,
-                       done_chan: &mut DoneChannel,
-                       context: &FetchContext)
-                       -> Response {
+pub fn http_redirect_fetch(request: &mut Request,
+                           cache: &mut CorsCache,
+                           response: Response,
+                           cors_flag: bool,
+                           target: Target,
+                           done_chan: &mut DoneChannel,
+                           context: &FetchContext)
+                           -> Response {
     // Step 1
     assert!(response.return_internal);
 
@@ -749,8 +749,10 @@ fn http_redirect_fetch(request: &mut Request,
     // Step 12
     // TODO implement referrer policy
 
+    let recursive_flag = request.redirect_mode != RedirectMode::Manual;
+
     // Step 13
-    main_fetch(request, cache, cors_flag, true, target, done_chan, context)
+    main_fetch(request, cache, cors_flag, recursive_flag, target, done_chan, context)
 }
 
 fn try_immutable_origin_to_hyper_origin(url_origin: &ImmutableOrigin) -> Option<HyperOrigin> {
@@ -1108,6 +1110,7 @@ fn http_network_fetch(request: &Request,
                                 res.response.status_raw().1.as_bytes().to_vec()));
     response.headers = res.response.headers.clone();
     response.referrer = request.referrer.to_url().cloned();
+    response.referrer_policy = request.referrer_policy.clone();
 
     let res_body = response.body.clone();
 

components/net/lib.rs

@@ -52,7 +52,7 @@ mod data_loader;
 pub mod filemanager_thread;
 mod hosts;
 pub mod hsts;
-mod http_loader;
+pub mod http_loader;
 pub mod image_cache;
 pub mod mime_classifier;
 pub mod resource_thread;

components/net/resource_thread.rs

@@ -8,10 +8,11 @@ use cookie;
 use cookie_rs;
 use cookie_storage::CookieStorage;
 use devtools_traits::DevtoolsControlMsg;
+use fetch::cors_cache::CorsCache;
 use fetch::methods::{FetchContext, fetch};
 use filemanager_thread::{FileManager, TFDProvider};
 use hsts::HstsList;
-use http_loader::HttpState;
+use http_loader::{HttpState, http_redirect_fetch};
 use hyper_serde::Serde;
 use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender};
 use net_traits::{CookieSource, CoreResourceThread};
@@ -19,6 +20,7 @@ use net_traits::{CoreResourceMsg, FetchResponseMsg};
 use net_traits::{CustomResponseMediator, ResourceId};
 use net_traits::{ResourceThreads, WebSocketCommunicate, WebSocketConnectData};
 use net_traits::request::{Request, RequestInit};
+use net_traits::response::{Response, ResponseInit};
 use net_traits::storage_thread::StorageThreadMsg;
 use profile_traits::time::ProfilerChan;
 use serde::{Deserialize, Serialize};
@@ -153,8 +155,10 @@ impl ResourceChannelManager {
                    msg: CoreResourceMsg,
                    http_state: &Arc<HttpState>) -> bool {
         match msg {
-            CoreResourceMsg::Fetch(init, sender) =>
-                self.resource_manager.fetch(init, sender, http_state),
+            CoreResourceMsg::Fetch(req_init, sender) =>
+                self.resource_manager.fetch(req_init, None, sender, http_state),
+            CoreResourceMsg::FetchRedirect(req_init, res_init, sender) =>
+                self.resource_manager.fetch(req_init, Some(res_init), sender, http_state),
             CoreResourceMsg::WebsocketConnect(connect, connect_data) =>
                 self.resource_manager.websocket_connect(connect, connect_data, http_state),
             CoreResourceMsg::SetCookieForUrl(request, cookie, source) =>
@@ -318,7 +322,8 @@ impl CoreResourceManager {
     }
 
     fn fetch(&self,
-             init: RequestInit,
+             req_init: RequestInit,
+             res_init_: Option<ResponseInit>,
              mut sender: IpcSender<FetchResponseMsg>,
              http_state: &Arc<HttpState>) {
         let http_state = http_state.clone();
@@ -326,8 +331,8 @@ impl CoreResourceManager {
         let dc = self.devtools_chan.clone();
         let filemanager = self.filemanager.clone();
 
-        thread::Builder::new().name(format!("fetch thread for {}", init.url)).spawn(move || {
-            let mut request = Request::from_init(init);
+        thread::Builder::new().name(format!("fetch thread for {}", req_init.url)).spawn(move || {
+            let mut request = Request::from_init(req_init);
             // XXXManishearth: Check origin against pipeline id (also ensure that the mode is allowed)
             // todo load context / mimesniff in fetch
             // todo referrer policy?
@@ -338,7 +343,20 @@ impl CoreResourceManager {
                 devtools_chan: dc,
                 filemanager: filemanager,
             };
-            fetch(&mut request, &mut sender, &context);
+
+            match res_init_ {
+                Some(res_init) => {
+                    let response = Response::from_init(res_init);
+                    http_redirect_fetch(&mut request,
+                                        &mut CorsCache::new(),
+                                        response,
+                                        true,
+                                        &mut sender,
+                                        &mut None,
+                                        &context);
+                },
+                None => fetch(&mut request, &mut sender, &context),
+            };
         }).expect("Thread spawning failed");
     }