Simplify fetching code.

components/gfx/font_cache_thread.rs

@@ -7,7 +7,7 @@ use fontsan;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use mime::{TopLevel, SubLevel};
-use net_traits::{AsyncResponseTarget, LoadContext, PendingAsyncLoad, CoreResourceThread, ResponseAction};
+use net_traits::{AsyncResponseTarget, LoadContext, CoreResourceThread, ResponseAction, load_async};
 use platform::font_context::FontContextHandle;
 use platform::font_list::SANS_SERIF_FONT_FAMILY;
 use platform::font_list::for_each_available_family;
@@ -208,17 +208,17 @@ impl FontCache {
         match src {
             Source::Url(ref url_source) => {
                 let url = &url_source.url;
-                let load = PendingAsyncLoad::new(LoadContext::Font,
-                                                 self.core_resource_thread.clone(),
-                                                 url.clone(),
-                                                 None,
-                                                 None,
-                                                 None);
                 let (data_sender, data_receiver) = ipc::channel().unwrap();
                 let data_target = AsyncResponseTarget {
                     sender: data_sender,
                 };
-                load.load_async(data_target);
+                load_async(LoadContext::Font,
+                           self.core_resource_thread.clone(),
+                           url.clone(),
+                           None,
+                           None,
+                           None,
+                           data_target);
                 let channel_to_self = self.channel_to_self.clone();
                 let url = (*url).clone();
                 let bytes = Mutex::new(Vec::new());

components/net_traits/lib.rs

@@ -44,7 +44,6 @@ use msg::constellation_msg::{PipelineId, ReferrerPolicy};
 use request::{Request, RequestInit};
 use response::{HttpsState, Response};
 use std::io::Error as IOError;
-use std::thread;
 use storage_thread::StorageThreadMsg;
 use url::Url;
 use websocket::header;
@@ -467,35 +466,13 @@ pub enum CoreResourceMsg {
 /// Initialized but unsent request. Encapsulates everything necessary to instruct
 /// the resource thread to make a new request. The `load` method *must* be called before
 /// destruction or the thread will panic.
-pub struct PendingAsyncLoad {
-    core_resource_thread: CoreResourceThread,
-    url: Url,
+struct LoadOriginData {
     pipeline: Option<PipelineId>,
-    guard: PendingLoadGuard,
-    context: LoadContext,
     referrer_policy: Option<ReferrerPolicy>,
     referrer_url: Option<Url>
 }
 
-struct PendingLoadGuard {
-    loaded: bool,
-}
-
-impl PendingLoadGuard {
-    fn neuter(&mut self) {
-        self.loaded = true;
-    }
-}
-
-impl Drop for PendingLoadGuard {
-    fn drop(&mut self) {
-        if !thread::panicking() {
-            assert!(self.loaded)
-        }
-    }
-}
-
-impl LoadOrigin for PendingAsyncLoad {
+impl LoadOrigin for LoadOriginData {
     fn referrer_url(&self) -> Option<Url> {
         self.referrer_url.clone()
     }
@@ -507,42 +484,22 @@ impl LoadOrigin for PendingAsyncLoad {
     }
 }
 
-impl PendingAsyncLoad {
-    pub fn new(context: LoadContext,
-               core_resource_thread: CoreResourceThread,
-               url: Url,
-               pipeline: Option<PipelineId>,
-               referrer_policy: Option<ReferrerPolicy>,
-               referrer_url: Option<Url>)
-               -> PendingAsyncLoad {
-        PendingAsyncLoad {
-            core_resource_thread: core_resource_thread,
-            url: url,
-            pipeline: pipeline,
-            guard: PendingLoadGuard { loaded: false, },
-            context: context,
-            referrer_policy: referrer_policy,
-            referrer_url: referrer_url
-        }
-    }
-
-    /// Initiate the network request associated with this pending load, using the provided target.
-    pub fn load_async(mut self, listener: AsyncResponseTarget) {
-        self.guard.neuter();
-
-        let load_data = LoadData::new(self.context.clone(),
-                                      self.url.clone(),
-                                      &self);
-        let consumer = LoadConsumer::Listener(listener);
-        self.core_resource_thread.send(CoreResourceMsg::Load(load_data, consumer, None)).unwrap();
-    }
-
-    /// Initiate the fetch associated with this pending load.
-    pub fn fetch_async(mut self, request: RequestInit, fetch_target: IpcSender<FetchResponseMsg>) {
-        self.guard.neuter();
-
-        self.core_resource_thread.send(CoreResourceMsg::Fetch(request, fetch_target)).unwrap();
-    }
+/// Instruct the resource thread to make a new request.
+pub fn load_async(context: LoadContext,
+                  core_resource_thread: CoreResourceThread,
+                  url: Url,
+                  pipeline: Option<PipelineId>,
+                  referrer_policy: Option<ReferrerPolicy>,
+                  referrer_url: Option<Url>,
+                  listener: AsyncResponseTarget) {
+    let load = LoadOriginData {
+        pipeline: pipeline,
+        referrer_policy: referrer_policy,
+        referrer_url: referrer_url
+    };
+    let load_data = LoadData::new(context, url, &load);
+    let consumer = LoadConsumer::Listener(listener);
+    core_resource_thread.send(CoreResourceMsg::Load(load_data, consumer, None)).unwrap();
 }
 
 /// Message sent in response to `Load`.  Contains metadata, and a port

components/script/document_loader.rs

@@ -9,8 +9,8 @@ use dom::bindings::js::JS;
 use dom::document::Document;
 use ipc_channel::ipc::IpcSender;
 use msg::constellation_msg::{PipelineId, ReferrerPolicy};
-use net_traits::{AsyncResponseTarget, PendingAsyncLoad, LoadContext};
-use net_traits::{FetchResponseMsg, ResourceThreads, IpcSend};
+use net_traits::{AsyncResponseTarget, CoreResourceMsg, load_async};
+use net_traits::{FetchResponseMsg, LoadContext, ResourceThreads, IpcSend};
 use net_traits::request::RequestInit;
 use std::thread;
 use url::Url;
@@ -49,7 +49,7 @@ impl LoadType {
 }
 
 /// Canary value ensuring that manually added blocking loads (ie. ones that weren't
-/// created via DocumentLoader::prepare_async_load) are always removed by the time
+/// created via DocumentLoader::{load_async, fetch_async}) are always removed by the time
 /// that the owner is destroyed.
 #[derive(JSTraceable, HeapSizeOf)]
 #[must_root]
@@ -63,7 +63,7 @@ pub struct LoadBlocker {
 impl LoadBlocker {
     /// Mark the document's load event as blocked on this new load.
     pub fn new(doc: &Document, load: LoadType) -> LoadBlocker {
-        doc.add_blocking_load(load.clone());
+        doc.mut_loader().add_blocking_load(load.clone());
         LoadBlocker {
             doc: JS::from_ref(doc),
             load: Some(load),
@@ -119,46 +119,35 @@ impl DocumentLoader {
     }
 
     /// Add a load to the list of blocking loads.
-    pub fn add_blocking_load(&mut self, load: LoadType) {
+    fn add_blocking_load(&mut self, load: LoadType) {
         self.blocking_loads.push(load);
     }
 
-    /// Create a new pending network request, which can be initiated at some point in
-    /// the future.
-    pub fn prepare_async_load(&mut self,
-                              load: LoadType,
-                              referrer: &Document,
-                              referrer_policy: Option<ReferrerPolicy>) -> PendingAsyncLoad {
-        let context = load.to_load_context();
-        let url = load.url().clone();
-        self.add_blocking_load(load);
-        PendingAsyncLoad::new(context,
-                              self.resource_threads.sender(),
-                              url,
-                              self.pipeline,
-                              referrer_policy.or(referrer.get_referrer_policy()),
-                              Some(referrer.url().clone()))
-    }
-
     /// Create and initiate a new network request.
     pub fn load_async(&mut self,
                       load: LoadType,
                       listener: AsyncResponseTarget,
                       referrer: &Document,
                       referrer_policy: Option<ReferrerPolicy>) {
-        let pending = self.prepare_async_load(load, referrer, referrer_policy);
-        pending.load_async(listener)
+        let context = load.to_load_context();
+        let url = load.url().clone();
+        self.add_blocking_load(load);
+        load_async(context,
+                   self.resource_threads.sender(),
+                   url,
+                   self.pipeline,
+                   referrer_policy.or(referrer.get_referrer_policy()),
+                   Some(referrer.url().clone()),
+                   listener);
     }
 
     /// Initiate a new fetch.
     pub fn fetch_async(&mut self,
                        load: LoadType,
                        request: RequestInit,
-                       fetch_target: IpcSender<FetchResponseMsg>,
-                       referrer: &Document,
-                       referrer_policy: Option<ReferrerPolicy>) {
-        let pending = self.prepare_async_load(load, referrer, referrer_policy);
-        pending.fetch_async(request, fetch_target);
+                       fetch_target: IpcSender<FetchResponseMsg>) {
+        self.add_blocking_load(load);
+        self.resource_threads.sender().send(CoreResourceMsg::Fetch(request, fetch_target)).unwrap();
     }
 
     /// Mark an in-progress network request complete.

components/script/dom/document.rs

@@ -96,7 +96,7 @@ use js::jsapi::JS_GetRuntime;
 use msg::constellation_msg::{ALT, CONTROL, SHIFT, SUPER};
 use msg::constellation_msg::{Key, KeyModifiers, KeyState};
 use msg::constellation_msg::{PipelineId, ReferrerPolicy};
-use net_traits::{AsyncResponseTarget, FetchResponseMsg, IpcSend, PendingAsyncLoad};
+use net_traits::{AsyncResponseTarget, FetchResponseMsg, IpcSend};
 use net_traits::CookieSource::NonHTTP;
 use net_traits::CoreResourceMsg::{GetCookiesForUrl, SetCookiesForUrl};
 use net_traits::request::RequestInit;
@@ -1423,28 +1423,16 @@ impl Document {
                            ReflowReason::RequestAnimationFrame);
     }
 
-    /// Add a load to the list of loads blocking this document's load.
-    pub fn add_blocking_load(&self, load: LoadType) {
-        let mut loader = self.loader.borrow_mut();
-        loader.add_blocking_load(load)
-    }
-
-    pub fn prepare_async_load(&self, load: LoadType, referrer_policy: Option<ReferrerPolicy>) -> PendingAsyncLoad {
-        let mut loader = self.loader.borrow_mut();
-        loader.prepare_async_load(load, self, referrer_policy)
-    }
-
     pub fn load_async(&self, load: LoadType, listener: AsyncResponseTarget, referrer_policy: Option<ReferrerPolicy>) {
         let mut loader = self.loader.borrow_mut();
         loader.load_async(load, listener, self, referrer_policy);
     }
 
     pub fn fetch_async(&self, load: LoadType,
                        request: RequestInit,
-                       fetch_target: IpcSender<FetchResponseMsg>,
-                       referrer_policy: Option<ReferrerPolicy>) {
+                       fetch_target: IpcSender<FetchResponseMsg>) {
         let mut loader = self.loader.borrow_mut();
-        loader.fetch_async(load, request, fetch_target, self, referrer_policy);
+        loader.fetch_async(load, request, fetch_target);
     }
 
     pub fn finish_load(&self, load: LoadType) {

components/script/dom/htmlscriptelement.rs

@@ -271,7 +271,7 @@ fn fetch_a_classic_script(script: &HTMLScriptElement,
     ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
         listener.notify_fetch(message.to().unwrap());
     });
-    doc.fetch_async(LoadType::Script(url), request, action_sender, None);
+    doc.fetch_async(LoadType::Script(url), request, action_sender);
 }
 
 impl HTMLScriptElement {