Auto merge of #13012 - servo:shared-layout-context, r=nox

Stop creating a LayoutContext in build_display_list_for_subtree.

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/13012)
<!-- Reviewable:end -->

components/layout/block.rs

@@ -28,7 +28,7 @@
 #![deny(unsafe_code)]
 
 use app_units::{Au, MAX_AU};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::BlockFlowDisplayListBuilding;
 use display_list_builder::{BorderPaintingMode, DisplayListBuildState, FragmentDisplayListBuilding};
 use euclid::{Point2D, Rect, Size2D};
@@ -1834,7 +1834,7 @@ impl Flow for BlockFlow {
         }
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         if self.base.flags.contains(NEEDS_LAYER) {
             self.fragment.flags.insert(HAS_LAYER)
         }
@@ -1969,12 +1969,12 @@ impl Flow for BlockFlow {
         let stacking_relative_position_of_display_port_for_children =
             if is_stacking_context || self.is_root() {
                 let visible_rect =
-                    match layout_context.shared.visible_rects.get(&self.layer_id()) {
+                    match layout_context.visible_rects.get(&self.layer_id()) {
                         Some(visible_rect) => *visible_rect,
-                        None => Rect::new(Point2D::zero(), layout_context.shared_context().viewport_size),
+                        None => Rect::new(Point2D::zero(), layout_context.style_context.viewport_size),
                     };
 
-                let viewport_size = layout_context.shared_context().viewport_size;
+                let viewport_size = layout_context.style_context.viewport_size;
                 visible_rect.inflate(viewport_size.width * DISPLAY_PORT_SIZE_FACTOR,
                                      viewport_size.height * DISPLAY_PORT_SIZE_FACTOR)
             } else if is_stacking_context {

components/layout/construct.rs

@@ -308,13 +308,13 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
             Some(LayoutNodeType::Element(LayoutElementType::HTMLImageElement)) => {
                 let image_info = box ImageFragmentInfo::new(node,
                                                             node.image_url(),
-                                                            &self.layout_context);
+                                                            &self.layout_context.shared);
                 SpecificFragmentInfo::Image(image_info)
             }
             Some(LayoutNodeType::Element(LayoutElementType::HTMLObjectElement)) => {
                 let image_info = box ImageFragmentInfo::new(node,
                                                             node.object_data(),
-                                                            &self.layout_context);
+                                                            &self.layout_context.shared);
                 SpecificFragmentInfo::Image(image_info)
             }
             Some(LayoutNodeType::Element(LayoutElementType::HTMLTableElement)) => {
@@ -332,7 +332,7 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
             }
             Some(LayoutNodeType::Element(LayoutElementType::HTMLCanvasElement)) => {
                 let data = node.canvas_data().unwrap();
-                SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(node, data, self.layout_context))
+                SpecificFragmentInfo::Canvas(box CanvasFragmentInfo::new(node, data, self.style_context()))
             }
             _ => {
                 // This includes pseudo-elements.
@@ -1267,7 +1267,7 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
             Some(ref url) => {
                 let image_info = box ImageFragmentInfo::new(node,
                                                             Some((*url).clone()),
-                                                            &self.layout_context);
+                                                            &self.layout_context.shared);
                 vec![Fragment::new(node, SpecificFragmentInfo::Image(image_info), self.layout_context)]
             }
             None => {

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),

components/layout/display_list_builder.rs

@@ -14,7 +14,7 @@ use app_units::{Au, AU_PER_PX};
 use azure::azure_hl::Color;
 use block::{BlockFlow, BlockStackingContextType};
 use canvas_traits::{CanvasMsg, CanvasData, FromLayoutMsg};
-use context::LayoutContext;
+use context::SharedLayoutContext;
 use euclid::{Matrix4D, Point2D, Point3D, Radians, Rect, SideOffsets2D, Size2D};
 use flex::FlexFlow;
 use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED};
@@ -65,16 +65,17 @@ fn get_cyclic<T>(arr: &[T], index: usize) -> &T {
 }
 
 pub struct DisplayListBuildState<'a> {
