Rename ScrollRoot to ClipScrollNode

ScrollRoot is an ever increasingly inaccurate name for this thing and
WebRender consistently uses ClipScrollNode nowadays. Stick with the
WebRender terminology to be consistent.

4 files changed, 128 insertions, 127 deletions

diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs
index 99a99a47b81..4e0aae44796 100644
--- a/components/gfx/display_list/mod.rs
+++ b/components/gfx/display_list/mod.rs
@@ -77,7 +77,7 @@ impl<'a> ScrollOffsetLookup<'a> {
             None => return None,
         };
 
-        let scroll_offset = self.full_offset_for_scroll_root(&clip_id);
+        let scroll_offset = self.full_offset_for_clip_scroll_node(&clip_id);
         *point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
                               point.y - Au::from_f32_px(scroll_offset.y));
         let frac_point = inv_transform.transform_point2d(&Point2D::new(point.x.to_f32_px(),
@@ -93,18 +93,18 @@ impl<'a> ScrollOffsetLookup<'a> {
         Some(sublookup)
     }
 
-    fn add_scroll_root(&mut self, scroll_root: &ScrollRoot) {
-        self.parents.insert(scroll_root.id, scroll_root.parent_id);
+    fn add_clip_scroll_node(&mut self, clip_scroll_node: &ClipScrollNode) {
+        self.parents.insert(clip_scroll_node.id, clip_scroll_node.parent_id);
     }
 
-    fn full_offset_for_scroll_root(&mut self, id: &ClipId) -> Vector2D<f32> {
+    fn full_offset_for_clip_scroll_node(&mut self, id: &ClipId) -> Vector2D<f32> {
         if let Some(offset) = self.calculated_total_offsets.get(id) {
             return *offset;
         }
 
         let parent_offset = if !id.is_root_scroll_node() {
             let parent_id = *self.parents.get(id).unwrap();
-            self.full_offset_for_scroll_root(&parent_id)
+            self.full_offset_for_clip_scroll_node(&parent_id)
         } else {
             Vector2D::zero()
         };
@@ -160,8 +160,8 @@ impl DisplayList {
                                                      offset_lookup,
                                                      result);
                 }
-                &DisplayItem::DefineClip(ref item) => {
-                    offset_lookup.add_scroll_root(&item.scroll_root);
+                &DisplayItem::DefineClipScrollNode(ref item) => {
+                    offset_lookup.add_clip_scroll_node(&item.node);
                 }
                 &DisplayItem::PopStackingContext(_) => return,
                 &DisplayItem::Text(ref text) => {
@@ -237,8 +237,8 @@ impl DisplayList {
                                                    result);
                 }
                 &DisplayItem::PopStackingContext(_) => return,
-                &DisplayItem::DefineClip(ref item) => {
-                    offset_lookup.add_scroll_root(&item.scroll_root);
+                &DisplayItem::DefineClipScrollNode(ref item) => {
+                    offset_lookup.add_clip_scroll_node(&item.node);
                 }
                 _ => {
                     if let Some(meta) = item.hit_test(*point, offset_lookup) {
@@ -558,20 +558,20 @@ impl fmt::Debug for StackingContext {
 }
 
 #[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
-pub enum ScrollRootType {
+pub enum ClipScrollNodeType {
     ScrollFrame(ScrollSensitivity),
     StickyFrame(StickyFrameInfo),
     Clip,
 }
 
-/// Defines a stacking context.
+/// Defines a clip scroll node.
 #[derive(Clone, Debug, Deserialize, HeapSizeOf, Serialize)]
-pub struct ScrollRoot {
+pub struct ClipScrollNode {
     /// The WebRender clip id of this scroll root based on the source of this clip
     /// and information about the fragment.
     pub id: ClipId,
 
-    /// The unique ID of the parent of this ScrollRoot.
+    /// The unique ID of the parent of this ClipScrollNode.
     pub parent_id: ClipId,
 
     /// The position of this scroll root's frame in the parent stacking context.
@@ -580,15 +580,15 @@ pub struct ScrollRoot {
     /// The rect of the contents that can be scrolled inside of the scroll root.
     pub content_rect: Rect<Au>,
 
-    /// The type of this ScrollRoot.
-    pub root_type: ScrollRootType
+    /// The type of this ClipScrollNode.
+    pub node_type: ClipScrollNodeType,
 }
 
-impl ScrollRoot {
+impl ClipScrollNode {
     pub fn to_define_item(&self, pipeline_id: PipelineId) -> DisplayItem {
-        DisplayItem::DefineClip(box DefineClipItem {
+        DisplayItem::DefineClipScrollNode(box DefineClipScrollNodeItem {
             base: BaseDisplayItem::empty(pipeline_id),
-            scroll_root: self.clone(),
+            node: self.clone(),
         })
     }
 }
@@ -610,7 +610,7 @@ pub enum DisplayItem {
     Iframe(Box<IframeDisplayItem>),
     PushStackingContext(Box<PushStackingContextItem>),
     PopStackingContext(Box<PopStackingContextItem>),
-    DefineClip(Box<DefineClipItem>),
+    DefineClipScrollNode(Box<DefineClipScrollNodeItem>),
 }
 
 /// Information common to all display items.
@@ -1215,12 +1215,12 @@ pub struct PopStackingContextItem {
 
 /// Starts a group of items inside a particular scroll root.
 #[derive(Clone, Deserialize, HeapSizeOf, Serialize)]
-pub struct DefineClipItem {
+pub struct DefineClipScrollNodeItem {
     /// Fields common to all display items.
     pub base: BaseDisplayItem,
 
     /// The scroll root that this item starts.
-    pub scroll_root: ScrollRoot,
+    pub node: ClipScrollNode,
 }
 
 /// How a box shadow should be clipped.
@@ -1252,7 +1252,7 @@ impl DisplayItem {
             DisplayItem::Iframe(ref iframe) => &iframe.base,
             DisplayItem::PushStackingContext(ref stacking_context) => &stacking_context.base,
             DisplayItem::PopStackingContext(ref item) => &item.base,
-            DisplayItem::DefineClip(ref item) => &item.base,
+            DisplayItem::DefineClipScrollNode(ref item) => &item.base,
         }
     }
 
@@ -1292,7 +1292,7 @@ impl DisplayItem {
         // test elements with `border-radius`, for example.
         let base_item = self.base();
 
-        let scroll_offset = offset_lookup.full_offset_for_scroll_root(&self.scroll_node_id());
+        let scroll_offset = offset_lookup.full_offset_for_clip_scroll_node(&self.scroll_node_id());
         let point = Point2D::new(point.x - Au::from_f32_px(scroll_offset.x),
                                  point.y - Au::from_f32_px(scroll_offset.y));
 
@@ -1349,8 +1349,8 @@ impl fmt::Debug for DisplayItem {
             return write!(f, "PopStackingContext({:?}", item.stacking_context_id);
         }
 
-        if let DisplayItem::DefineClip(ref item) = *self {
-            return write!(f, "DefineClip({:?}", item.scroll_root);
+        if let DisplayItem::DefineClipScrollNode(ref item) = *self {
+            return write!(f, "DefineClipScrollNode({:?}", item.node);
         }
 
         write!(f, "{} @ {:?} {:?}",
@@ -1377,7 +1377,7 @@ impl fmt::Debug for DisplayItem {
                 DisplayItem::Iframe(_) => "Iframe".to_owned(),
                 DisplayItem::PushStackingContext(_) |
                 DisplayItem::PopStackingContext(_) |
-                DisplayItem::DefineClip(_) => "".to_owned(),
+                DisplayItem::DefineClipScrollNode(_) => "".to_owned(),
             },
             self.bounds(),
             self.base().local_clip
diff --git a/components/layout/block.rs b/components/layout/block.rs
index 790003abc3a..0c316ccea03 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 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;
     }
 
 }
diff --git a/components/layout/webrender_helpers.rs b/components/layout/webrender_helpers.rs
index 59aa20d9579..de251d7d938 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)
                     }
                 };