diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs index 99a99a47b813..4e0aae447967 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 { + fn full_offset_for_clip_scroll_node(&mut self, id: &ClipId) -> Vector2D { 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, - /// 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), PushStackingContext(Box), PopStackingContext(Box), - DefineClip(Box), + DefineClipScrollNode(Box), } /// 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 790003abc3af..0c316ccea031 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -1680,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, _) | diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs index cbd76a580c8d..9a63b9111ef5 100644 --- a/components/layout/display_list_builder.rs +++ b/components/layout/display_list_builder.rs @@ -18,19 +18,19 @@ use euclid::{Point2D, Rect, SideOffsets2D, Size2D, Transform3D, TypedSize2D}; use euclid::Vector2D; use flex::FlexFlow; use flow::{BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED}; -use fnv::FnvHashMap; 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; @@ -143,14 +143,14 @@ fn get_cyclic(arr: &[T], index: usize) -> &T { #[derive(Debug)] struct StackingContextInfo { children: Vec, - scroll_roots: Vec, + clip_scroll_nodes: Vec, } impl StackingContextInfo { fn new() -> StackingContextInfo { StackingContextInfo { children: Vec::new(), - scroll_roots: Vec::new(), + clip_scroll_nodes: Vec::new(), } } @@ -166,11 +166,11 @@ pub struct StackingContextCollectionState { /// The root of the StackingContext tree. pub root_stacking_context: StackingContext, - /// StackingContext and ScrollRoot children for each StackingContext. + /// StackingContext and ClipScrollNode children for each StackingContext. stacking_context_info: FnvHashMap, - /// A map establishing the parent child relationship of every ScrollRoot. - pub scroll_root_parents: FnvHashMap, + /// A map establishing the parent child relationship of every ClipScrollNode. + pub clip_scroll_node_parents: FnvHashMap, /// The current stacking context id, used to keep track of state when building. /// recursively building and processing the display list. @@ -207,7 +207,7 @@ impl StackingContextCollectionState { pipeline_id: pipeline_id, root_stacking_context: StackingContext::root(pipeline_id), stacking_context_info: FnvHashMap::default(), - scroll_root_parents: 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, @@ -227,20 +227,20 @@ impl StackingContextCollectionState { 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) { + 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); } } @@ -251,18 +251,18 @@ pub struct DisplayListBuildState<'a> { /// The root of the StackingContext tree. pub root_stacking_context: StackingContext, - /// StackingContext and ScrollRoot children for each StackingContext. + /// StackingContext and ClipScrollNode children for each StackingContext. stacking_context_info: FnvHashMap, - /// A map establishing the parent child relationship of every ScrollRoot. - pub scroll_root_parents: FnvHashMap, + /// A map establishing the parent child relationship of every ClipScrollNode. + pub clip_scroll_node_parents: FnvHashMap, /// The items in this display list. pub items: FnvHashMap>, - /// Whether or not we are processing an element that establishes a scroll root, used - /// to determine what ScrollRoot to place backgrounds and borders into. - pub processing_scroll_root_element: bool, + /// 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. @@ -287,8 +287,8 @@ impl<'a> DisplayListBuildState<'a> { root_stacking_context: state.root_stacking_context, items: FnvHashMap::default(), stacking_context_info: state.stacking_context_info, - scroll_root_parents: state.scroll_root_parents, - processing_scroll_root_element: false, + 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(), @@ -300,19 +300,19 @@ impl<'a> DisplayListBuildState<'a> { items.push(display_item); } - fn parent_scroll_root_id(&self, scroll_root_id: ClipId) -> ClipId { - if scroll_root_id.is_root_scroll_node() { - return scroll_root_id; + 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, @@ -322,8 +322,8 @@ impl<'a> DisplayListBuildState<'a> { cursor: Option, 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 }; @@ -365,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); } @@ -2330,16 +2330,16 @@ pub trait BlockFlowDisplayListBuilding { stacking_context_type: BlockStackingContextType, can_establish_containing_block: EstablishContainingBlock) -> ClipAndScrollInfo; - fn setup_scroll_root_for_position(&mut self, - state: &mut StackingContextCollectionState, - border_box: &Rect); - fn setup_scroll_root_for_overflow(&mut self, - state: &mut StackingContextCollectionState, - border_box: &Rect); - fn setup_scroll_root_for_css_clip(&mut self, - state: &mut StackingContextCollectionState, - preserved_state: &mut SavedStackingContextCollectionState, - stacking_relative_border_box: &Rect); + fn setup_clip_scroll_node_for_position(&mut self, + state: &mut StackingContextCollectionState, + border_box: &Rect); + fn setup_clip_scroll_node_for_overflow(&mut self, + state: &mut StackingContextCollectionState, + border_box: &Rect); + fn setup_clip_scroll_node_for_css_clip(&mut self, + state: &mut StackingContextCollectionState, + preserved_state: &mut SavedStackingContextCollectionState, + stacking_relative_border_box: &Rect); fn create_pseudo_stacking_context_for_block(&mut self, parent_stacking_context_id: StackingContextId, parent_clip_and_scroll_info: ClipAndScrollInfo, @@ -2566,9 +2566,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 @@ -2592,7 +2592,7 @@ impl BlockFlowDisplayListBuilding for BlockFlow { containing_clip_and_scroll_info } - fn setup_scroll_root_for_position(&mut self, + fn setup_clip_scroll_node_for_position(&mut self, state: &mut StackingContextCollectionState, border_box: &Rect) { if self.positioning() != position::T::sticky { @@ -2640,28 +2640,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.pipeline_id.to_webrender()); + 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_scroll_root( - ScrollRoot { - id: new_scroll_root_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 StackingContextCollectionState, - border_box: &Rect) { - if !self.overflow_style_may_require_scroll_root() { + fn setup_clip_scroll_node_for_overflow(&mut self, + state: &mut StackingContextCollectionState, + border_box: &Rect) { + if !self.overflow_style_may_require_clip_scroll_node() { return; } @@ -2681,9 +2681,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.pipeline_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; } @@ -2705,27 +2705,27 @@ impl BlockFlowDisplayListBuilding for BlockFlow { let content_size = Size2D::new(content_size.x, content_size.y); let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id; - state.add_scroll_root( - ScrollRoot { - id: new_scroll_root_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 StackingContextCollectionState, - preserved_state: &mut SavedStackingContextCollectionState, - stacking_relative_border_box: &Rect) { + fn setup_clip_scroll_node_for_css_clip(&mut self, + state: &mut StackingContextCollectionState, + preserved_state: &mut SavedStackingContextCollectionState, + stacking_relative_border_box: &Rect) { // 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, @@ -2750,14 +2750,14 @@ 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.pipeline_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; } @@ -2765,17 +2765,18 @@ impl BlockFlowDisplayListBuilding for BlockFlow { preserved_state.push_clip(state, &clip_rect, self.positioning()); let parent_id = self.clip_and_scroll_info(state.pipeline_id).scroll_node_id; - state.add_scroll_root( - ScrollRoot { - id: new_scroll_root_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; } @@ -2850,7 +2851,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 @@ -2868,7 +2869,7 @@ 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; } } diff --git a/components/layout/webrender_helpers.rs b/components/layout/webrender_helpers.rs index 59aa20d95790..de251d7d9381 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}; @@ -488,27 +488,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) } };