-    pub layout_context: &'a LayoutContext<'a>,
+    pub shared_layout_context: &'a SharedLayoutContext,
     pub items: Vec<DisplayItem>,
     pub stacking_context_id_stack: Vec<StackingContextId>,
 }
 
 impl<'a> DisplayListBuildState<'a> {
-    pub fn new(layout_context: &'a LayoutContext, stacking_context_id: StackingContextId)
+    pub fn new(shared_layout_context: &'a SharedLayoutContext,
+               stacking_context_id: StackingContextId)
                -> DisplayListBuildState<'a> {
         DisplayListBuildState {
-            layout_context: layout_context,
+            shared_layout_context: shared_layout_context,
             items: Vec::new(),
             stacking_context_id_stack: vec!(stacking_context_id),
         }
@@ -491,10 +492,10 @@ 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.shared_layout_context
+                                   .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");

components/layout/flex.rs

@@ -8,7 +8,7 @@
 
 use app_units::{Au, MAX_AU};
 use block::BlockFlow;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::{DisplayListBuildState, FlexFlowDisplayListBuilding};
 use euclid::Point2D;
 use floats::FloatKind;
@@ -920,7 +920,7 @@ impl Flow for FlexFlow {
         }
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/flow.rs

@@ -27,7 +27,7 @@
 
 use app_units::Au;
 use block::{BlockFlow, FormattingContextType};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use euclid::{Point2D, Rect, Size2D};
 use floats::{Floats, SpeculatedFloatPlacement};
@@ -318,7 +318,7 @@ pub trait Flow: fmt::Debug + Sync + Send + 'static {
     }
 
     /// Phase 4 of reflow: computes absolute positions.
-    fn compute_absolute_position(&mut self, _: &LayoutContext) {
+    fn compute_absolute_position(&mut self, _: &SharedLayoutContext) {
         // The default implementation is a no-op.
     }
 

components/layout/fragment.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use canvas_traits::CanvasMsg;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use euclid::{Point2D, Rect, Size2D};
 use floats::ClearType;
 use flow::{self, ImmutableFlowUtils};
@@ -42,6 +42,7 @@ use style::computed_values::content::ContentItem;
 use style::computed_values::{border_collapse, box_sizing, clear, color, display, mix_blend_mode};
 use style::computed_values::{overflow_wrap, overflow_x, position, text_decoration};
 use style::computed_values::{transform_style, vertical_align, white_space, word_break, z_index};
+use style::context::SharedStyleContext;
 use style::dom::TRestyleDamage;
 use style::logical_geometry::{LogicalMargin, LogicalRect, LogicalSize, WritingMode};
 use style::properties::ServoComputedValues;
@@ -323,7 +324,10 @@ pub struct CanvasFragmentInfo {
 }
 
 impl CanvasFragmentInfo {
-    pub fn new<N: ThreadSafeLayoutNode>(node: &N, data: HTMLCanvasData, ctx: &LayoutContext) -> CanvasFragmentInfo {
+    pub fn new<N: ThreadSafeLayoutNode>(node: &N,
+                                        data: HTMLCanvasData,
+                                        ctx: &SharedStyleContext)
+                                        -> CanvasFragmentInfo {
         CanvasFragmentInfo {
             replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, ctx),
             ipc_renderer: data.ipc_renderer
@@ -368,9 +372,10 @@ impl ImageFragmentInfo {
     /// FIXME(pcwalton): The fact that image fragments store the cache in the fragment makes little
     /// sense to me.
     pub fn new<N: ThreadSafeLayoutNode>(node: &N, url: Option<Url>,
-                                        layout_context: &LayoutContext) -> ImageFragmentInfo {
+                                        shared_layout_context: &SharedLayoutContext)
+                                        -> ImageFragmentInfo {
         let image_or_metadata = url.and_then(|url| {
-            layout_context.get_or_request_image_or_meta(url, UsePlaceholder::Yes)
+            shared_layout_context.get_or_request_image_or_meta(url, UsePlaceholder::Yes)
         });
 
         let (image, metadata) = match image_or_metadata {
@@ -386,7 +391,7 @@ impl ImageFragmentInfo {
         };
 
         ImageFragmentInfo {
-            replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, layout_context),
+            replaced_image_fragment_info: ReplacedImageFragmentInfo::new(node, &shared_layout_context.style_context),
             image: image,
             metadata: metadata,
         }
@@ -445,9 +450,9 @@ pub struct ReplacedImageFragmentInfo {
 }
 
 impl ReplacedImageFragmentInfo {
-    pub fn new<N>(node: &N, ctx: &LayoutContext) -> ReplacedImageFragmentInfo
+    pub fn new<N>(node: &N, ctx: &SharedStyleContext) -> ReplacedImageFragmentInfo
             where N: ThreadSafeLayoutNode {
-        let is_vertical = node.style(ctx.style_context()).writing_mode.is_vertical();
+        let is_vertical = node.style(ctx).writing_mode.is_vertical();
         ReplacedImageFragmentInfo {
             computed_inline_size: None,
             computed_block_size: None,

components/layout/inline.rs

@@ -6,7 +6,7 @@
 
 use app_units::Au;
 use block::AbsoluteAssignBSizesTraversal;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use display_list_builder::{FragmentDisplayListBuilding, InlineFlowDisplayListBuilding};
 use euclid::{Point2D, Size2D};
@@ -1532,7 +1532,7 @@ impl Flow for InlineFlow {
         }
     }
 
-    fn compute_absolute_position(&mut self, _: &LayoutContext) {
+    fn compute_absolute_position(&mut self, _: &SharedLayoutContext) {
         // First, gather up the positions of all the containing blocks (if any).
         //
         // FIXME(pcwalton): This will get the absolute containing blocks inside `...` wrong in the

components/layout/list_item.rs

@@ -9,7 +9,7 @@
 
 use app_units::Au;
 use block::BlockFlow;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::{DisplayListBuildState, ListItemFlowDisplayListBuilding};
 use euclid::Point2D;
 use floats::FloatKind;
@@ -124,7 +124,7 @@ impl Flow for ListItemFlow {
         }
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/multicol.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use block::BlockFlow;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use euclid::Size2D;
@@ -163,7 +163,7 @@ impl Flow for MulticolFlow {
         }
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context);
         let pitch = LogicalSize::new(self.block_flow.base.writing_mode, self.column_pitch, Au(0));
         let pitch = pitch.to_physical(self.block_flow.base.writing_mode);
@@ -254,7 +254,7 @@ impl Flow for MulticolColumnFlow {
         Flow::fragment(&mut self.block_flow, layout_context, fragmentation_context)
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/sequential.rs

@@ -82,14 +82,13 @@ pub fn build_display_list_for_subtree(root: &mut FlowRef,
                                       shared_layout_context: &SharedLayoutContext)
                                       -> Vec<DisplayItem> {
     let flow_root = flow_ref::deref_mut(root);
-    let layout_context = LayoutContext::new(shared_layout_context);
-    flow_root.traverse_preorder(&ComputeAbsolutePositions { layout_context: &layout_context });
+    flow_root.traverse_preorder(&ComputeAbsolutePositions { layout_context: shared_layout_context });
     let mut children = vec![];
     flow_root.collect_stacking_contexts(root_stacking_context.id,
                                         &mut children);
     root_stacking_context.add_children(children);
     let mut build_display_list = BuildDisplayList {
-        state: DisplayListBuildState::new(&layout_context,
+        state: DisplayListBuildState::new(shared_layout_context,
                                           flow::base(&*flow_root).stacking_context_id),
     };
     build_display_list.traverse(&mut *flow_root);

components/layout/table.rs

@@ -9,7 +9,7 @@
 use app_units::Au;
 use block::{BlockFlow, CandidateBSizeIterator, ISizeAndMarginsComputer};
 use block::{ISizeConstraintInput, ISizeConstraintSolution};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode, DisplayListBuildState};
 use euclid::Point2D;
 use flow;
@@ -434,7 +434,7 @@ impl Flow for TableFlow {
         self.block_flow.assign_block_size_for_table_like_flow(vertical_spacing)
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/table_caption.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use block::BlockFlow;
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use flow::{Flow, FlowClass, OpaqueFlow};
@@ -66,7 +66,7 @@ impl Flow for TableCaptionFlow {
         self.block_flow.assign_block_size(layout_context);
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/table_cell.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use block::{BlockFlow, ISizeAndMarginsComputer, MarginsMayCollapseFlag};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use cssparser::Color;
 use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode, DisplayListBuildState};
 use euclid::{Point2D, Rect, SideOffsets2D, Size2D};
@@ -208,7 +208,7 @@ impl Flow for TableCellFlow {
         self.assign_block_size_table_cell_base(layout_context);
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/table_row.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use block::{BlockFlow, ISizeAndMarginsComputer};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use cssparser::{Color, RGBA};
 use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode, DisplayListBuildState};
 use euclid::Point2D;
@@ -413,7 +413,7 @@ impl Flow for TableRowFlow {
         self.assign_block_size_table_row_base(layout_context);
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/table_rowgroup.rs

@@ -8,7 +8,7 @@
 
 use app_units::Au;
 use block::{BlockFlow, ISizeAndMarginsComputer};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use flow::{Flow, FlowClass, OpaqueFlow};
@@ -195,7 +195,7 @@ impl Flow for TableRowGroupFlow {
         self.block_flow.assign_block_size_for_table_like_flow(self.spacing.vertical)
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/table_wrapper.rs

@@ -16,7 +16,7 @@
 use app_units::Au;
 use block::{AbsoluteNonReplaced, BlockFlow, FloatNonReplaced, ISizeAndMarginsComputer, ISizeConstraintInput};
 use block::{ISizeConstraintSolution, MarginsMayCollapseFlag};
-use context::LayoutContext;
+use context::{LayoutContext, SharedLayoutContext};
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use floats::FloatKind;
@@ -413,7 +413,7 @@ impl Flow for TableWrapperFlow {
         debug_assert!(remaining.is_none());
     }
 
-    fn compute_absolute_position(&mut self, layout_context: &LayoutContext) {
+    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {
         self.block_flow.compute_absolute_position(layout_context)
     }
 

components/layout/traversal.rs

@@ -198,7 +198,7 @@ impl<'a> PostorderFlowTraversal for AssignBSizes<'a> {
 
 #[derive(Copy, Clone)]
 pub struct ComputeAbsolutePositions<'a> {
-    pub layout_context: &'a LayoutContext<'a>,
+    pub layout_context: &'a SharedLayoutContext,
 }
 
 impl<'a> PreorderFlowTraversal for ComputeAbsolutePositions<'a> {