diff options
Diffstat (limited to 'components/layout/display_list_builder.rs')
| -rw-r--r-- | components/layout/display_list_builder.rs | 173 |
1 files changed, 87 insertions, 86 deletions
diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs index cbd76a580c8..9a63b9111ef 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<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(), } } @@ -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<StackingContextId, StackingContextInfo>, - /// A map establishing the parent child relationship of every ScrollRoot. - pub scroll_root_parents: FnvHashMap<ClipId, ClipId>, + /// 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. @@ -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<StackingContextId, StackingContextInfo>, - /// A map establishing the parent child relationship of every ScrollRoot. - pub scroll_root_parents: FnvHashMap<ClipId, ClipId>, + /// 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 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<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 }; @@ -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<Au>); - fn setup_scroll_root_for_overflow(&mut self, - state: &mut StackingContextCollectionState, - border_box: &Rect<Au>); - fn setup_scroll_root_for_css_clip(&mut self, - state: &mut StackingContextCollectionState, - preserved_state: &mut SavedStackingContextCollectionState, - 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, @@ -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<Au>) { 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<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; } @@ -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<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, @@ -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; } } |