aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--components/compositing/buffer_map.rs162
-rw-r--r--components/compositing/compositor.rs34
-rw-r--r--components/compositing/compositor_task.rs20
-rw-r--r--components/compositing/headless.rs2
-rw-r--r--components/compositing/lib.rs2
-rw-r--r--components/compositing/surface_map.rs163
-rw-r--r--components/gfx/paint_task.rs39
-rw-r--r--components/servo/Cargo.lock6
-rw-r--r--ports/cef/Cargo.lock6
-rw-r--r--ports/gonk/Cargo.lock6
10 files changed, 222 insertions, 218 deletions
diff --git a/components/compositing/buffer_map.rs b/components/compositing/buffer_map.rs
deleted file mode 100644
index 8e514eab87c..00000000000
--- a/components/compositing/buffer_map.rs
+++ /dev/null
@@ -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
- }
-}
diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs
index 79a0f08b150..8b649185feb 100644
--- a/components/compositing/compositor.rs
+++ b/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.
- buffer_map: BufferMap,
+ /// A data structure to cache unused NativeSurfaces.
+ 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) {
- buffer.rect = buffer_request.page_rect;
- buffer.screen_pos = buffer_request.screen_rect;
- buffer.resolution = paint_request.scale;
- buffer.native_surface.mark_wont_leak();
- buffer.painted_with_cpu = !opts::get().gpu_painting;
- buffer.content_age = buffer_request.content_age;
- buffer_request.layer_buffer = Some(buffer);
+ let size = Size2D::new(buffer_request.screen_rect.size.width as i32,
+ buffer_request.screen_rect.size.height as i32);
+ if let Some(mut native_surface) = self.surface_map.find(size) {
+ native_surface.mark_wont_leak();
+ buffer_request.native_surface = Some(native_surface);
}
}
}
@@ -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);
}
}
}
diff --git a/components/compositing/compositor_task.rs b/components/compositing/compositor_task.rs
index dbf661e212d..422c5be4f3b 100644
--- a/components/compositing/compositor_task.rs
+++ b/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::layers::{BufferRequest, LayerBuffer, LayerBufferSet};
+use layers::platform::surface::{NativeDisplay, NativeSurface};
+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 {
- layer_buffers.push(layer_buffer);
+ if let Some(native_surface) = request.native_surface {
+ native_surfaces.push(native_surface);
}
}
- if !layer_buffers.is_empty() {
- self.send(Msg::ReturnUnusedLayerBuffers(layer_buffers));
+ if !native_surfaces.is_empty() {
+ 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.
- ReturnUnusedLayerBuffers(Vec<Box<LayerBuffer>>),
+ /// these native surfaces, so that they can be re-added to the surface cache.
+ 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"),
}
}
diff --git a/components/compositing/headless.rs b/components/compositing/headless.rs
index 6d2da22da43..7cda9ed635a 100644
--- a/components/compositing/headless.rs
+++ b/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
diff --git a/components/compositing/lib.rs b/components/compositing/lib.rs
index ef27074c96d..396cf9b5b1b 100644
--- a/components/compositing/lib.rs
+++ b/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;
diff --git a/components/compositing/surface_map.rs b/components/compositing/surface_map.rs
new file mode 100644
index 00000000000..76bf729d9e5
--- /dev/null
+++ b/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
+ }
+}
diff --git a/components/gfx/paint_task.rs b/components/gfx/paint_task.rs
index 4083fd05aa2..129e0b95a10 100644
--- a/components/gfx/paint_task.rs
+++ b/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
- // in case it dies in transit to the compositor task.
- let width = tile.screen_rect.size.width;
- let height = tile.screen_rect.size.height;
- let mut native_surface: NativeSurface =
- layers::platform::surface::NativeSurface::new(native_display!(self),
- Size2D::new(width as i32, height as i32));
- native_surface.mark_wont_leak();
-
- box LayerBuffer {
- native_surface: native_surface,
- rect: tile.page_rect,
- screen_pos: tile.screen_rect,
- resolution: scale,
- painted_with_cpu: !opts::get().gpu_painting,
- content_age: tile.content_age,
- }
- })
+ // Create an empty native surface. We mark it as not leaking
+ // in case it dies in transit to the compositor task.
+ let width = tile.screen_rect.size.width;
+ let height = tile.screen_rect.size.height;
+ let mut native_surface = tile.native_surface.take().unwrap_or_else(|| {
+ NativeSurface::new(native_display!(self), Size2D::new(width as i32, height as i32))
+ });
+ native_surface.mark_wont_leak();
+
+ box LayerBuffer {
+ native_surface: native_surface,
+ rect: tile.page_rect,
+ screen_pos: tile.screen_rect,
+ resolution: scale,
+ painted_with_cpu: !opts::get().gpu_painting,
+ content_age: tile.content_age,
+ }
}
}
diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock
index 90d29e2e9e8..229bc93812e 100644
--- a/components/servo/Cargo.lock
+++ b/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)",
]
diff --git a/ports/cef/Cargo.lock b/ports/cef/Cargo.lock
index eb55c30ac09..fb4c5e7cb62 100644
--- a/ports/cef/Cargo.lock
+++ b/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)",
]
diff --git a/ports/gonk/Cargo.lock b/ports/gonk/Cargo.lock
index d625915614e..b18e73a6d77 100644
--- a/ports/gonk/Cargo.lock
+++ b/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)",
]
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-31 15:12:40 +0000