Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #18462 - mrobinson:cleanup-building-state, r=emilio

Browse source 
Do some minor cleanups in display list building

<!-- Please describe your changes on the following line: -->

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [ ] These changes fix #__ (github issue number if applicable).

<!-- Either: -->
- [ ] There are tests for these changes OR
- [x] These changes do not require tests because they should not change behavior.

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- 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/18462)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2017-09-15 05:30:47 -05:00 • committed by GitHub
commit b2df99cb65
17 changed files with 258 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

52
components/gfx/display_list/mod.rs
View file

@ -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

5
components/layout/block.rs
View file

@ -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);
}

319
components/layout/display_list_builder.rs
View file

@ -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);

3
components/layout/flex.rs
View file

@ -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);
}

7
components/layout/flow.rs
View file

@ -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);
}

3
components/layout/inline.rs
View file

@ -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);
}

3
components/layout/list_item.rs
View file

@ -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);
}

6
components/layout/multicol.rs
View file

@ -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);
}

5
components/layout/sequential.rs
View file

@ -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,
};

3
components/layout/table.rs
View file

@ -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);
}

4
components/layout/table_caption.rs
View file

@ -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);
}

3
components/layout/table_cell.rs
View file

@ -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);
}

4
components/layout/table_colgroup.rs
View file

@ -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);
}

3
components/layout/table_row.rs
View file

@ -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);
}

4
components/layout/table_rowgroup.rs
View file

@ -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);
}

4
components/layout/table_wrapper.rs
View file

@ -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);
}

28
components/layout/webrender_helpers.rs
View file

@ -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)
}
};