From 71b83d6e994a2d200a6f5a8841ddcfb14f8a2606 Mon Sep 17 00:00:00 2001 From: Martin Robinson Date: Tue, 22 Sep 2015 11:29:15 -0700 Subject: [PATCH] Pass PaintTile to painting threads This will be useful because in the future, PaintTiles might hold simple DisplayLists instead of StackingContexts. --- components/gfx/display_list/mod.rs | 21 ++++++++-------- components/gfx/paint_task.rs | 39 +++++++++++++++--------------- 2 files changed, 31 insertions(+), 29 deletions(-) diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs index 288a3237269..e5b032117ae 100644 --- a/components/gfx/display_list/mod.rs +++ b/components/gfx/display_list/mod.rs @@ -99,7 +99,7 @@ pub struct DisplayList { /// Child stacking contexts. pub children: LinkedList>, /// Child PaintLayers that will be rendered on top of everything else. - pub layered_children: LinkedList, + pub layered_children: LinkedList>, } impl DisplayList { @@ -705,8 +705,8 @@ impl StackingContextLayerCreator { stacking_context.display_list.layered_children.back().unwrap().id.companion_layer_id(); let child_stacking_context = Arc::new(stacking_context.create_layered_child(next_layer_id, display_list)); - stacking_context.display_list.layered_children.push_back( - PaintLayer::new(next_layer_id, color::transparent(), child_stacking_context)); + stacking_context.display_list.layered_children.push_back(Arc::new( + PaintLayer::new(next_layer_id, color::transparent(), child_stacking_context))); self.all_following_children_need_layers = true; } } @@ -717,7 +717,7 @@ impl StackingContextLayerCreator { if let Some(layer_id) = stacking_context.layer_id { self.finish_building_current_layer(parent_stacking_context); parent_stacking_context.display_list.layered_children.push_back( - PaintLayer::new(layer_id, color::transparent(), stacking_context)); + Arc::new(PaintLayer::new(layer_id, color::transparent(), stacking_context))); // We have started processing layered stacking contexts, so any stacking context that // we process from now on needs its own layer to ensure proper rendering order. @@ -735,17 +735,18 @@ impl StackingContextLayerCreator { } /// Returns the stacking context in the given tree of stacking contexts with a specific layer ID. -pub fn find_stacking_context_with_layer_id(this: &Arc, layer_id: LayerId) - -> Option> { +pub fn find_layer_with_layer_id(this: &Arc, + layer_id: LayerId) + -> Option> { for kid in &this.display_list.layered_children { - if let Some(stacking_context) = kid.find_stacking_context_with_layer_id(layer_id) { - return Some(stacking_context); + if let Some(paint_layer) = PaintLayer::find_layer_with_layer_id(&kid, layer_id) { + return Some(paint_layer); } } for kid in &this.display_list.children { - if let Some(stacking_context) = find_stacking_context_with_layer_id(kid, layer_id) { - return Some(stacking_context); + if let Some(paint_layer) = find_layer_with_layer_id(kid, layer_id) { + return Some(paint_layer); } } diff --git a/components/gfx/paint_task.rs b/components/gfx/paint_task.rs index 563bbe04a0e..87c157b331c 100644 --- a/components/gfx/paint_task.rs +++ b/components/gfx/paint_task.rs @@ -60,14 +60,14 @@ impl PaintLayer { } } - pub fn find_stacking_context_with_layer_id(&self, - layer_id: LayerId) - -> Option> { - if self.id == layer_id { - return Some(self.stacking_context.clone()); + pub fn find_layer_with_layer_id(this: &Arc, + layer_id: LayerId) + -> Option> { + if this.id == layer_id { + return Some(this.clone()); } - display_list::find_stacking_context_with_layer_id(&self.stacking_context, layer_id) + display_list::find_layer_with_layer_id(&this.stacking_context, layer_id) } } @@ -111,7 +111,7 @@ pub struct PaintTask { time_profiler_chan: time::ProfilerChan, /// The root paint layer sent to us by the layout thread. - root_paint_layer: Option, + root_paint_layer: Option>, /// Permission to send paint messages to the compositor paint_permission: bool, @@ -216,7 +216,7 @@ impl PaintTask where C: PaintListener + Send + 'static { match message { Msg::FromLayout(LayoutToPaintMsg::PaintInit(epoch, paint_layer)) => { self.current_epoch = Some(epoch); - self.root_paint_layer = Some(paint_layer); + self.root_paint_layer = Some(Arc::new(paint_layer)); if !self.paint_permission { debug!("PaintTask: paint ready msg"); @@ -296,9 +296,9 @@ impl PaintTask where C: PaintListener + Send + 'static { layer_kind: LayerKind) { time::profile(time::ProfilerCategory::Painting, None, self.time_profiler_chan.clone(), || { // Bail out if there is no appropriate layer. - let stacking_context = if let Some(ref paint_layer) = self.root_paint_layer { - match paint_layer.find_stacking_context_with_layer_id(layer_id) { - Some(stacking_context) => stacking_context, + let paint_layer = if let Some(ref root_paint_layer) = self.root_paint_layer { + match PaintLayer::find_layer_with_layer_id(root_paint_layer, layer_id) { + Some(paint_layer) => paint_layer, None => return, } } else { @@ -313,7 +313,7 @@ impl PaintTask where C: PaintListener + Send + 'static { let thread_id = i % self.worker_threads.len(); self.worker_threads[thread_id].paint_tile(thread_id, tile, - stacking_context.clone(), + paint_layer.clone(), scale, layer_kind); } @@ -347,7 +347,7 @@ impl PaintTask where C: PaintListener + Send + 'static { self.current_epoch.unwrap()); fn build_from_paint_layer(properties: &mut Vec, - paint_layer: &PaintLayer, + paint_layer: &Arc, page_position: &Point2D, transform: &Matrix4, perspective: &Matrix4, @@ -470,12 +470,12 @@ impl WorkerThreadProxy { fn paint_tile(&mut self, thread_id: usize, tile: BufferRequest, - stacking_context: Arc, + paint_layer: Arc, scale: f32, layer_kind: LayerKind) { let msg = MsgToWorkerThread::PaintTile(thread_id, tile, - stacking_context, + paint_layer, scale, layer_kind); self.sender.send(msg).unwrap() @@ -540,10 +540,10 @@ impl WorkerThread { loop { match self.receiver.recv().unwrap() { MsgToWorkerThread::Exit => break, - MsgToWorkerThread::PaintTile(thread_id, tile, stacking_context, scale, layer_kind) => { + MsgToWorkerThread::PaintTile(thread_id, tile, paint_layer, scale, layer_kind) => { let buffer = self.optimize_and_paint_tile(thread_id, tile, - stacking_context, + paint_layer, scale, layer_kind); self.sender.send(MsgFromWorkerThread::PaintedTile(buffer)).unwrap() @@ -576,10 +576,11 @@ impl WorkerThread { fn optimize_and_paint_tile(&mut self, thread_id: usize, mut tile: BufferRequest, - stacking_context: Arc, + paint_layer: Arc, scale: f32, layer_kind: LayerKind) -> Box { + let stacking_context = &paint_layer.stacking_context; let size = Size2D::new(tile.screen_rect.size.width as i32, tile.screen_rect.size.height as i32); let mut buffer = self.create_layer_buffer(&mut tile, scale); @@ -683,7 +684,7 @@ impl WorkerThread { enum MsgToWorkerThread { Exit, - PaintTile(usize, BufferRequest, Arc, f32, LayerKind), + PaintTile(usize, BufferRequest, Arc, f32, LayerKind), } enum MsgFromWorkerThread {