Use fetch_async in the image cache.

components/net/image_cache_thread.rs

@@ -5,13 +5,12 @@
 use immeta::load_from_buf;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
-use msg::constellation_msg::{PipelineId, ReferrerPolicy};
+use net_traits::{CoreResourceThread, NetworkError, ResponseAction, fetch_async, FetchResponseMsg, FetchMetadata};
-use net_traits::{AsyncResponseTarget, CoreResourceMsg, CoreResourceThread, LoadConsumer, LoadData, LoadOrigin};
-use net_traits::{LoadContext, NetworkError, ResponseAction};
 use net_traits::image::base::{Image, ImageMetadata, PixelFormat, load_from_memory};
 use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheCommand, ImageCacheThread, ImageState};
 use net_traits::image_cache_thread::{ImageCacheResult, ImageOrMetadataAvailable, ImageResponse, UsePlaceholder};
 use net_traits::image_cache_thread::ImageResponder;
+use net_traits::request::{Destination, RequestInit, Type as RequestType};
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
@@ -305,19 +304,6 @@ fn convert_format(format: PixelFormat) -> webrender_traits::ImageFormat {
     }
 }
 
-struct ImageCacheOrigin;
-impl LoadOrigin for ImageCacheOrigin {
-    fn referrer_url(&self) -> Option<Url> {
-        None
-    }
-    fn referrer_policy(&self) -> Option<ReferrerPolicy> {
-        None
-    }
-    fn pipeline_id(&self) -> Option<PipelineId> {
-        None
-    }
-}
-
 fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi) -> io::Result<Arc<Image>> {
     let mut placeholder_path = try!(resources_dir_path());
     placeholder_path.push("rippy.png");
@@ -530,25 +516,41 @@ impl ImageCache {
                     CacheResult::Miss => {
                         // A new load request! Request the load from
                         // the resource thread.
-                        let load_data = LoadData::new(LoadContext::Image,
+                        // https://html.spec.whatwg.org/multipage/#update-the-image-data
-                                                        (*ref_url).clone(),
+                        // step 12.
-                                                        &ImageCacheOrigin);
+                        let request = RequestInit {
-                        let (action_sender, action_receiver) = ipc::channel().unwrap();
+                            url: (*ref_url).clone(),
-                        let response_target = AsyncResponseTarget {
+                            type_: RequestType::Image,
-                            sender: action_sender,
+                            destination: Destination::Image,
+                            origin: (*ref_url).clone(),
+                            .. RequestInit::default()
                         };
-                        let msg = CoreResourceMsg::Load(load_data,
+
-                                                   LoadConsumer::Listener(response_target),
-                                                   None);
                         let progress_sender = self.progress_sender.clone();
-                        ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
+                        fetch_async(request, &self.core_resource_thread, move |action| {
-                            let action: ResponseAction = message.to().unwrap();
+                            let action = match action {
+                                FetchResponseMsg::ProcessRequestBody |
+                                FetchResponseMsg::ProcessRequestEOF => return,
+                                FetchResponseMsg::ProcessResponse(meta_result) => {
+                                    ResponseAction::HeadersAvailable(meta_result.map(|m| {
+                                        match m {
+                                            FetchMetadata::Unfiltered(m) => m,
+                                            FetchMetadata::Filtered { unsafe_, .. } => unsafe_
+                                        }
+                                    }))
+                                }
+                                FetchResponseMsg::ProcessResponseChunk(new_bytes) => {
+                                    ResponseAction::DataAvailable(new_bytes)
+                                }
+                                FetchResponseMsg::ProcessResponseEOF(response) => {
+                                    ResponseAction::ResponseComplete(response)
+                                }
+                            };
                             progress_sender.send(ResourceLoadInfo {
                                 action: action,
                                 key: load_key,
                             }).unwrap();
                         });
-                        self.core_resource_thread.send(msg).unwrap();
                     }
                     CacheResult::Hit => {
                         // Request is already on its way.