Have BufferMap store NativeSurfaces and rename to SurfaceMap

We currently store LayerBuffers, because previously NativeSurfaces did
not record their own size. Now we can store NativeSurfaces directly,
which saves a bit of space in the surface cache and allows us to create
LayerBuffers only in the PaintTask.

This also means that instead of sending cached LayerBuffers, the
compositor can just send cached NativeSurfaces to the PaintTask.

components/compositing/buffer_map.rs

@@ -1,162 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use std::collections::HashMap;
-use std::collections::hash_map::Entry::{Occupied, Vacant};
-use euclid::size::Size2D;
-use layers::platform::surface::NativeDisplay;
-use layers::layers::LayerBuffer;
-use std::hash::{Hash, Hasher};
-
-/// This is a struct used to store buffers when they are not in use.
-/// The paint task can quickly query for a particular size of buffer when it
-/// needs it.
-pub struct BufferMap {
-    /// A HashMap that stores the Buffers.
-    map: HashMap<BufferKey, BufferValue>,
-    /// The current amount of memory stored by the BufferMap's buffers.
-    mem: usize,
-    /// The maximum allowed memory. Unused buffers will be deleted
-    /// when this threshold is exceeded.
-    max_mem: usize,
-    /// A monotonically increasing counter to track how recently tile sizes were used.
-    counter: usize,
-}
-
-/// A key with which to store buffers. It is based on the size of the buffer.
-#[derive(Eq, Copy, Clone)]
-struct BufferKey([usize; 2]);
-
-impl Hash for BufferKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let BufferKey(ref bytes) = *self;
-        bytes.hash(state);
-    }
-}
-
-impl PartialEq for BufferKey {
-    fn eq(&self, other: &BufferKey) -> bool {
-        let BufferKey(s) = *self;
-        let BufferKey(o) = *other;
-        s[0] == o[0] && s[1] == o[1]
-    }
-}
-
-/// Create a key from a given size
-impl BufferKey {
-    fn get(input: Size2D<usize>) -> BufferKey {
-        BufferKey([input.width, input.height])
-    }
-}
-
-/// A helper struct to keep track of buffers in the HashMap
-struct BufferValue {
-    /// An array of buffers, all the same size
-    buffers: Vec<Box<LayerBuffer>>,
-    /// The counter when this size was last requested
-    last_action: usize,
-}
-
-impl BufferMap {
-    // Creates a new BufferMap with a given buffer limit.
-    pub fn new(max_mem: usize) -> BufferMap {
-        BufferMap {
-            map: HashMap::new(),
-            mem: 0,
-            max_mem: max_mem,
-            counter: 0,
-        }
-    }
-
-    pub fn insert_buffers(&mut self, display: &NativeDisplay, buffers: Vec<Box<LayerBuffer>>) {
-        for mut buffer in buffers.into_iter() {
-            buffer.mark_wont_leak();
-            self.insert(display, buffer)
-        }
-    }
-
-    /// Insert a new buffer into the map.
-    pub fn insert(&mut self, display: &NativeDisplay, new_buffer: Box<LayerBuffer>) {
-        let new_key = BufferKey::get(new_buffer.get_size_2d());
-
-        // If all our buffers are the same size and we're already at our
-        // memory limit, no need to store this new buffer; just let it drop.
-        if self.mem + new_buffer.get_mem() > self.max_mem && self.map.len() == 1 &&
-            self.map.contains_key(&new_key) {
-            new_buffer.destroy(display);
-            return;
-        }
-
-        self.mem += new_buffer.get_mem();
-        // use lazy insertion function to prevent unnecessary allocation
-        let counter = &self.counter;
-        match self.map.entry(new_key) {
-            Occupied(entry) => {
-                entry.into_mut().buffers.push(new_buffer);
-            }
-            Vacant(entry) => {
-                entry.insert(BufferValue {
-                    buffers: vec!(new_buffer),
-                    last_action: *counter,
-                });
-            }
-        }
-
-        let mut opt_key: Option<BufferKey> = None;
-        while self.mem > self.max_mem {
-            let old_key = match opt_key {
-                Some(key) => key,
-                None => {
-                    match self.map.iter().min_by(|&(_, x)| x.last_action) {
-                        Some((k, _)) => *k,
-                        None => panic!("BufferMap: tried to delete with no elements in map"),
-                    }
-                }
-            };
-            if {
-                let list = &mut self.map.get_mut(&old_key).unwrap().buffers;
-                let condemned_buffer = list.pop().take().unwrap();
-                self.mem -= condemned_buffer.get_mem();
-                condemned_buffer.destroy(display);
-                list.is_empty()
-            }
-            { // then
-                self.map.remove(&old_key); // Don't store empty vectors!
-                opt_key = None;
-            } else {
-                opt_key = Some(old_key);
-            }
-        }
-    }
-
-    // Try to find a buffer for the given size.
-    pub fn find(&mut self, size: Size2D<usize>) -> Option<Box<LayerBuffer>> {
-        let mut flag = false; // True if key needs to be popped after retrieval.
-        let key = BufferKey::get(size);
-        let ret = match self.map.get_mut(&key) {
-            Some(ref mut buffer_val) => {
-                buffer_val.last_action = self.counter;
-                self.counter += 1;
-
-                let buffer = buffer_val.buffers.pop().take().unwrap();
-                self.mem -= buffer.get_mem();
-                if buffer_val.buffers.is_empty() {
-                    flag = true;
-                }
-                Some(buffer)
-            }
-            None => None,
-        };
-
-        if flag {
-            self.map.remove(&key); // Don't store empty vectors!
-        }
-
-        ret
-    }
-
-    pub fn mem(&self) -> usize {
-        self.mem
-    }
-}

