diff --git a/components/gfx/font_cache_thread.rs b/components/gfx/font_cache_thread.rs
index e469cf6dfaa..09ab6f12b88 100644
--- a/components/gfx/font_cache_thread.rs
+++ b/components/gfx/font_cache_thread.rs
@@ -5,8 +5,8 @@
 use font_template::{FontTemplate, FontTemplateDescriptor};
 use fontsan;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
-use ipc_channel::router::ROUTER;
-use net_traits::{AsyncResponseTarget, LoadContext, CoreResourceThread, ResponseAction, load_async};
+use net_traits::{CoreResourceThread, FetchResponseMsg, fetch_async};
+use net_traits::request::{Destination, RequestInit, Type as RequestType};
 use platform::font_context::FontContextHandle;
 use platform::font_list::SANS_SERIF_FONT_FAMILY;
 use platform::font_list::for_each_available_family;
@@ -204,35 +204,33 @@ impl FontCache {
         }
 
         match src {
-            Source::Url(ref url_source) => {
-                let url = &url_source.url;
-                let (data_sender, data_receiver) = ipc::channel().unwrap();
-                let data_target = AsyncResponseTarget {
-                    sender: data_sender,
+            Source::Url(url_source) => {
+                // https://drafts.csswg.org/css-fonts/#font-fetching-requirements
+                let url = url_source.url;
+                let request = RequestInit {
+                    url: url.clone(),
+                    type_: RequestType::Font,
+                    destination: Destination::Font,
+                    origin: url.clone(),
+                    .. RequestInit::default()
                 };
-                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());
                 let response_valid = Mutex::new(false);
-                ROUTER.add_route(data_receiver.to_opaque(), box move |message| {
-                    let response: ResponseAction = message.to().unwrap();
+                fetch_async(request, &self.core_resource_thread, move |response| {
                     match response {
-                        ResponseAction::HeadersAvailable(meta_result) => {
+                        FetchResponseMsg::ProcessRequestBody |
+                        FetchResponseMsg::ProcessRequestEOF => (),
+                        FetchResponseMsg::ProcessResponse(meta_result) => {
                             *response_valid.lock().unwrap() = meta_result.is_ok();
                         }
-                        ResponseAction::DataAvailable(new_bytes) => {
+                        FetchResponseMsg::ProcessResponseChunk(new_bytes) => {
                             if *response_valid.lock().unwrap() {
                                 bytes.lock().unwrap().extend(new_bytes.into_iter())
                             }
                         }
-                        ResponseAction::ResponseComplete(response) => {
+                        FetchResponseMsg::ProcessResponseEOF(response) => {
                             if response.is_err() || !*response_valid.lock().unwrap() {
                                 let msg = Command::AddWebFont(family_name.clone(), sources.clone(), sender.clone());
                                 channel_to_self.send(msg).unwrap();