Use fetch in ScriptThread.

I did not find the prose that defines the creation of the request in the HTML
standard (if it exists).

components/script/dom/servoparser/mod.rs

@@ -28,7 +28,7 @@ use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper_serde::Serde;
 use js::jsapi::JSTracer;
 use msg::constellation_msg::PipelineId;
-use net_traits::{AsyncResponseListener, Metadata, NetworkError};
+use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError};
 use network_listener::PreInvoke;
 use profile_traits::time::{TimerMetadata, TimerMetadataFrameType};
 use profile_traits::time::{TimerMetadataReflowType, ProfilerCategory, profile};
@@ -332,11 +332,21 @@ impl ParserContext {
     }
 }
 
-impl AsyncResponseListener for ParserContext {
+impl FetchResponseListener for ParserContext {
-    fn headers_available(&mut self, meta_result: Result<Metadata, NetworkError>) {
+    fn process_request_body(&mut self) {}
+
+    fn process_request_eof(&mut self) {}
+
+    fn process_response(&mut self,
+                        meta_result: Result<FetchMetadata, NetworkError>) {
         let mut ssl_error = None;
         let metadata = match meta_result {
-            Ok(meta) => Some(meta),
+            Ok(meta) => {
+                Some(match meta {
+                    FetchMetadata::Unfiltered(m) => m,
+                    FetchMetadata::Filtered { unsafe_, .. } => unsafe_
+                })
+            },
             Err(NetworkError::SslValidation(url, reason)) => {
                 ssl_error = Some(reason);
                 let mut meta = Metadata::default(url);
@@ -408,7 +418,7 @@ impl AsyncResponseListener for ParserContext {
         }
     }
 
-    fn data_available(&mut self, payload: Vec<u8>) {
+    fn process_response_chunk(&mut self, payload: Vec<u8>) {
         if !self.is_synthesized_document {
             // FIXME: use Vec<u8> (html5ever #34)
             let data = UTF_8.decode(&payload, DecoderTrap::Replace).unwrap();
@@ -420,7 +430,7 @@ impl AsyncResponseListener for ParserContext {
         }
     }
 
-    fn response_complete(&mut self, status: Result<(), NetworkError>) {
+    fn process_response_eof(&mut self, status: Result<(), NetworkError>) {
         let parser = match self.parser.as_ref() {
             Some(parser) => parser.root(),
             None => return,

components/script/script_thread.rs

@@ -57,7 +57,7 @@ use dom::window::{ReflowReason, Window};
 use dom::worker::TrustedWorkerAddress;
 use euclid::Rect;
 use euclid::point::Point2D;
-use hyper::header::{ContentType, Headers, HttpDate, LastModified};
+use hyper::header::{ContentType, HttpDate, LastModified};
 use hyper::header::ReferrerPolicy as ReferrerPolicyHeader;
 use hyper::method::Method;
 use hyper::mime::{Mime, SubLevel, TopLevel};
@@ -72,10 +72,10 @@ use js::rust::Runtime;
 use layout_wrapper::ServoLayoutNode;
 use mem::heap_size_of_self_and_children;
 use msg::constellation_msg::{FrameType, PipelineId, PipelineNamespace, ReferrerPolicy};
-use net_traits::{AsyncResponseTarget, CoreResourceMsg, LoadConsumer, LoadContext, Metadata, ResourceThreads};
+use net_traits::{CoreResourceMsg, IpcSend, Metadata, ResourceThreads};
-use net_traits::{IpcSend, LoadData as NetLoadData};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
 use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheResult, ImageCacheThread};
+use net_traits::request::{CredentialsMode, Destination, RequestInit};
 use network_listener::NetworkListener;
 use profile_traits::mem::{self, OpaqueSender, Report, ReportKind, ReportsChan};
 use profile_traits::time::{self, ProfilerCategory, profile};
@@ -2114,30 +2114,29 @@ impl ScriptThread {
             wrapper: None,
         };
         ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
-            listener.notify_action(message.to().unwrap());
+            listener.notify_fetch(message.to().unwrap());
         });
-        let response_target = AsyncResponseTarget {
-            sender: action_sender,
-        };
 
         if load_data.url.scheme() == "javascript" {
             load_data.url = Url::parse("about:blank").unwrap();
         }
 
-        self.resource_threads.send(CoreResourceMsg::Load(NetLoadData {
+        let request = RequestInit {
-            context: LoadContext::Browsing,
+            url: load_data.url.clone(),
-            url: load_data.url,
             method: load_data.method,
-            headers: Headers::new(),
+            destination: Destination::Document,
-            preserved_headers: load_data.headers,
+            credentials_mode: CredentialsMode::Include,
-            data: load_data.data,
+            use_url_credentials: true,
-            cors: None,
+            origin: load_data.url,
             pipeline_id: Some(id),
-            credentials_flag: true,
+            referrer_url: load_data.referrer_url,
             referrer_policy: load_data.referrer_policy,
-            referrer_url: load_data.referrer_url
+            headers: load_data.headers,
-        }, LoadConsumer::Listener(response_target), None)).unwrap();
+            body: load_data.data,
+            .. RequestInit::default()
+        };
 
+        self.resource_threads.send(CoreResourceMsg::Fetch(request, action_sender)).unwrap();
         self.incomplete_loads.borrow_mut().push(incomplete);
     }