components/compositing/compositor.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use buffer_map::BufferMap;
+use surface_map::SurfaceMap;
 use compositor_layer::{CompositorData, CompositorLayer, WantsScrollEventsFlag};
 use compositor_task::{CompositorEventListener, CompositorProxy, CompositorReceiver};
 use compositor_task::Msg;
@@ -158,8 +158,8 @@ pub struct IOCompositor<Window: WindowMethods> {
     /// image for the reftest framework.
     ready_to_save_state: ReadyState,
 
-    /// A data structure to store unused LayerBuffers.
+    /// A data structure to cache unused NativeSurfaces.
-    buffer_map: BufferMap,
+    surface_map: SurfaceMap,
 }
 
 pub struct ScrollEvent {
@@ -301,7 +301,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
             last_composite_time: 0,
             has_seen_quit_event: false,
             ready_to_save_state: ReadyState::Unknown,
-            buffer_map: BufferMap::new(BUFFER_MAP_SIZE),
+            surface_map: SurfaceMap::new(BUFFER_MAP_SIZE),
         }
     }
 
@@ -402,9 +402,9 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 }
             }
 
-            (Msg::ReturnUnusedLayerBuffers(layer_buffers),
+            (Msg::ReturnUnusedNativeSurfaces(native_surfaces),
              ShutdownState::NotShuttingDown) => {
-                self.cache_unused_buffers(layer_buffers);
+                self.surface_map.insert_surfaces(&self.native_display, native_surfaces);
             }
 
             (Msg::ScrollFragmentPoint(pipeline_id, layer_id, point),
@@ -494,7 +494,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 let mut reports = vec![];
                 let name = "compositor-task";
                 reports.push(mem::Report {
-                    path: path![name, "buffer-map"], size: self.buffer_map.mem(),
+                    path: path![name, "surface-map"], size: self.surface_map.mem(),
                 });
                 reports.push(mem::Report {
                     path: path![name, "layer-tree"], size: self.scene.get_memory_usage(),
@@ -1176,18 +1176,15 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
     fn fill_paint_request_with_cached_layer_buffers(&mut self, paint_request: &mut PaintRequest) {
         for buffer_request in paint_request.buffer_requests.iter_mut() {
-            if self.buffer_map.mem() == 0 {
+            if self.surface_map.mem() == 0 {
                 return;
             }
 
-            if let Some(mut buffer) = self.buffer_map.find(buffer_request.screen_rect.size) {
+            let size = Size2D::new(buffer_request.screen_rect.size.width as i32,
-                buffer.rect = buffer_request.page_rect;
+                                   buffer_request.screen_rect.size.height as i32);
-                buffer.screen_pos = buffer_request.screen_rect;
+            if let Some(mut native_surface) = self.surface_map.find(size) {
-                buffer.resolution = paint_request.scale;
+                native_surface.mark_wont_leak();
-                buffer.native_surface.mark_wont_leak();
+                buffer_request.native_surface = Some(native_surface);
-                buffer.painted_with_cpu = !opts::get().gpu_painting;
-                buffer.content_age = buffer_request.content_age;
-                buffer_request.layer_buffer = Some(buffer);
             }
         }
     }
@@ -1579,7 +1576,10 @@ impl<Window: WindowMethods> IOCompositor<Window> {
 
     pub fn cache_unused_buffers(&mut self, buffers: Vec<Box<LayerBuffer>>) {
         if !buffers.is_empty() {
-            self.buffer_map.insert_buffers(&self.native_display, buffers);
+            let surfaces = buffers.into_iter().map(|buffer| {
+                buffer.native_surface
+            }).collect();
+            self.surface_map.insert_surfaces(&self.native_display, surfaces);
         }
     }
 }

components/compositing/compositor_task.rs

@@ -14,8 +14,8 @@ use windowing::{WindowEvent, WindowMethods};
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use ipc_channel::ipc::{IpcReceiver, IpcSender};
-use layers::platform::surface::NativeDisplay;
+use layers::platform::surface::{NativeDisplay, NativeSurface};
-use layers::layers::{BufferRequest, LayerBuffer, LayerBufferSet};
+use layers::layers::{BufferRequest, LayerBufferSet};
 use msg::compositor_msg::{Epoch, LayerId, LayerProperties, FrameTreeId};
 use msg::compositor_msg::{PaintListener, ScriptToCompositorMsg};
 use msg::constellation_msg::{AnimationState, ConstellationChan, PipelineId};
@@ -110,14 +110,14 @@ impl PaintListener for Box<CompositorProxy+'static+Send> {
     }
 
     fn ignore_buffer_requests(&mut self, buffer_requests: Vec<BufferRequest>) {
-        let mut layer_buffers = Vec::new();
+        let mut native_surfaces = Vec::new();
         for request in buffer_requests.into_iter() {
-            if let Some(layer_buffer) = request.layer_buffer {
+            if let Some(native_surface) = request.native_surface {
-                layer_buffers.push(layer_buffer);
+                native_surfaces.push(native_surface);
             }
         }
-        if !layer_buffers.is_empty() {
+        if !native_surfaces.is_empty() {
-            self.send(Msg::ReturnUnusedLayerBuffers(layer_buffers));
+            self.send(Msg::ReturnUnusedNativeSurfaces(native_surfaces));
         }
     }
 
@@ -195,8 +195,8 @@ pub enum Msg {
     /// <head> tag finished parsing
     HeadParsed,
     /// Signal that the paint task ignored the paint requests that carried
-    /// these layer buffers, so that they can be re-added to the surface cache.
+    /// these native surfaces, so that they can be re-added to the surface cache.
-    ReturnUnusedLayerBuffers(Vec<Box<LayerBuffer>>),
+    ReturnUnusedNativeSurfaces(Vec<NativeSurface>),
     /// Collect memory reports and send them back to the given mem::ReportsChan.
     CollectMemoryReports(mem::ReportsChan),
 }
@@ -227,7 +227,7 @@ impl Debug for Msg {
             Msg::IsReadyToSaveImageReply(..) => write!(f, "IsReadyToSaveImageReply"),
             Msg::NewFavicon(..) => write!(f, "NewFavicon"),
             Msg::HeadParsed => write!(f, "HeadParsed"),
-            Msg::ReturnUnusedLayerBuffers(..) => write!(f, "ReturnUnusedLayerBuffers"),
+            Msg::ReturnUnusedNativeSurfaces(..) => write!(f, "ReturnUnusedNativeSurfaces"),
             Msg::CollectMemoryReports(..) => write!(f, "CollectMemoryReports"),
         }
     }

components/compositing/headless.rs

@@ -111,7 +111,7 @@ impl CompositorEventListener for NullCompositor {
             Msg::IsReadyToSaveImageReply(..) => {}
             Msg::NewFavicon(..) => {}
             Msg::HeadParsed => {}
-            Msg::ReturnUnusedLayerBuffers(..) => {}
+            Msg::ReturnUnusedNativeSurfaces(..) => {}
             Msg::CollectMemoryReports(..) => {}
         }
         true

components/compositing/lib.rs

@@ -46,7 +46,7 @@ pub use constellation::Constellation;
 
 pub mod compositor_task;
 
-mod buffer_map;
+mod surface_map;
 mod compositor_layer;
 mod compositor;
 mod headless;

components/compositing/surface_map.rs

@@ -0,0 +1,163 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::collections::HashMap;
+use std::collections::hash_map::Entry::{Occupied, Vacant};
+use euclid::size::Size2D;
+use layers::platform::surface::{NativeDisplay, NativeSurface};
+use std::hash::{Hash, Hasher};
+
+/// This is a struct used to store surfaces when they are not in use.
+/// The paint task can quickly query for a particular size of surface when it
+/// needs it.
+pub struct SurfaceMap {
+    /// A HashMap that stores the Buffers.
+    map: HashMap<SurfaceKey, SurfaceValue>,
+    /// The current amount of memory stored by the SurfaceMap's surfaces.
+    mem: usize,
+    /// The maximum allowed memory. Unused surfaces will be deleted
+    /// when this threshold is exceeded.
+    max_mem: usize,
+    /// A monotonically increasing counter to track how recently tile sizes were used.
+    counter: usize,
+}
+
+/// A key with which to store surfaces. It is based on the size of the surface.
+#[derive(Eq, Copy, Clone)]
+struct SurfaceKey([i32; 2]);
+
+impl Hash for SurfaceKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let SurfaceKey(ref bytes) = *self;
+        bytes.hash(state);
+    }
+}
+
+impl PartialEq for SurfaceKey {
+    fn eq(&self, other: &SurfaceKey) -> bool {
+        let SurfaceKey(s) = *self;
+        let SurfaceKey(o) = *other;
+        s[0] == o[0] && s[1] == o[1]
+    }
+}
+
+/// Create a key from a given size
+impl SurfaceKey {
+    fn get(input: Size2D<i32>) -> SurfaceKey {
+        SurfaceKey([input.width, input.height])
+    }
+}
+
+/// A helper struct to keep track of surfaces in the HashMap
+struct SurfaceValue {
+    /// An array of surfaces, all the same size
+    surfaces: Vec<NativeSurface>,
+    /// The counter when this size was last requested
+    last_action: usize,
+}
+
+impl SurfaceMap {
+    // Creates a new SurfaceMap with a given surface limit.
+    pub fn new(max_mem: usize) -> SurfaceMap {
+        SurfaceMap {
+            map: HashMap::new(),
+            mem: 0,
+            max_mem: max_mem,
+            counter: 0,
+        }
+    }
+
+    pub fn insert_surfaces(&mut self, display: &NativeDisplay, surfaces: Vec<NativeSurface>) {
+        for surface in surfaces.into_iter() {
+            self.insert(display, surface);
+        }
+    }
+
+    /// Insert a new buffer into the map.
+    pub fn insert(&mut self, display: &NativeDisplay, mut new_surface: NativeSurface) {
+        let new_key = SurfaceKey::get(new_surface.get_size());
+
+        // If all our surfaces are the same size and we're already at our
+        // memory limit, no need to store this new buffer; just let it drop.
+        let new_total_memory_usage = self.mem + new_surface.get_memory_usage();
+        if new_total_memory_usage > self.max_mem && self.map.len() == 1 &&
+            self.map.contains_key(&new_key) {
+            new_surface.destroy(display);
+            return;
+        }
+
+        self.mem = new_total_memory_usage;
+        new_surface.mark_wont_leak();
+
+        // use lazy insertion function to prevent unnecessary allocation
+        let counter = &self.counter;
+        match self.map.entry(new_key) {
+            Occupied(entry) => {
+                entry.into_mut().surfaces.push(new_surface);
+            }
+            Vacant(entry) => {
+                entry.insert(SurfaceValue {
+                    surfaces: vec!(new_surface),
+                    last_action: *counter,
+                });
+            }
+        }
+
+        let mut opt_key: Option<SurfaceKey> = None;
+        while self.mem > self.max_mem {
+            let old_key = match opt_key {
+                Some(key) => key,
+                None => {
+                    match self.map.iter().min_by(|&(_, x)| x.last_action) {
+                        Some((k, _)) => *k,
+                        None => panic!("SurfaceMap: tried to delete with no elements in map"),
+                    }
+                }
+            };
+            if {
+                let list = &mut self.map.get_mut(&old_key).unwrap().surfaces;
+                let mut condemned_surface = list.pop().take().unwrap();
+                self.mem -= condemned_surface.get_memory_usage();
+                condemned_surface.destroy(display);
+                list.is_empty()
+            }
+            { // then
+                self.map.remove(&old_key); // Don't store empty vectors!
+                opt_key = None;
+            } else {
+                opt_key = Some(old_key);
+            }
+        }
+    }
+
+    // Try to find a buffer for the given size.
+    pub fn find(&mut self, size: Size2D<i32>) -> Option<NativeSurface> {
+        let mut flag = false; // True if key needs to be popped after retrieval.
+        let key = SurfaceKey::get(size);
+        let ret = match self.map.get_mut(&key) {
+            Some(ref mut surface_val) => {
+                surface_val.last_action = self.counter;
+                self.counter += 1;
+
+                let surface = surface_val.surfaces.pop().take().unwrap();
+                self.mem -= surface.get_memory_usage();
+                if surface_val.surfaces.is_empty() {
+                    flag = true;
+                }
+                Some(surface)
+            }
+            None => None,
+        };
+
+        if flag {
+            self.map.remove(&key); // Don't store empty vectors!
+        }
+
+        ret
+    }
+
+    pub fn mem(&self) -> usize {
+        self.mem
+    }
+}

components/gfx/paint_task.rs

@@ -17,7 +17,6 @@ use euclid::rect::Rect;
 use euclid::size::Size2D;
 use layers::platform::surface::{NativeDisplay, NativeSurface};
 use layers::layers::{BufferRequest, LayerBuffer, LayerBufferSet};
-use layers;
 use canvas_traits::CanvasMsg;
 use msg::compositor_msg::{Epoch, FrameTreeId, LayerId, LayerKind};
 use msg::compositor_msg::{LayerProperties, PaintListener, ScrollPolicy};
@@ -508,7 +507,7 @@ impl WorkerThread {
             DrawTarget::new(BackendType::Skia, size, SurfaceFormat::B8G8R8A8)
         } else {
             let gl_rasterization_context =
-                layer_buffer.native_surface.gl_rasterization_context(native_display!(self), size);
+                layer_buffer.native_surface.gl_rasterization_context(native_display!(self));
             match gl_rasterization_context {
                 Some(gl_rasterization_context) => {
                     gl_rasterization_context.make_current();
@@ -609,25 +608,23 @@ impl WorkerThread {
                            tile: &mut BufferRequest,
                            scale: f32)
                            -> Box<LayerBuffer> {
-        tile.layer_buffer.take().unwrap_or_else(|| {
+        // Create an empty native surface. We mark it as not leaking
-            // Create an empty native surface. We mark it as not leaking
+        // in case it dies in transit to the compositor task.
-            // in case it dies in transit to the compositor task.
+        let width = tile.screen_rect.size.width;
-            let width = tile.screen_rect.size.width;
+        let height = tile.screen_rect.size.height;
-            let height = tile.screen_rect.size.height;
+        let mut native_surface = tile.native_surface.take().unwrap_or_else(|| {
-            let mut native_surface: NativeSurface =
+            NativeSurface::new(native_display!(self), Size2D::new(width as i32, height as i32))
-                layers::platform::surface::NativeSurface::new(native_display!(self),
+        });
-                                                              Size2D::new(width as i32, height as i32));
+        native_surface.mark_wont_leak();
-            native_surface.mark_wont_leak();
 
-            box LayerBuffer {
+        box LayerBuffer {
-                native_surface: native_surface,
+            native_surface: native_surface,
-                rect: tile.page_rect,
+            rect: tile.page_rect,
-                screen_pos: tile.screen_rect,
+            screen_pos: tile.screen_rect,
-                resolution: scale,
+            resolution: scale,
-                painted_with_cpu: !opts::get().gpu_painting,
+            painted_with_cpu: !opts::get().gpu_painting,
-                content_age: tile.content_age,
+            content_age: tile.content_age,
-            }
+        }
-        })
     }
 }
 

components/servo/Cargo.lock

@@ -679,7 +679,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "layers"
 version = "0.1.0"
-source = "git+https://github.com/servo/rust-layers#1c9628618803c161753fd9f00f5ef781660ce11e"
+source = "git+https://github.com/servo/rust-layers#0c9644b1b54a94c10d4e9dbe39d209669fa66961"
 dependencies = [
  "azure 0.1.0 (git+https://github.com/servo/rust-azure)",
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -926,7 +926,7 @@ dependencies = [
 [[package]]
 name = "offscreen_gl_context"
 version = "0.1.0"
-source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#46c5cc8694b08c09de55821e0e8a00ebe5ed97da"
+source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#724d47a76f8a7eeb105f6b8878b94701cff1bc1a"
 dependencies = [
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -937,6 +937,8 @@ dependencies = [
  "layers 0.1.0 (git+https://github.com/servo/rust-layers)",
  "libc 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_macros 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "x11 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 

ports/cef/Cargo.lock

@@ -671,7 +671,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "layers"
 version = "0.1.0"
-source = "git+https://github.com/servo/rust-layers#1c9628618803c161753fd9f00f5ef781660ce11e"
+source = "git+https://github.com/servo/rust-layers#0c9644b1b54a94c10d4e9dbe39d209669fa66961"
 dependencies = [
  "azure 0.1.0 (git+https://github.com/servo/rust-azure)",
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -905,7 +905,7 @@ dependencies = [
 [[package]]
 name = "offscreen_gl_context"
 version = "0.1.0"
-source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#46c5cc8694b08c09de55821e0e8a00ebe5ed97da"
+source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#724d47a76f8a7eeb105f6b8878b94701cff1bc1a"
 dependencies = [
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -916,6 +916,8 @@ dependencies = [
  "layers 0.1.0 (git+https://github.com/servo/rust-layers)",
  "libc 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_macros 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "x11 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 

ports/gonk/Cargo.lock

@@ -605,7 +605,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "layers"
 version = "0.1.0"
-source = "git+https://github.com/servo/rust-layers#1c9628618803c161753fd9f00f5ef781660ce11e"
+source = "git+https://github.com/servo/rust-layers#0c9644b1b54a94c10d4e9dbe39d209669fa66961"
 dependencies = [
  "azure 0.1.0 (git+https://github.com/servo/rust-azure)",
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -822,7 +822,7 @@ dependencies = [
 [[package]]
 name = "offscreen_gl_context"
 version = "0.1.0"
-source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#46c5cc8694b08c09de55821e0e8a00ebe5ed97da"
+source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#724d47a76f8a7eeb105f6b8878b94701cff1bc1a"
 dependencies = [
  "cgl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -833,6 +833,8 @@ dependencies = [
  "layers 0.1.0 (git+https://github.com/servo/rust-layers)",
  "libc 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_macros 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "x11 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]