Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 04:30:10 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
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 -->
This commit is contained in:
bors-servo 2016-08-24 09:38:31 -05:00 • committed by GitHub
commit 6191748907
18 changed files with 66 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

10
components/layout/block.rs
View file

@ -28,7 +28,7 @@
#![deny(unsafe_code)] #![deny(unsafe_code)]
use app_units::{Au, MAX_AU}; use app_units::{Au, MAX_AU};
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::BlockFlowDisplayListBuilding; use display_list_builder::BlockFlowDisplayListBuilding;
use display_list_builder::{BorderPaintingMode, DisplayListBuildState, FragmentDisplayListBuilding}; use display_list_builder::{BorderPaintingMode, DisplayListBuildState, FragmentDisplayListBuilding};
use euclid::{Point2D, Rect, Size2D}; 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) { if self.base.flags.contains(NEEDS_LAYER) {
self.fragment.flags.insert(HAS_LAYER) self.fragment.flags.insert(HAS_LAYER)
} }
@ -1969,12 +1969,12 @@ impl Flow for BlockFlow {
let stacking_relative_position_of_display_port_for_children = let stacking_relative_position_of_display_port_for_children =
if is_stacking_context || self.is_root() { if is_stacking_context || self.is_root() {
let visible_rect = 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, 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, visible_rect.inflate(viewport_size.width * DISPLAY_PORT_SIZE_FACTOR,
viewport_size.height * DISPLAY_PORT_SIZE_FACTOR) viewport_size.height * DISPLAY_PORT_SIZE_FACTOR)
} else if is_stacking_context { } else if is_stacking_context {

8
components/layout/construct.rs
View file

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

19
components/layout/context.rs
View file

@ -130,13 +130,15 @@ impl<'a> LayoutContext<'a> {
pub fn font_context(&self) -> RefMut<FontContext> { pub fn font_context(&self) -> RefMut<FontContext> {
self.cached_local_layout_context.font_context.borrow_mut() self.cached_local_layout_context.font_context.borrow_mut()
} }
}
impl SharedLayoutContext {
fn get_or_request_image_synchronously(&self, url: Url, use_placeholder: UsePlaceholder) fn get_or_request_image_synchronously(&self, url: Url, use_placeholder: UsePlaceholder)
-> Option<Arc<Image>> { -> Option<Arc<Image>> {
debug_assert!(opts::get().output_file.is_some() || opts::get().exit_after_load); debug_assert!(opts::get().output_file.is_some() || opts::get().exit_after_load);
// See if the image is already available // 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 { match result {
Ok(image) => return Some(image), 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 // 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. // image load or we risk emitting an output file missing the image.
let (sync_tx, sync_rx) = ipc::channel().unwrap(); 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 { loop {
match sync_rx.recv() { match sync_rx.recv() {
Err(_) => return None, Err(_) => return None,
@ -174,16 +176,16 @@ impl<'a> LayoutContext<'a> {
.map(|img| ImageOrMetadataAvailable::ImageAvailable(img)); .map(|img| ImageOrMetadataAvailable::ImageAvailable(img));
} }
// See if the image is already available // See if the image is already available
let result = self.shared.image_cache_thread.find_image_or_metadata(url.clone(), let result = self.image_cache_thread.find_image_or_metadata(url.clone(),
use_placeholder); use_placeholder);
match result { match result {
Ok(image_or_metadata) => Some(image_or_metadata), Ok(image_or_metadata) => Some(image_or_metadata),
// Image failed to load, so just return nothing // Image failed to load, so just return nothing
Err(ImageState::LoadError) => None, Err(ImageState::LoadError) => None,
// Not yet requested, async mode - request image or metadata from the cache // Not yet requested, async mode - request image or metadata from the cache
Err(ImageState::NotRequested) => { Err(ImageState::NotRequested) => {
let sender = self.shared.image_cache_sender.lock().unwrap().clone(); let sender = self.image_cache_sender.lock().unwrap().clone();
self.shared.image_cache_thread.request_image_and_metadata(url, sender, None); self.image_cache_thread.request_image_and_metadata(url, sender, None);
None None
} }
// Image has been requested, is still pending. Return no image for this paint loop. // 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) fetch_image_data_as_well: bool)
-> Option<(WebRenderImageInfo, Option<IpcSharedMemory>)> { -> Option<(WebRenderImageInfo, Option<IpcSharedMemory>)> {
if !fetch_image_data_as_well { 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) = if let Some(existing_webrender_image) =
webrender_image_cache.get(&((*url).clone(), use_placeholder)) { webrender_image_cache.get(&((*url).clone(), use_placeholder)) {
return Some(((*existing_webrender_image).clone(), None)) return Some(((*existing_webrender_image).clone(), None))
@ -216,8 +218,7 @@ impl<'a> LayoutContext<'a> {
}; };
Some((image_info, bytes)) Some((image_info, bytes))
} else if !fetch_image_data_as_well { } else if !fetch_image_data_as_well {
let mut webrender_image_cache = self.shared let mut webrender_image_cache = self.webrender_image_cache
.webrender_image_cache
.write() .write()
.unwrap(); .unwrap();
webrender_image_cache.insert(((*url).clone(), use_placeholder), webrender_image_cache.insert(((*url).clone(), use_placeholder),

17
components/layout/display_list_builder.rs
View file

@ -14,7 +14,7 @@ use app_units::{Au, AU_PER_PX};
use azure::azure_hl::Color; use azure::azure_hl::Color;
use block::{BlockFlow, BlockStackingContextType}; use block::{BlockFlow, BlockStackingContextType};
use canvas_traits::{CanvasMsg, CanvasData, FromLayoutMsg}; use canvas_traits::{CanvasMsg, CanvasData, FromLayoutMsg};
use context::LayoutContext; use context::SharedLayoutContext;
use euclid::{Matrix4D, Point2D, Point3D, Radians, Rect, SideOffsets2D, Size2D}; use euclid::{Matrix4D, Point2D, Point3D, Radians, Rect, SideOffsets2D, Size2D};
use flex::FlexFlow; use flex::FlexFlow;
use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED}; 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 struct DisplayListBuildState<'a> {
pub layout_context: &'a LayoutContext<'a>, pub shared_layout_context: &'a SharedLayoutContext,
pub items: Vec<DisplayItem>, pub items: Vec<DisplayItem>,
pub stacking_context_id_stack: Vec<StackingContextId>, pub stacking_context_id_stack: Vec<StackingContextId>,
} }
impl<'a> DisplayListBuildState<'a> { 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<'a> {
DisplayListBuildState { DisplayListBuildState {
layout_context: layout_context, shared_layout_context: shared_layout_context,
items: Vec::new(), items: Vec::new(),
stacking_context_id_stack: vec!(stacking_context_id), stacking_context_id_stack: vec!(stacking_context_id),
} }
@ -491,10 +492,10 @@ impl FragmentDisplayListBuilding for Fragment {
index: usize) { index: usize) {
let background = style.get_background(); let background = style.get_background();
let fetch_image_data_as_well = !opts::get().use_webrender; let fetch_image_data_as_well = !opts::get().use_webrender;
let webrender_image = let webrender_image = state.shared_layout_context
state.layout_context.get_webrender_image_for_url(image_url, .get_webrender_image_for_url(image_url,
UsePlaceholder::No, UsePlaceholder::No,
fetch_image_data_as_well); fetch_image_data_as_well);
if let Some((webrender_image, image_data)) = webrender_image { if let Some((webrender_image, image_data)) = webrender_image {
debug!("(building display list) building background image"); debug!("(building display list) building background image");

4
components/layout/flex.rs
View file

@ -8,7 +8,7 @@
use app_units::{Au, MAX_AU}; use app_units::{Au, MAX_AU};
use block::BlockFlow; use block::BlockFlow;
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::{DisplayListBuildState, FlexFlowDisplayListBuilding}; use display_list_builder::{DisplayListBuildState, FlexFlowDisplayListBuilding};
use euclid::Point2D; use euclid::Point2D;
use floats::FloatKind; 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) self.block_flow.compute_absolute_position(layout_context)
} }

4
components/layout/flow.rs
View file

@ -27,7 +27,7 @@
use app_units::Au; use app_units::Au;
use block::{BlockFlow, FormattingContextType}; use block::{BlockFlow, FormattingContextType};
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState; use display_list_builder::DisplayListBuildState;
use euclid::{Point2D, Rect, Size2D}; use euclid::{Point2D, Rect, Size2D};
use floats::{Floats, SpeculatedFloatPlacement}; use floats::{Floats, SpeculatedFloatPlacement};
@ -318,7 +318,7 @@ pub trait Flow: fmt::Debug + Sync + Send + 'static {
} }
/// Phase 4 of reflow: computes absolute positions. /// 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. // The default implementation is a no-op.
} }

19
components/layout/fragment.rs
View file

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

4
components/layout/inline.rs
View file

@ -6,7 +6,7 @@
use app_units::Au; use app_units::Au;
use block::AbsoluteAssignBSizesTraversal; use block::AbsoluteAssignBSizesTraversal;
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState; use display_list_builder::DisplayListBuildState;
use display_list_builder::{FragmentDisplayListBuilding, InlineFlowDisplayListBuilding}; use display_list_builder::{FragmentDisplayListBuilding, InlineFlowDisplayListBuilding};
use euclid::{Point2D, Size2D}; 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). // 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 // FIXME(pcwalton): This will get the absolute containing blocks inside `...` wrong in the

4
components/layout/list_item.rs
View file

@ -9,7 +9,7 @@
use app_units::Au; use app_units::Au;
use block::BlockFlow; use block::BlockFlow;
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::{DisplayListBuildState, ListItemFlowDisplayListBuilding}; use display_list_builder::{DisplayListBuildState, ListItemFlowDisplayListBuilding};
use euclid::Point2D; use euclid::Point2D;
use floats::FloatKind; 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) self.block_flow.compute_absolute_position(layout_context)
} }

6
components/layout/multicol.rs
View file

@ -8,7 +8,7 @@
use app_units::Au; use app_units::Au;
use block::BlockFlow; use block::BlockFlow;
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState; use display_list_builder::DisplayListBuildState;
use euclid::Point2D; use euclid::Point2D;
use euclid::Size2D; 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); 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 = LogicalSize::new(self.block_flow.base.writing_mode, self.column_pitch, Au(0));
let pitch = pitch.to_physical(self.block_flow.base.writing_mode); 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) 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) self.block_flow.compute_absolute_position(layout_context)
} }

5
components/layout/sequential.rs
View file

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

4
components/layout/table.rs
View file

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

4
components/layout/table_caption.rs
View file

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

4
components/layout/table_cell.rs
View file

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

4
components/layout/table_row.rs
View file

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

4
components/layout/table_rowgroup.rs
View file

@ -8,7 +8,7 @@
use app_units::Au; use app_units::Au;
use block::{BlockFlow, ISizeAndMarginsComputer}; use block::{BlockFlow, ISizeAndMarginsComputer};
use context::LayoutContext; use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState; use display_list_builder::DisplayListBuildState;
use euclid::Point2D; use euclid::Point2D;
use flow::{Flow, FlowClass, OpaqueFlow}; 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) 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) self.block_flow.compute_absolute_position(layout_context)
} }

4
components/layout/table_wrapper.rs
View file

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

2
components/layout/traversal.rs
View file

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