Pass a borrowed fetch context to fetch().

This will allow inspecting its state after fetching in unit tests.

components/net/fetch/methods.rs

@@ -63,7 +63,7 @@ type DoneChannel = Option<(Sender<Data>, Receiver<Data>)>;
 /// [Fetch](https://fetch.spec.whatwg.org#concept-fetch)
 pub fn fetch<UI: 'static + UIProvider>(request: Rc<Request>,
                                        target: &mut Target,
-                                       context: FetchContext<UI>)
+                                       context: &FetchContext<UI>)
                                        -> Response {
     fetch_with_cors_cache(request, &mut CORSCache::new(), target, context)
 }
@@ -71,7 +71,7 @@ pub fn fetch<UI: 'static + UIProvider>(request: Rc<Request>,
 pub fn fetch_with_cors_cache<UI: 'static + UIProvider>(request: Rc<Request>,
                                                        cache: &mut CORSCache,
                                                        target: &mut Target,
-                                                       context: FetchContext<UI>)
+                                                       context: &FetchContext<UI>)
                                                        -> Response {
     // Step 1
     if request.window.get() == Window::Client {

components/net/resource_thread.rs

@@ -586,7 +586,7 @@ impl CoreResourceManager {
                 devtools_chan: dc,
                 filemanager: filemanager,
             };
-            fetch(Rc::new(request), &mut target, context);
+            fetch(Rc::new(request), &mut target, &context);
         })
     }
 

tests/unit/net/fetch.rs

@@ -119,7 +119,7 @@ fn test_fetch_blob() {
 
 
     let request = Request::new(url, Some(Origin::Origin(origin.origin())), false, None);
-    let fetch_response = fetch(Rc::new(request), &mut None, context);
+    let fetch_response = fetch(Rc::new(request), &mut None, &context);
 
     assert!(!fetch_response.is_network_error());
 
@@ -231,9 +231,9 @@ fn test_cors_preflight_cache_fetch() {
     let wrapped_request1 = Rc::new(request);
 
     let fetch_response0 = fetch_with_cors_cache(wrapped_request0.clone(), &mut cache,
-                                                &mut None, new_fetch_context(None));
+                                                &mut None, &new_fetch_context(None));
     let fetch_response1 = fetch_with_cors_cache(wrapped_request1.clone(), &mut cache,
-                                                &mut None, new_fetch_context(None));
+                                                &mut None, &new_fetch_context(None));
     let _ = server.close();
 
     assert!(!fetch_response0.is_network_error() && !fetch_response1.is_network_error());

tests/unit/net/lib.rs

@@ -74,12 +74,12 @@ impl FetchTaskTarget for FetchResponseCollector {
 
 fn fetch_async(request: Request, target: Box<FetchTaskTarget + Send>, dc: Option<Sender<DevtoolsControlMsg>>) {
     thread::spawn(move || {
-        fetch(Rc::new(request), &mut Some(target), new_fetch_context(dc));
+        fetch(Rc::new(request), &mut Some(target), &new_fetch_context(dc));
     });
 }
 
 fn fetch_sync(request: Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Response {
-    fetch(Rc::new(request), &mut None, new_fetch_context(dc))
+    fetch(Rc::new(request), &mut None, &new_fetch_context(dc))
 }
 
 fn make_server<H: Handler + 'static>(handler: H) -> (Listening, Url) {