aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--components/gfx/display_list/mod.rs52
-rw-r--r--components/layout/block.rs5
-rw-r--r--components/layout/display_list_builder.rs319
-rw-r--r--components/layout/flex.rs3
-rw-r--r--components/layout/flow.rs7
-rw-r--r--components/layout/inline.rs3
-rw-r--r--components/layout/list_item.rs3
-rw-r--r--components/layout/multicol.rs6
-rw-r--r--components/layout/sequential.rs5
-rw-r--r--components/layout/table.rs3
-rw-r--r--components/layout/table_caption.rs4
-rw-r--r--components/layout/table_cell.rs3
-rw-r--r--components/layout/table_colgroup.rs4
-rw-r--r--components/layout/table_row.rs3
-rw-r--r--components/layout/table_rowgroup.rs4
-rw-r--r--components/layout/table_wrapper.rs4
-rw-r--r--components/layout/webrender_helpers.rs28
17 files changed, 258 insertions, 198 deletions
diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs
index 99a99a47b81..4e0aae44796 100644
--- a/components/gfx/display_list/mod.rs
+++ b/components/gfx/display_list/mod.rs
@@ -77,7 +77,7 @@ impl<'a> ScrollOffsetLookup<'a> {
None => return None,
};
- let scroll_offset = self.full_offset_for_scroll_root(&clip_id);
+ let scroll_offset = self.full_offset_for_clip_scroll_node(&clip_id);
*point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
point.y - Au::from_f32_px(scroll_offset.y));
let frac_point = inv_transform.transform_point2d(&Point2D::new(point.x.to_f32_px(),
@@ -93,18 +93,18 @@ impl<'a> ScrollOffsetLookup<'a> {
Some(sublookup)
}
- fn add_scroll_root(&mut self, scroll_root: &ScrollRoot) {
- self.parents.insert(scroll_root.id, scroll_root.parent_id);
+ fn add_clip_scroll_node(&mut self, clip_scroll_node: &ClipScrollNode) {
+ self.parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
}
- fn full_offset_for_scroll_root(&mut self, id: &ClipId) -> Vector2D<f32> {
+ fn full_offset_for_clip_scroll_node(&mut self, id: &ClipId) -> Vector2D<f32> {
if let Some(offset) = self.calculated_total_offsets.get(id) {
return *offset;
}
let parent_offset = if !id.is_root_scroll_node() {
let parent_id = *self.parents.get(id).unwrap();
- self.full_offset_for_scroll_root(&parent_id)
+ self.full_offset_for_clip_scroll_node(&parent_id)
} else {
Vector2D::zero()
};
@@ -160,8 +160,8 @@ impl DisplayList {
offset_lookup,
result);
}
- &DisplayItem::DefineClip(ref item) => {
- offset_lookup.add_scroll_root(&item.scroll_root);
+ &DisplayItem::DefineClipScrollNode(ref item) => {
+ offset_lookup.add_clip_scroll_node(&item.node);
}
&DisplayItem::PopStackingContext(_) => return,
&DisplayItem::Text(ref text) => {
@@ -237,8 +237,8 @@ impl DisplayList {
result);
}
&DisplayItem::PopStackingContext(_) => return,
- &DisplayItem::DefineClip(ref item) => {
- offset_lookup.add_scroll_root(&item.scroll_root);
+ &DisplayItem::DefineClipScrollNode(ref item) => {
+ offset_lookup.add_clip_scroll_node(&item.node);
}
_ => {
if let Some(meta) = item.hit_test(*point, offset_lookup) {
@@ -558,20 +558,20 @@ impl fmt::Debug for StackingContext {
}
#[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
-pub enum ScrollRootType {
+pub enum ClipScrollNodeType {
ScrollFrame(ScrollSensitivity),
StickyFrame(StickyFrameInfo),
Clip,
}
-/// Defines a stacking context.
+/// Defines a clip scroll node.
#[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
-pub struct ScrollRoot {
+pub struct ClipScrollNode {
/// The WebRender clip id of this scroll root based on the source of this clip
/// and information about the fragment.
pub id: ClipId,
- /// The unique ID of the parent of this ScrollRoot.
+ /// The unique ID of the parent of this ClipScrollNode.
pub parent_id: ClipId,
/// The position of this scroll root's frame in the parent stacking context.
@@ -580,15 +580,15 @@ pub struct ScrollRoot {
/// The rect of the contents that can be scrolled inside of the scroll root.
pub content_rect: Rect<Au>,
- /// The type of this ScrollRoot.
- pub root_type: ScrollRootType
+ /// The type of this ClipScrollNode.
+ pub node_type: ClipScrollNodeType,
}
-impl ScrollRoot {
+impl ClipScrollNode {
pub fn to_define_item(&self, pipeline_id: PipelineId) -> DisplayItem {
- DisplayItem::DefineClip(box DefineClipItem {
+ DisplayItem::DefineClipScrollNode(box DefineClipScrollNodeItem {
base: BaseDisplayItem::empty(pipeline_id),
- scroll_root: self.clone(),
+ node: self.clone(),
})
}
}
@@ -610,7 +610,7 @@ pub enum DisplayItem {
Iframe(Box<IframeDisplayItem>),
PushStackingContext(Box<PushStackingContextItem>),
PopStackingContext(Box<PopStackingContextItem>),
- DefineClip(Box<DefineClipItem>),
+ DefineClipScrollNode(Box<DefineClipScrollNodeItem>),
}
/// Information common to all display items.
@@ -1215,12 +1215,12 @@ pub struct PopStackingContextItem {
/// Starts a group of items inside a particular scroll root.
#[derive(Clone, Deserialize, HeapSizeOf, Serialize)]
-pub struct DefineClipItem {
+pub struct DefineClipScrollNodeItem {
/// Fields common to all display items.
pub base: BaseDisplayItem,
/// The scroll root that this item starts.
- pub scroll_root: ScrollRoot,
+ pub node: ClipScrollNode,
}
/// How a box shadow should be clipped.
@@ -1252,7 +1252,7 @@ impl DisplayItem {
DisplayItem::Iframe(ref iframe) => &iframe.base,
DisplayItem::PushStackingContext(ref stacking_context) => &stacking_context.base,
DisplayItem::PopStackingContext(ref item) => &item.base,
- DisplayItem::DefineClip(ref item) => &item.base,
+ DisplayItem::DefineClipScrollNode(ref item) => &item.base,
}
}
@@ -1292,7 +1292,7 @@ impl DisplayItem {
// test elements with `border-radius`, for example.
let base_item = self.base();
- let scroll_offset = offset_lookup.full_offset_for_scroll_root(&self.scroll_node_id());
+ let scroll_offset = offset_lookup.full_offset_for_clip_scroll_node(&self.scroll_node_id());
let point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
point.y - Au::from_f32_px(scroll_offset.y));
@@ -1349,8 +1349,8 @@ impl fmt::Debug for DisplayItem {
return write!(f, "PopStackingContext({:?}", item.stacking_context_id);
}
- if let DisplayItem::DefineClip(ref item) = *self {
- return write!(f, "DefineClip({:?}", item.scroll_root);
+ if let DisplayItem::DefineClipScrollNode(ref item) = *self {
+ return write!(f, "DefineClipScrollNode({:?}", item.node);
}
write!(f, "{} @ {:?} {:?}",
@@ -1377,7 +1377,7 @@ impl fmt::Debug for DisplayItem {
DisplayItem::Iframe(_) => "Iframe".to_owned(),
DisplayItem::PushStackingContext(_) |
DisplayItem::PopStackingContext(_) |
- DisplayItem::DefineClip(_) => "".to_owned(),
+ DisplayItem::DefineClipScrollNode(_) => "".to_owned(),
},
self.bounds(),
self.base().local_clip
diff --git a/components/layout/block.rs b/components/layout/block.rs
index de151fd9a28..6ecf6bc77c1 100644
--- a/components/layout/block.rs
+++ b/components/layout/block.rs
@@ -31,6 +31,7 @@ use app_units::{Au, MAX_AU};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use display_list_builder::{DisplayListBuildState, EstablishContainingBlock};
+use display_list_builder::StackingContextCollectionState;
use euclid::{Point2D, Rect, SideOffsets2D, Size2D};
use floats::{ClearType, FloatKind, Floats, PlacementInfo};
use flow::{self, BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ForceNonfloatedFlag};
@@ -1679,7 +1680,7 @@ impl BlockFlow {
}
}
- pub fn overflow_style_may_require_scroll_root(&self) -> bool {
+ pub fn overflow_style_may_require_clip_scroll_node(&self) -> bool {
match (self.fragment.style().get_box().overflow_x,
self.fragment.style().get_box().overflow_y) {
(overflow_x::T::auto, _) | (overflow_x::T::scroll, _) | (overflow_x::T::hidden, _) |
@@ -2150,7 +2151,7 @@ impl Flow for BlockFlow {
}
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.collect_stacking_contexts_for_block(state, EstablishContainingBlock::Yes);
}
diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs
index d38db2a0061..4379de6e6e4 100644
--- a/components/layout/display_list_builder.rs
+++ b/components/layout/display_list_builder.rs
@@ -19,23 +19,24 @@ use euclid::Vector2D;
use flex::FlexFlow;
use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED};
use flow_ref::FlowRef;
+use fnv::FnvHashMap;
use fragment::{CanvasFragmentSource, CoordinateSystem, Fragment, ImageFragmentInfo, ScannedTextFragmentInfo};
use fragment::{SpecificFragmentInfo, TruncatedFragmentInfo};
use gfx::display_list;
use gfx::display_list::{BLUR_INFLATION_FACTOR, BaseDisplayItem, BorderDetails, BorderDisplayItem};
-use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClippingRegion};
-use gfx::display_list::{DisplayItem, DisplayItemMetadata, DisplayList, DisplayListSection};
-use gfx::display_list::{GradientDisplayItem, IframeDisplayItem, ImageBorder, ImageDisplayItem};
-use gfx::display_list::{LineDisplayItem, NormalBorder, OpaqueNode, PushTextShadowDisplayItem};
-use gfx::display_list::{PopTextShadowDisplayItem, RadialGradientDisplayItem, ScrollRoot};
-use gfx::display_list::{ScrollRootType, SolidColorDisplayItem, StackingContext, StackingContextType};
-use gfx::display_list::{TextDisplayItem, TextOrientation, WebRenderImageInfo};
+use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClipScrollNode};
+use gfx::display_list::{ClipScrollNodeType, ClippingRegion, DisplayItem, DisplayItemMetadata};
+use gfx::display_list::{DisplayList, DisplayListSection, GradientDisplayItem, IframeDisplayItem};
+use gfx::display_list::{ImageBorder, ImageDisplayItem, LineDisplayItem, NormalBorder, OpaqueNode};
+use gfx::display_list::{PopTextShadowDisplayItem, PushTextShadowDisplayItem};
+use gfx::display_list::{RadialGradientDisplayItem, SolidColorDisplayItem, StackingContext};
+use gfx::display_list::{StackingContextType, TextDisplayItem, TextOrientation, WebRenderImageInfo};
use gfx_traits::{combine_id_with_fragment_type, FragmentType, StackingContextId};
use inline::{FIRST_FRAGMENT_OF_ELEMENT, InlineFlow, LAST_FRAGMENT_OF_ELEMENT};
use ipc_channel::ipc;
use list_item::ListItemFlow;
use model::{self, MaybeAuto};
-use msg::constellation_msg::BrowsingContextId;
+use msg::constellation_msg::{BrowsingContextId, PipelineId};
use net_traits::image::base::PixelFormat;
use net_traits::image_cache::UsePlaceholder;
use range::Range;
@@ -44,7 +45,6 @@ use servo_config::opts;
use servo_geometry::max_rect;
use servo_url::ServoUrl;
use std::{cmp, f32};
-use std::collections::HashMap;
use std::default::Default;
use std::mem;
use std::sync::Arc;
@@ -143,14 +143,14 @@ fn get_cyclic<T>(arr: &[T], index: usize) -> &T {
#[derive(Debug)]
struct StackingContextInfo {
children: Vec<StackingContext>,
- scroll_roots: Vec<ScrollRoot>,
+ clip_scroll_nodes: Vec<ClipScrollNode>,
}
impl StackingContextInfo {
fn new() -> StackingContextInfo {
StackingContextInfo {
children: Vec::new(),
- scroll_roots: Vec::new(),
+ clip_scroll_nodes: Vec::new(),
}
}
@@ -159,13 +159,18 @@ impl StackingContextInfo {
}
}
-pub struct DisplayListBuildState<'a> {
- pub layout_context: &'a LayoutContext<'a>,
+pub struct StackingContextCollectionState {
+ /// The PipelineId of this stacking context collection.
+ pub pipeline_id: PipelineId,
+
+ /// The root of the StackingContext tree.
pub root_stacking_context: StackingContext,
- pub items: HashMap<StackingContextId, Vec<DisplayItem>>,
- stacking_context_info: HashMap<StackingContextId, StackingContextInfo>,
- pub scroll_root_parents: HashMap<ClipId, ClipId>,
- pub processing_scroll_root_element: bool,
+
+ /// StackingContext and ClipScrollNode children for each StackingContext.
+ stacking_context_info: FnvHashMap<StackingContextId, StackingContextInfo>,
+
+ /// A map establishing the parent child relationship of every ClipScrollNode.
+ pub clip_scroll_node_parents: FnvHashMap<ClipId, ClipId>,
/// The current stacking context id, used to keep track of state when building.
/// recursively building and processing the display list.
@@ -183,10 +188,6 @@ pub struct DisplayListBuildState<'a> {
/// by their containing block's scroll root.
pub containing_block_clip_and_scroll_info: ClipAndScrollInfo,
- /// Vector containing iframe sizes, used to inform the constellation about
- /// new iframe sizes
- pub iframe_sizes: Vec<(BrowsingContextId, TypedSize2D<f32, CSSPixel>)>,
-
/// A stack of clips used to cull display list entries that are outside the
/// rendered region.
pub clip_stack: Vec<Rect<Au>>,
@@ -199,32 +200,24 @@ pub struct DisplayListBuildState<'a> {
parent_stacking_relative_content_box: Rect<Au>,
}
-impl<'a> DisplayListBuildState<'a> {
- pub fn new(layout_context: &'a LayoutContext) -> DisplayListBuildState<'a> {
- let root_clip_info = ClipAndScrollInfo::simple(layout_context.id.root_scroll_node());
- DisplayListBuildState {
- layout_context: layout_context,
- root_stacking_context: StackingContext::root(layout_context.id),
- items: HashMap::new(),
- stacking_context_info: HashMap::new(),
- scroll_root_parents: HashMap::new(),
- processing_scroll_root_element: false,
+impl StackingContextCollectionState {
+ pub fn new(pipeline_id: PipelineId) -> StackingContextCollectionState {
+ let root_clip_info = ClipAndScrollInfo::simple(pipeline_id.root_scroll_node());
+ StackingContextCollectionState {
+ pipeline_id: pipeline_id,
+ root_stacking_context: StackingContext::root(pipeline_id),
+ stacking_context_info: FnvHashMap::default(),
+ clip_scroll_node_parents: FnvHashMap::default(),
current_stacking_context_id: StackingContextId::root(),
current_real_stacking_context_id: StackingContextId::root(),
current_clip_and_scroll_info: root_clip_info,
containing_block_clip_and_scroll_info: root_clip_info,
- iframe_sizes: Vec::new(),
clip_stack: Vec::new(),
containing_block_clip_stack: Vec::new(),
parent_stacking_relative_content_box: Rect::zero(),
}
}
- fn add_display_item(&mut self, display_item: DisplayItem) {
- let items = self.items.entry(display_item.stacking_context_id()).or_insert(Vec::new());
- items.push(display_item);
- }
-
fn add_stacking_context(&mut self,
parent_id: StackingContextId,
stacking_context: StackingContext) {
@@ -234,35 +227,92 @@ impl<'a> DisplayListBuildState<'a> {
info.children.push(stacking_context);
}
- fn has_scroll_root(&mut self, id: ClipId) -> bool {
- self.scroll_root_parents.contains_key(&id)
+ fn has_clip_scroll_node(&mut self, id: ClipId) -> bool {
+ self.clip_scroll_node_parents.contains_key(&id)
}
- fn add_scroll_root(&mut self, scroll_root: ScrollRoot) {
- // We want the scroll root to be defined by another other possible item that could use it,
+ fn add_clip_scroll_node(&mut self, clip_scroll_node: ClipScrollNode) {
+ // We want the scroll root to be defined before any possible item that could use it,
// so we make sure that it is added to the beginning of the parent "real" (non-pseudo)
// stacking context. This ensures that item reordering will not result in an item using
// the scroll root before it is defined.
- self.scroll_root_parents.insert(scroll_root.id, scroll_root.parent_id);
+ self.clip_scroll_node_parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
let info = self.stacking_context_info
.entry(self.current_real_stacking_context_id)
.or_insert(StackingContextInfo::new());
- info.scroll_roots.push(scroll_root);
+ info.clip_scroll_nodes.push(clip_scroll_node);
+ }
+}
+
+pub struct DisplayListBuildState<'a> {
+ /// A LayoutContext reference important for creating WebRender images.
+ pub layout_context: &'a LayoutContext<'a>,
+
+ /// The root of the StackingContext tree.
+ pub root_stacking_context: StackingContext,
+
+ /// StackingContext and ClipScrollNode children for each StackingContext.
+ stacking_context_info: FnvHashMap<StackingContextId, StackingContextInfo>,
+
+ /// A map establishing the parent child relationship of every ClipScrollNode.
+ pub clip_scroll_node_parents: FnvHashMap<ClipId, ClipId>,
+
+ /// The items in this display list.
+ pub items: FnvHashMap<StackingContextId, Vec<DisplayItem>>,
+
+ /// Whether or not we are processing an element that establishes scrolling overflow. Used
+ /// to determine what ClipScrollNode to place backgrounds and borders into.
+ pub processing_scrolling_overflow_element: bool,
+
+ /// The current stacking context id, used to keep track of state when building.
+ /// recursively building and processing the display list.
+ pub current_stacking_context_id: StackingContextId,
+
+ /// The current clip and scroll info, used to keep track of state when
+ /// recursively building and processing the display list.
+ pub current_clip_and_scroll_info: ClipAndScrollInfo,
+
+ /// Vector containing iframe sizes, used to inform the constellation about
+ /// new iframe sizes
+ pub iframe_sizes: Vec<(BrowsingContextId, TypedSize2D<f32, CSSPixel>)>,
+}
+
+impl<'a> DisplayListBuildState<'a> {
+ pub fn new(layout_context: &'a LayoutContext,
+ state: StackingContextCollectionState)
+ -> DisplayListBuildState<'a> {
+ let root_clip_info = ClipAndScrollInfo::simple(layout_context.id.root_scroll_node());
+ DisplayListBuildState {
+ layout_context: layout_context,
+ root_stacking_context: state.root_stacking_context,
+ items: FnvHashMap::default(),
+ stacking_context_info: state.stacking_context_info,
+ clip_scroll_node_parents: state.clip_scroll_node_parents,
+ processing_scrolling_overflow_element: false,
+ current_stacking_context_id: StackingContextId::root(),
+ current_clip_and_scroll_info: root_clip_info,
+ iframe_sizes: Vec::new(),
+ }
}
- fn parent_scroll_root_id(&self, scroll_root_id: ClipId) -> ClipId {
- if scroll_root_id.is_root_scroll_node() {
- return scroll_root_id;
+ fn add_display_item(&mut self, display_item: DisplayItem) {
+ let items = self.items.entry(display_item.stacking_context_id()).or_insert(Vec::new());
+ items.push(display_item);
+ }
+
+ fn parent_clip_scroll_node_id(&self, clip_scroll_node_id: ClipId) -> ClipId {
+ if clip_scroll_node_id.is_root_scroll_node() {
+ return clip_scroll_node_id;
}
- debug_assert!(self.scroll_root_parents.contains_key(&scroll_root_id));
- *self.scroll_root_parents.get(&scroll_root_id).unwrap()
+ debug_assert!(self.clip_scroll_node_parents.contains_key(&clip_scroll_node_id));
+ *self.clip_scroll_node_parents.get(&clip_scroll_node_id).unwrap()
}
- fn is_background_or_border_of_scroll_root(&self, section: DisplayListSection) -> bool {
+ fn is_background_or_border_of_clip_scroll_node(&self, section: DisplayListSection) -> bool {
(section == DisplayListSection::BackgroundAndBorders ||
section == DisplayListSection::BlockBackgroundsAndBorders) &&
- self.processing_scroll_root_element
+ self.processing_scrolling_overflow_element
}
fn create_base_display_item(&self,
@@ -272,8 +322,8 @@ impl<'a> DisplayListBuildState<'a> {
cursor: Option<Cursor>,
section: DisplayListSection)
-> BaseDisplayItem {
- let clip_and_scroll_info = if self.is_background_or_border_of_scroll_root(section) {
- ClipAndScrollInfo::simple(self.parent_scroll_root_id(self.current_clip_and_scroll_info.scroll_node_id))
+ let clip_and_scroll_info = if self.is_background_or_border_of_clip_scroll_node(section) {
+ ClipAndScrollInfo::simple(self.parent_clip_scroll_node_id(self.current_clip_and_scroll_info.scroll_node_id))
} else {
self.current_clip_and_scroll_info
};
@@ -315,12 +365,12 @@ impl<'a> DisplayListBuildState<'a> {
let pipeline_id = self.layout_context.id;
if stacking_context.context_type != StackingContextType::Real {
- list.extend(info.scroll_roots.into_iter().map(|root| root.to_define_item(pipeline_id)));
+ list.extend(info.clip_scroll_nodes.into_iter().map(|root| root.to_define_item(pipeline_id)));
self.to_display_list_for_items(list, child_items, info.children);
} else {
let (push_item, pop_item) = stacking_context.to_display_list_items(pipeline_id);
list.push(push_item);
- list.extend(info.scroll_roots.into_iter().map(|root| root.to_define_item(pipeline_id)));
+ list.extend(info.clip_scroll_nodes.into_iter().map(|root| root.to_define_item(pipeline_id)));
self.to_display_list_for_items(list, child_items, info.children);
list.push(pop_item);
}
@@ -2270,47 +2320,47 @@ pub enum EstablishContainingBlock {
pub trait BlockFlowDisplayListBuilding {
fn collect_stacking_contexts_for_block(&mut self,
- state: &mut DisplayListBuildState,
+ state: &mut StackingContextCollectionState,
can_establish_containing_block: EstablishContainingBlock);
fn transform_clip_to_coordinate_space(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState);
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState);
fn setup_clipping_for_block(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState,
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState,
stacking_context_type: BlockStackingContextType,
can_establish_containing_block: EstablishContainingBlock)
-> ClipAndScrollInfo;
- fn setup_scroll_root_for_position(&mut self,
- state: &mut DisplayListBuildState,
- border_box: &Rect<Au>);
- fn setup_scroll_root_for_overflow(&mut self,
- state: &mut DisplayListBuildState,
- border_box: &Rect<Au>);
- fn setup_scroll_root_for_css_clip(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState,
- stacking_relative_border_box: &Rect<Au>);
+ fn setup_clip_scroll_node_for_position(&mut self,
+ state: &mut StackingContextCollectionState,
+ border_box: &Rect<Au>);
+ fn setup_clip_scroll_node_for_overflow(&mut self,
+ state: &mut StackingContextCollectionState,
+ border_box: &Rect<Au>);
+ fn setup_clip_scroll_node_for_css_clip(&mut self,
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState,
+ stacking_relative_border_box: &Rect<Au>);
fn create_pseudo_stacking_context_for_block(&mut self,
parent_stacking_context_id: StackingContextId,
parent_clip_and_scroll_info: ClipAndScrollInfo,
- state: &mut DisplayListBuildState);
+ state: &mut StackingContextCollectionState);
fn create_real_stacking_context_for_block(&mut self,
parent_stacking_context_id: StackingContextId,
parent_clip_and_scroll_info: ClipAndScrollInfo,
- state: &mut DisplayListBuildState);
+ state: &mut StackingContextCollectionState);
fn build_display_list_for_block(&mut self,
state: &mut DisplayListBuildState,
border_painting_mode: BorderPaintingMode);
}
-/// This structure manages ensuring that modification to DisplayListBuildState
-/// is only temporary. It's useful for moving recursively down the flow tree
-/// and ensuring that the state is restored for siblings. To use this structure,
-/// we must call PreservedDisplayListState::restore in order to restore the state.
+/// This structure manages ensuring that modification to StackingContextCollectionState is
+/// only temporary. It's useful for moving recursively down the flow tree and ensuring
+/// that the state is restored for siblings. To use this structure, we must call
+/// SavedStackingContextCollectionState::restore in order to restore the state.
/// TODO(mrobinson): It would be nice to use RAII here to avoid having to call restore.
-pub struct PreservedDisplayListState {
+pub struct SavedStackingContextCollectionState {
stacking_context_id: StackingContextId,
real_stacking_context_id: StackingContextId,
clip_and_scroll_info: ClipAndScrollInfo,
@@ -2320,9 +2370,9 @@ pub struct PreservedDisplayListState {
stacking_relative_content_box: Rect<Au>,
}
-impl PreservedDisplayListState {
- fn new(state: &mut DisplayListBuildState) -> PreservedDisplayListState {
- PreservedDisplayListState {
+impl SavedStackingContextCollectionState {
+ fn new(state: &mut StackingContextCollectionState) -> SavedStackingContextCollectionState {
+ SavedStackingContextCollectionState {
stacking_context_id: state.current_stacking_context_id,
real_stacking_context_id: state.current_real_stacking_context_id,
clip_and_scroll_info: state.current_clip_and_scroll_info,
@@ -2333,13 +2383,13 @@ impl PreservedDisplayListState {
}
}
- fn switch_to_containing_block_clip(&mut self, state: &mut DisplayListBuildState) {
+ fn switch_to_containing_block_clip(&mut self, state: &mut StackingContextCollectionState) {
let clip = state.containing_block_clip_stack.last().cloned().unwrap_or_else(max_rect);
state.clip_stack.push(clip);
self.clips_pushed += 1;
}
- fn restore(self, state: &mut DisplayListBuildState) {
+ fn restore(self, state: &mut StackingContextCollectionState) {
state.current_stacking_context_id = self.stacking_context_id;
state.current_real_stacking_context_id = self.real_stacking_context_id;
state.current_clip_and_scroll_info = self.clip_and_scroll_info;
@@ -2355,7 +2405,7 @@ impl PreservedDisplayListState {
}
fn push_clip(&mut self,
- state: &mut DisplayListBuildState,
+ state: &mut StackingContextCollectionState,
clip: &Rect<Au>,
positioning: position::T) {
let mut clip = *clip;
@@ -2377,8 +2427,8 @@ impl PreservedDisplayListState {
impl BlockFlowDisplayListBuilding for BlockFlow {
fn transform_clip_to_coordinate_space(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState) {
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState) {
if state.clip_stack.is_empty() {
return;
}
@@ -2436,9 +2486,9 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
}
fn collect_stacking_contexts_for_block(&mut self,
- state: &mut DisplayListBuildState,
+ state: &mut StackingContextCollectionState,
can_establish_containing_block: EstablishContainingBlock) {
- let mut preserved_state = PreservedDisplayListState::new(state);
+ let mut preserved_state = SavedStackingContextCollectionState::new(state);
let block_stacking_context_type = self.block_stacking_context_type();
self.base.stacking_context_id = match block_stacking_context_type {
@@ -2487,8 +2537,8 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
}
fn setup_clipping_for_block(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState,
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState,
stacking_context_type: BlockStackingContextType,
can_establish_containing_block: EstablishContainingBlock)
-> ClipAndScrollInfo {
@@ -2518,9 +2568,9 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
self.transform_clip_to_coordinate_space(state, preserved_state);
}
- self.setup_scroll_root_for_position(state, &stacking_relative_border_box);
- self.setup_scroll_root_for_overflow(state, &stacking_relative_border_box);
- self.setup_scroll_root_for_css_clip(state, preserved_state, &stacking_relative_border_box);
+ self.setup_clip_scroll_node_for_position(state, &stacking_relative_border_box);
+ self.setup_clip_scroll_node_for_overflow(state, &stacking_relative_border_box);
+ self.setup_clip_scroll_node_for_css_clip(state, preserved_state, &stacking_relative_border_box);
self.base.clip = state.clip_stack.last().cloned().unwrap_or_else(max_rect);
// We keep track of our position so that any stickily positioned elements can
@@ -2544,8 +2594,8 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
containing_clip_and_scroll_info
}
- fn setup_scroll_root_for_position(&mut self,
- state: &mut DisplayListBuildState,
+ fn setup_clip_scroll_node_for_position(&mut self,
+ state: &mut StackingContextCollectionState,
border_box: &Rect<Au>) {
if self.positioning() != position::T::sticky {
return;
@@ -2592,28 +2642,28 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
to_sticky_info(sticky_position.left,
to_max_offset(constraint_rect.max_x(), border_box_in_parent.max_x())));
- let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
- state.layout_context.id.to_webrender());
- let parent_id = self.clip_and_scroll_info(state.layout_context.id).scroll_node_id;
- state.add_scroll_root(
- ScrollRoot {
- id: new_scroll_root_id,
+ let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
+ state.pipeline_id.to_webrender());
+ let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
+ state.add_clip_scroll_node(
+ ClipScrollNode {
+ id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: ClippingRegion::from_rect(border_box),
content_rect: Rect::zero(),
- root_type: ScrollRootType::StickyFrame(sticky_frame_info),
+ node_type: ClipScrollNodeType::StickyFrame(sticky_frame_info),
},
);
- let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_scroll_root_id);
+ let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
- fn setup_scroll_root_for_overflow(&mut self,
- state: &mut DisplayListBuildState,
- border_box: &Rect<Au>) {
- if !self.overflow_style_may_require_scroll_root() {
+ fn setup_clip_scroll_node_for_overflow(&mut self,
+ state: &mut StackingContextCollectionState,
+ border_box: &Rect<Au>) {
+ if !self.overflow_style_may_require_clip_scroll_node() {
return;
}
@@ -2633,9 +2683,9 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
// If we already have a scroll root for this flow, just return. This can happen
// when fragments map to more than one flow, such as in the case of table
// wrappers. We just accept the first scroll root in that case.
- let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
- state.layout_context.id.to_webrender());
- if state.has_scroll_root(new_scroll_root_id) {
+ let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::OverflowClip),
+ state.pipeline_id.to_webrender());
+ if state.has_clip_scroll_node(new_clip_scroll_node_id) {
return;
}
@@ -2656,28 +2706,28 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
let content_size = self.base.overflow.scroll.origin + self.base.overflow.scroll.size;
let content_size = Size2D::new(content_size.x, content_size.y);
- let parent_id = self.clip_and_scroll_info(state.layout_context.id).scroll_node_id;
- state.add_scroll_root(
- ScrollRoot {
- id: new_scroll_root_id,
+ let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
+ state.add_clip_scroll_node(
+ ClipScrollNode {
+ id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: clip,
content_rect: Rect::new(content_box.origin, content_size),
- root_type: ScrollRootType::ScrollFrame(sensitivity),
+ node_type: ClipScrollNodeType::ScrollFrame(sensitivity),
},
);
- let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_scroll_root_id);
+ let new_clip_and_scroll_info = ClipAndScrollInfo::simple(new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
/// Adds a scroll root for a block to take the `clip` property into account
/// per CSS 2.1 § 11.1.2.
- fn setup_scroll_root_for_css_clip(&mut self,
- state: &mut DisplayListBuildState,
- preserved_state: &mut PreservedDisplayListState,
- stacking_relative_border_box: &Rect<Au>) {
+ fn setup_clip_scroll_node_for_css_clip(&mut self,
+ state: &mut StackingContextCollectionState,
+ preserved_state: &mut SavedStackingContextCollectionState,
+ stacking_relative_border_box: &Rect<Au>) {
// Account for `clip` per CSS 2.1 § 11.1.2.
let style_clip_rect = match self.fragment.style().get_effects().clip {
Either::First(style_clip_rect) => style_clip_rect,
@@ -2704,32 +2754,33 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
// We use the node id to create scroll roots for overflow properties, so we
// use the fragment address to do the same for CSS clipping.
// TODO(mrobinson): This should be more resilient while maintaining the space
- // efficiency of ScrollRootId.
- let new_scroll_root_id = ClipId::new(self.fragment.unique_id(IdType::CSSClip),
- state.layout_context.id.to_webrender());
+ // efficiency of ClipScrollNode.
+ let new_clip_scroll_node_id = ClipId::new(self.fragment.unique_id(IdType::CSSClip),
+ state.pipeline_id.to_webrender());
// If we already have a scroll root for this flow, just return. This can happen
// when fragments map to more than one flow, such as in the case of table
// wrappers. We just accept the first scroll root in that case.
- if state.has_scroll_root(new_scroll_root_id) {
+ if state.has_clip_scroll_node(new_clip_scroll_node_id) {
return;
}
let clip_rect = Rect::new(clip_origin, clip_size);
preserved_state.push_clip(state, &clip_rect, self.positioning());
- let parent_id = self.clip_and_scroll_info(state.layout_context.id).scroll_node_id;
- state.add_scroll_root(
- ScrollRoot {
- id: new_scroll_root_id,
+ let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id;
+ state.add_clip_scroll_node(
+ ClipScrollNode {
+ id: new_clip_scroll_node_id,
parent_id: parent_id,
clip: ClippingRegion::from_rect(&clip_rect),
content_rect: Rect::zero(), // content_rect isn't important for clips.
- root_type: ScrollRootType::Clip,
+ node_type: ClipScrollNodeType::Clip,
},
);
- let new_clip_and_scroll_info = ClipAndScrollInfo::new(new_scroll_root_id, new_scroll_root_id);
+ let new_clip_and_scroll_info = ClipAndScrollInfo::new(new_clip_scroll_node_id,
+ new_clip_scroll_node_id);
self.base.clip_and_scroll_info = Some(new_clip_and_scroll_info);
state.current_clip_and_scroll_info = new_clip_and_scroll_info;
}
@@ -2737,7 +2788,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
fn create_pseudo_stacking_context_for_block(&mut self,
parent_stacking_context_id: StackingContextId,
parent_clip_and_scroll_info: ClipAndScrollInfo,
- state: &mut DisplayListBuildState) {
+ state: &mut StackingContextCollectionState) {
let creation_mode = if self.base.flags.contains(IS_ABSOLUTELY_POSITIONED) ||
self.fragment.style.get_box().position != position::T::static_ {
StackingContextType::PseudoPositioned
@@ -2771,7 +2822,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
fn create_real_stacking_context_for_block(&mut self,
parent_stacking_context_id: StackingContextId,
parent_clip_and_scroll_info: ClipAndScrollInfo,
- state: &mut DisplayListBuildState) {
+ state: &mut StackingContextCollectionState) {
let scroll_policy = if self.is_fixed() {
ScrollPolicy::Fixed
} else {
@@ -2804,7 +2855,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
DisplayListSection::BlockBackgroundsAndBorders
};
- state.processing_scroll_root_element = self.has_scrolling_overflow();
+ state.processing_scrolling_overflow_element = self.has_scrolling_overflow();
// Add the box that starts the block context.
self.fragment
@@ -2822,13 +2873,13 @@ impl BlockFlowDisplayListBuilding for BlockFlow {
self.base.build_display_items_for_debugging_tint(state, self.fragment.node);
- state.processing_scroll_root_element = false;
+ state.processing_scrolling_overflow_element = false;
}
}
pub trait InlineFlowDisplayListBuilding {
- fn collect_stacking_contexts_for_inline(&mut self, state: &mut DisplayListBuildState);
+ fn collect_stacking_contexts_for_inline(&mut self, state: &mut StackingContextCollectionState);
fn build_display_list_for_inline_fragment_at_index(&mut self,
state: &mut DisplayListBuildState,
index: usize);
@@ -2836,7 +2887,7 @@ pub trait InlineFlowDisplayListBuilding {
}
impl InlineFlowDisplayListBuilding for InlineFlow {
- fn collect_stacking_contexts_for_inline(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts_for_inline(&mut self, state: &mut StackingContextCollectionState) {
self.base.stacking_context_id = state.current_stacking_context_id;
self.base.clip_and_scroll_info = Some(state.current_clip_and_scroll_info);
self.base.clip = state.clip_stack.last().cloned().unwrap_or_else(max_rect);
diff --git a/components/layout/flex.rs b/components/layout/flex.rs
index 3c0f66def82..063add9e1d5 100644
--- a/components/layout/flex.rs
+++ b/components/layout/flex.rs
@@ -10,6 +10,7 @@ use app_units::{Au, MAX_AU};
use block::{AbsoluteAssignBSizesTraversal, BlockFlow, MarginsMayCollapseFlag};
use context::LayoutContext;
use display_list_builder::{DisplayListBuildState, FlexFlowDisplayListBuilding};
+use display_list_builder::StackingContextCollectionState;
use euclid::Point2D;
use floats::FloatKind;
use flow;
@@ -988,7 +989,7 @@ impl Flow for FlexFlow {
self.build_display_list_for_flex(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts(state);
}
diff --git a/components/layout/flow.rs b/components/layout/flow.rs
index a2a05761438..b5afce9471b 100644
--- a/components/layout/flow.rs
+++ b/components/layout/flow.rs
@@ -28,7 +28,7 @@
use app_units::Au;
use block::{BlockFlow, FormattingContextType};
use context::LayoutContext;
-use display_list_builder::DisplayListBuildState;
+use display_list_builder::{DisplayListBuildState, StackingContextCollectionState};
use euclid::{Transform3D, Point2D, Vector2D, Rect, Size2D};
use flex::FlexFlow;
use floats::{Floats, SpeculatedFloatPlacement};
@@ -223,7 +223,7 @@ pub trait Flow: fmt::Debug + Sync + Send + 'static {
None
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState);
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState);
/// If this is a float, places it. The default implementation does nothing.
fn place_float_if_applicable<'a>(&mut self) {}
@@ -1110,7 +1110,8 @@ impl BaseFlow {
return self as *const BaseFlow as usize;
}
- pub fn collect_stacking_contexts_for_children(&mut self, state: &mut DisplayListBuildState) {
+ pub fn collect_stacking_contexts_for_children(&mut self,
+ state: &mut StackingContextCollectionState) {
for kid in self.children.iter_mut() {
kid.collect_stacking_contexts(state);
}
diff --git a/components/layout/inline.rs b/components/layout/inline.rs
index c38693c3340..e04ede22470 100644
--- a/components/layout/inline.rs
+++ b/components/layout/inline.rs
@@ -9,6 +9,7 @@ use app_units::{Au, MIN_AU};
use block::AbsoluteAssignBSizesTraversal;
use context::LayoutContext;
use display_list_builder::{DisplayListBuildState, InlineFlowDisplayListBuilding};
+use display_list_builder::StackingContextCollectionState;
use euclid::{Point2D, Size2D};
use floats::{FloatKind, Floats, PlacementInfo};
use flow::{self, BaseFlow, Flow, FlowClass, ForceNonfloatedFlag};
@@ -1659,7 +1660,7 @@ impl Flow for InlineFlow {
fn update_late_computed_block_position_if_necessary(&mut self, _: Au) {}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.collect_stacking_contexts_for_inline(state);
}
diff --git a/components/layout/list_item.rs b/components/layout/list_item.rs
index 22d2f8786d0..a8346411285 100644
--- a/components/layout/list_item.rs
+++ b/components/layout/list_item.rs
@@ -11,6 +11,7 @@ use app_units::Au;
use block::BlockFlow;
use context::{LayoutContext, with_thread_local_font_context};
use display_list_builder::{DisplayListBuildState, ListItemFlowDisplayListBuilding};
+use display_list_builder::StackingContextCollectionState;
use euclid::Point2D;
use floats::FloatKind;
use flow::{Flow, FlowClass, OpaqueFlow};
@@ -147,7 +148,7 @@ impl Flow for ListItemFlow {
self.build_display_list_for_list_item(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts(state);
}
diff --git a/components/layout/multicol.rs b/components/layout/multicol.rs
index 19ca037712b..8d59092956d 100644
--- a/components/layout/multicol.rs
+++ b/components/layout/multicol.rs
@@ -10,7 +10,7 @@ use ServoArc;
use app_units::Au;
use block::BlockFlow;
use context::LayoutContext;
-use display_list_builder::DisplayListBuildState;
+use display_list_builder::{DisplayListBuildState, StackingContextCollectionState};
use euclid::{Point2D, Vector2D};
use floats::FloatKind;
use flow::{Flow, FlowClass, OpaqueFlow, mut_base, FragmentationContext};
@@ -190,7 +190,7 @@ impl Flow for MulticolFlow {
self.block_flow.build_display_list(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts(state);
}
@@ -280,7 +280,7 @@ impl Flow for MulticolColumnFlow {
self.block_flow.build_display_list(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts(state);
}
diff --git a/components/layout/sequential.rs b/components/layout/sequential.rs
index 6673ecc8e14..86a7d90142f 100644
--- a/components/layout/sequential.rs
+++ b/components/layout/sequential.rs
@@ -6,7 +6,7 @@
use app_units::Au;
use context::LayoutContext;
-use display_list_builder::DisplayListBuildState;
+use display_list_builder::{DisplayListBuildState, StackingContextCollectionState};
use euclid::{Point2D, Vector2D};
use floats::SpeculatedFloatPlacement;
use flow::{self, Flow, ImmutableFlowUtils, IS_ABSOLUTELY_POSITIONED};
@@ -69,9 +69,10 @@ pub fn reflow(root: &mut Flow, layout_context: &LayoutContext, relayout_mode: Re
pub fn build_display_list_for_subtree<'a>(flow_root: &mut Flow,
layout_context: &'a LayoutContext)
-> DisplayListBuildState<'a> {
- let mut state = DisplayListBuildState::new(layout_context);
+ let mut state = StackingContextCollectionState::new(layout_context.id);
flow_root.collect_stacking_contexts(&mut state);
+ let state = DisplayListBuildState::new(layout_context, state);
let mut build_display_list = BuildDisplayList {
state: state,
};
diff --git a/components/layout/table.rs b/components/layout/table.rs
index 8e7e63b4705..e373385e050 100644
--- a/components/layout/table.rs
+++ b/components/layout/table.rs
@@ -12,6 +12,7 @@ use block::{ISizeConstraintInput, ISizeConstraintSolution};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use display_list_builder::{DisplayListBuildState, EstablishContainingBlock};
+use display_list_builder::StackingContextCollectionState;
use euclid::Point2D;
use flow;
use flow::{BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ImmutableFlowUtils, OpaqueFlow};
@@ -503,7 +504,7 @@ impl Flow for TableFlow {
self.block_flow.build_display_list_for_block(state, border_painting_mode);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::Yes);
}
diff --git a/components/layout/table_caption.rs b/components/layout/table_caption.rs
index 39e20d95bbf..2ee55382f6c 100644
--- a/components/layout/table_caption.rs
+++ b/components/layout/table_caption.rs
@@ -10,7 +10,7 @@ use app_units::Au;
use block::BlockFlow;
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, DisplayListBuildState};
-use display_list_builder::EstablishContainingBlock;
+use display_list_builder::{EstablishContainingBlock, StackingContextCollectionState};
use euclid::Point2D;
use flow::{Flow, FlowClass, OpaqueFlow};
use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
@@ -80,7 +80,7 @@ impl Flow for TableCaptionFlow {
self.block_flow.build_display_list(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::No);
}
diff --git a/components/layout/table_cell.rs b/components/layout/table_cell.rs
index c696b3f58f4..42dfce82cff 100644
--- a/components/layout/table_cell.rs
+++ b/components/layout/table_cell.rs
@@ -11,6 +11,7 @@ use block::{BlockFlow, ISizeAndMarginsComputer, MarginsMayCollapseFlag};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use display_list_builder::{DisplayListBuildState, EstablishContainingBlock};
+use display_list_builder::StackingContextCollectionState;
use euclid::{Point2D, Rect, SideOffsets2D, Size2D};
use flow::{self, Flow, FlowClass, IS_ABSOLUTELY_POSITIONED, OpaqueFlow};
use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
@@ -261,7 +262,7 @@ impl Flow for TableCellFlow {
self.block_flow.build_display_list_for_block(state, border_painting_mode)
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::No);
}
diff --git a/components/layout/table_colgroup.rs b/components/layout/table_colgroup.rs
index 10a87903403..4d54afbe386 100644
--- a/components/layout/table_colgroup.rs
+++ b/components/layout/table_colgroup.rs
@@ -8,7 +8,7 @@
use app_units::Au;
use context::LayoutContext;
-use display_list_builder::DisplayListBuildState;
+use display_list_builder::{DisplayListBuildState, StackingContextCollectionState};
use euclid::Point2D;
use flow::{BaseFlow, Flow, FlowClass, ForceNonfloatedFlag, OpaqueFlow};
use fragment::{Fragment, FragmentBorderBoxIterator, Overflow, SpecificFragmentInfo};
@@ -92,7 +92,7 @@ impl Flow for TableColGroupFlow {
// Table columns are invisible.
fn build_display_list(&mut self, _: &mut DisplayListBuildState) { }
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.base.stacking_context_id = state.current_stacking_context_id;
self.base.clip_and_scroll_info = Some(state.current_clip_and_scroll_info);
}
diff --git a/components/layout/table_row.rs b/components/layout/table_row.rs
index 376229e0db2..17728a5ae0b 100644
--- a/components/layout/table_row.rs
+++ b/components/layout/table_row.rs
@@ -11,6 +11,7 @@ use block::{BlockFlow, ISizeAndMarginsComputer};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use display_list_builder::{DisplayListBuildState, EstablishContainingBlock};
+use display_list_builder::StackingContextCollectionState;
use euclid::Point2D;
use flow::{self, EarlyAbsolutePositionInfo, Flow, FlowClass, ImmutableFlowUtils, OpaqueFlow};
use flow_list::MutFlowListIterator;
@@ -478,7 +479,7 @@ impl Flow for TableRowFlow {
self.block_flow.build_display_list_for_block(state, border_painting_mode);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::No);
}
diff --git a/components/layout/table_rowgroup.rs b/components/layout/table_rowgroup.rs
index 413a3f978b3..aabc56b8e54 100644
--- a/components/layout/table_rowgroup.rs
+++ b/components/layout/table_rowgroup.rs
@@ -10,7 +10,7 @@ use app_units::Au;
use block::{BlockFlow, ISizeAndMarginsComputer};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, DisplayListBuildState};
-use display_list_builder::EstablishContainingBlock;
+use display_list_builder::{EstablishContainingBlock, StackingContextCollectionState};
use euclid::Point2D;
use flow::{Flow, FlowClass, OpaqueFlow};
use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
@@ -183,7 +183,7 @@ impl Flow for TableRowGroupFlow {
self.block_flow.build_display_list(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::No);
}
diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs
index 1b7db760a09..1d9c2f6566e 100644
--- a/components/layout/table_wrapper.rs
+++ b/components/layout/table_wrapper.rs
@@ -18,7 +18,7 @@ use block::{AbsoluteNonReplaced, BlockFlow, FloatNonReplaced, ISizeAndMarginsCom
use block::{ISizeConstraintSolution, MarginsMayCollapseFlag};
use context::LayoutContext;
use display_list_builder::{BlockFlowDisplayListBuilding, DisplayListBuildState};
-use display_list_builder::EstablishContainingBlock;
+use display_list_builder::{EstablishContainingBlock, StackingContextCollectionState};
use euclid::Point2D;
use floats::FloatKind;
use flow::{Flow, FlowClass, ImmutableFlowUtils, INLINE_POSITION_IS_STATIC, OpaqueFlow};
@@ -457,7 +457,7 @@ impl Flow for TableWrapperFlow {
self.block_flow.build_display_list(state);
}
- fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
+ fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
self.block_flow.collect_stacking_contexts_for_block(state, EstablishContainingBlock::No);
}
diff --git a/components/layout/webrender_helpers.rs b/components/layout/webrender_helpers.rs
index 3a67aeedecd..01ac993133c 100644
--- a/components/layout/webrender_helpers.rs
+++ b/components/layout/webrender_helpers.rs
@@ -9,8 +9,8 @@
use app_units::Au;
use euclid::{Point2D, Vector2D, Rect, SideOffsets2D, Size2D};
-use gfx::display_list::{BorderDetails, BorderRadii, BoxShadowClipMode, ClippingRegion};
-use gfx::display_list::{DisplayItem, DisplayList, DisplayListTraversal, ScrollRootType};
+use gfx::display_list::{BorderDetails, BorderRadii, BoxShadowClipMode, ClipScrollNodeType};
+use gfx::display_list::{ClippingRegion, DisplayItem, DisplayList, DisplayListTraversal};
use gfx::display_list::StackingContextType;
use msg::constellation_msg::PipelineId;
use style::computed_values::{image_rendering, mix_blend_mode, transform_style};
@@ -491,27 +491,27 @@ impl WebRenderDisplayItemConverter for DisplayItem {
stacking_context.filters.to_filter_ops());
}
DisplayItem::PopStackingContext(_) => builder.pop_stacking_context(),
- DisplayItem::DefineClip(ref item) => {
- builder.push_clip_id(item.scroll_root.parent_id);
+ DisplayItem::DefineClipScrollNode(ref item) => {
+ builder.push_clip_id(item.node.parent_id);
- let our_id = item.scroll_root.id;
- let item_rect = item.scroll_root.clip.main.to_rectf();
- let webrender_id = match item.scroll_root.root_type {
- ScrollRootType::Clip => {
+ let our_id = item.node.id;
+ let item_rect = item.node.clip.main.to_rectf();
+ let webrender_id = match item.node.node_type {
+ ClipScrollNodeType::Clip => {
builder.define_clip(Some(our_id),
item_rect,
- item.scroll_root.clip.get_complex_clips(),
+ item.node.clip.get_complex_clips(),
None)
}
- ScrollRootType::ScrollFrame(scroll_sensitivity) => {
+ ClipScrollNodeType::ScrollFrame(scroll_sensitivity) => {
builder.define_scroll_frame(Some(our_id),
- item.scroll_root.content_rect.to_rectf(),
- item.scroll_root.clip.main.to_rectf(),
- item.scroll_root.clip.get_complex_clips(),
+ item.node.content_rect.to_rectf(),
+ item.node.clip.main.to_rectf(),
+ item.node.clip.get_complex_clips(),
None,
scroll_sensitivity)
}
- ScrollRootType::StickyFrame(sticky_frame_info) => {
+ ClipScrollNodeType::StickyFrame(sticky_frame_info) => {
builder.define_sticky_frame(Some(our_id), item_rect, sticky_frame_info)
}
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-01 20:59:23 +0000