diff --git a/components/layout/context.rs b/components/layout/context.rs
index 02d4bdd8b8d..eb9024c2c5b 100644
--- a/components/layout/context.rs
+++ b/components/layout/context.rs
@@ -130,13 +130,15 @@ impl<'a> LayoutContext<'a> {
     pub fn font_context(&self) -> RefMut<FontContext> {
         self.cached_local_layout_context.font_context.borrow_mut()
     }
+}
 
+impl SharedLayoutContext {
     fn get_or_request_image_synchronously(&self, url: Url, use_placeholder: UsePlaceholder)
                                           -> Option<Arc<Image>> {
         debug_assert!(opts::get().output_file.is_some() || opts::get().exit_after_load);
 
         // See if the image is already available
-        let result = self.shared.image_cache_thread.find_image(url.clone(), use_placeholder);
+        let result = self.image_cache_thread.find_image(url.clone(), use_placeholder);
 
         match result {
             Ok(image) => return Some(image),
@@ -150,7 +152,7 @@ impl<'a> LayoutContext<'a> {
         // If we are emitting an output file, then we need to block on
         // image load or we risk emitting an output file missing the image.
         let (sync_tx, sync_rx) = ipc::channel().unwrap();
-        self.shared.image_cache_thread.request_image(url, ImageCacheChan(sync_tx), None);
+        self.image_cache_thread.request_image(url, ImageCacheChan(sync_tx), None);
         loop {
             match sync_rx.recv() {
                 Err(_) => return None,
@@ -174,16 +176,16 @@ impl<'a> LayoutContext<'a> {
                        .map(|img| ImageOrMetadataAvailable::ImageAvailable(img));
         }
         // See if the image is already available
-        let result = self.shared.image_cache_thread.find_image_or_metadata(url.clone(),
-                                                                           use_placeholder);
+        let result = self.image_cache_thread.find_image_or_metadata(url.clone(),
+                                                                    use_placeholder);
         match result {
             Ok(image_or_metadata) => Some(image_or_metadata),
             // Image failed to load, so just return nothing
             Err(ImageState::LoadError) => None,
             // Not yet requested, async mode - request image or metadata from the cache
             Err(ImageState::NotRequested) => {
-                let sender = self.shared.image_cache_sender.lock().unwrap().clone();
-                self.shared.image_cache_thread.request_image_and_metadata(url, sender, None);
+                let sender = self.image_cache_sender.lock().unwrap().clone();
+                self.image_cache_thread.request_image_and_metadata(url, sender, None);
                 None
             }
             // Image has been requested, is still pending. Return no image for this paint loop.
@@ -198,7 +200,7 @@ impl<'a> LayoutContext<'a> {
                                        fetch_image_data_as_well: bool)
                                        -> Option<(WebRenderImageInfo, Option<IpcSharedMemory>)> {
         if !fetch_image_data_as_well {
-            let webrender_image_cache = self.shared.webrender_image_cache.read().unwrap();
+            let webrender_image_cache = self.webrender_image_cache.read().unwrap();
             if let Some(existing_webrender_image) =
                     webrender_image_cache.get(&((*url).clone(), use_placeholder)) {
                 return Some(((*existing_webrender_image).clone(), None))
@@ -216,8 +218,7 @@ impl<'a> LayoutContext<'a> {
                     };
                     Some((image_info, bytes))
                 } else if !fetch_image_data_as_well {
-                    let mut webrender_image_cache = self.shared
-                                                        .webrender_image_cache
+                    let mut webrender_image_cache = self.webrender_image_cache
                                                         .write()
                                                         .unwrap();
                     webrender_image_cache.insert(((*url).clone(), use_placeholder),
diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs
index ce3df3f4c47..db8b67400fc 100644
--- a/components/layout/display_list_builder.rs
+++ b/components/layout/display_list_builder.rs
@@ -491,10 +491,11 @@ impl FragmentDisplayListBuilding for Fragment {
                                                index: usize) {
         let background = style.get_background();
         let fetch_image_data_as_well = !opts::get().use_webrender;
-        let webrender_image =
-            state.layout_context.get_webrender_image_for_url(image_url,
-                                                             UsePlaceholder::No,
-                                                             fetch_image_data_as_well);
+        let webrender_image = state.layout_context
+                                   .shared
+                                   .get_webrender_image_for_url(image_url,
+                                                                UsePlaceholder::No,
+                                                                fetch_image_data_as_well);
 
         if let Some((webrender_image, image_data)) = webrender_image {
             debug!("(building display list) building background image");
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index dbf6307bac1..aeff0639868 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -370,7 +370,7 @@ impl ImageFragmentInfo {
     pub fn new<N: ThreadSafeLayoutNode>(node: &N, url: Option<Url>,
                                         layout_context: &LayoutContext) -> ImageFragmentInfo {
         let image_or_metadata = url.and_then(|url| {
-            layout_context.get_or_request_image_or_meta(url, UsePlaceholder::Yes)
+            layout_context.shared.get_or_request_image_or_meta(url, UsePlaceholder::Yes)
         });
 
         let (image, metadata) = match image_or_metadata {