Add ScrollTree builder and unit test

cc/trees/property_tree_builder.cc

Index: cc/trees/property_tree_builder.cc
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index a27bd3c8bf6e0d2575138592243cdb29d565bcf1..da51fbe0e8382900f4b29a879e04600b56a5246d 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc
@@ -31,11 +31,13 @@ struct DataForRecursion {
   TransformTree* transform_tree;
   ClipTree* clip_tree;
   EffectTree* effect_tree;
+  ScrollTree* scroll_tree;
   LayerType* transform_tree_parent;
   LayerType* transform_fixed_parent;
   int render_target;
   int clip_tree_parent;
   int effect_tree_parent;
+  int scroll_tree_parent;
   const LayerType* page_scale_layer;
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
@@ -48,6 +50,8 @@ struct DataForRecursion {
   bool should_flatten;
   bool target_is_clipped;
   bool is_hidden;
+  bool scroll_other_criteria;
+  ScrollBlocksOn accumulated_scroll_blocks_on;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_compensation_adjustment;
   gfx::Transform compound_transform_since_render_target;
@@ -89,6 +93,15 @@ static bool LayerClipsSubtree(LayerType* layer) {
 }
 
 template <typename LayerType>
+static int GetScrollParentId(const DataForRecursion<LayerType>& data,
+                             LayerType* layer) {
+  const bool inherits_scroll = !layer->parent() || !layer->scroll_parent();

[jaydasika, 2016/01/22 22:28:28]

Why do we need !layer->parent() here ? (The only case I think this is handling
is, root is its own scroll parent, is that ever possible ?)

[sunxd, 2016/01/25 15:37:21]

I made this identical to GetClipParentId, is it the same story in that part?

+  const int id = inherits_scroll ? data.scroll_tree_parent
+                                 : layer->scroll_parent()->scroll_tree_index();
+  return id;
+}
+
+template <typename LayerType>
 void AddClipNodeIfNeeded(const DataForRecursion<LayerType>& data_from_ancestor,
                          LayerType* layer,
                          bool created_render_surface,
@@ -620,6 +633,53 @@ bool AddEffectNodeIfNeeded(
 }
 
 template <typename LayerType>
+void AddScrollNodeIfNeeded(
+    const DataForRecursion<LayerType>& data_from_ancestor,
+    LayerType* layer,
+    DataForRecursion<LayerType>* data_for_children) {
+  int parent_id = GetScrollParentId(data_from_ancestor, layer);
+
+  bool is_root = !layer->parent();
+  bool scrollable = layer->scrollable();
+  ScrollBlocksOn scroll_blocks_on = layer->scroll_blocks_on();
+  ScrollBlocksOn accumulated_scroll_blocks_on =
+      data_from_ancestor.accumulated_scroll_blocks_on;
+  bool contains_non_fast_scrollable_region =
+      !layer->non_fast_scrollable_region().IsEmpty();
+  bool should_scroll_on_main_thread = layer->should_scroll_on_main_thread();
+
+  bool other_criteria = is_root || scrollable ||
+                        (scroll_blocks_on | accumulated_scroll_blocks_on) !=
+                            accumulated_scroll_blocks_on ||
+                        contains_non_fast_scrollable_region;
+  bool requires_node =
+      other_criteria || (should_scroll_on_main_thread &&
+                         data_from_ancestor.scroll_other_criteria);

[ajuma, 2016/01/25 15:19:54]

What's the intuition behind passing scroll_other_criteria to children and using
it this way to determine if a node is needed? (Would it help to use a more
descriptive name for it?)

[sunxd, 2016/01/25 15:37:21]

The idea is that we do not create scroll nodes for:

A layer that only should_scroll_on_main_thread, and the scroll_tree_parent is
created only because of should_scroll_on_main_thread.

The precise name would be scroll_node_uninheritable_criteria? And the name in
DataForRecursion can be scroll_tree_parent_created_by_uninheritable_criteria?

[ajuma, 2016/01/25 16:21:59]

Thanks, those names sound clearer. Please also add a comment about this.

+
+  if (!requires_node) {
+    data_for_children->scroll_tree_parent = parent_id;
+  } else {
+    ScrollNode node;
+    node.owner_id = layer->id();
+    node.data.scrollable = scrollable;
+    node.data.should_scroll_on_main_thread = should_scroll_on_main_thread;
+    node.data.scroll_blocks_on =
+        scroll_blocks_on | accumulated_scroll_blocks_on;
+    node.data.contains_non_fast_scrollable_region =
+        contains_non_fast_scrollable_region;
+    node.data.transform_id =
+        data_for_children->transform_tree_parent->transform_tree_index();
+    data_for_children->scroll_tree_parent =
+        data_for_children->scroll_tree->Insert(node, parent_id);
+    data_for_children->scroll_other_criteria = other_criteria;
+    data_for_children->accumulated_scroll_blocks_on =
+        node.data.scroll_blocks_on;
+  }
+
+  layer->SetScrollTreeIndex(data_for_children->scroll_tree_parent);
+}
+
+template <typename LayerType>
 void BuildPropertyTreesInternal(
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent,
@@ -646,6 +706,8 @@ void BuildPropertyTreesInternal(
   AddClipNodeIfNeeded(data_from_parent, layer, created_render_surface,
                       created_transform_node, &data_for_children);
 
+  AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
+
   data_for_children.is_hidden =
       layer->hide_layer_and_subtree() || data_from_parent.is_hidden;
   layer->set_is_hidden_from_property_trees(data_for_children.is_hidden);
@@ -727,11 +789,13 @@ void BuildPropertyTreesTopLevelInternal(
   data_for_recursion.transform_tree = &property_trees->transform_tree;
   data_for_recursion.clip_tree = &property_trees->clip_tree;
   data_for_recursion.effect_tree = &property_trees->effect_tree;
+  data_for_recursion.scroll_tree = &property_trees->scroll_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = kRootPropertyTreeNodeId;
   data_for_recursion.clip_tree_parent = kRootPropertyTreeNodeId;
   data_for_recursion.effect_tree_parent = kInvalidPropertyTreeNodeId;
+  data_for_recursion.scroll_tree_parent = kRootPropertyTreeNodeId;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
   data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
@@ -744,11 +808,14 @@ void BuildPropertyTreesTopLevelInternal(
   data_for_recursion.should_flatten = false;
   data_for_recursion.target_is_clipped = false;
   data_for_recursion.is_hidden = false;
+  data_for_recursion.scroll_other_criteria = true;
+  data_for_recursion.accumulated_scroll_blocks_on = SCROLL_BLOCKS_ON_NONE;
   data_for_recursion.device_transform = &device_transform;
 
   data_for_recursion.transform_tree->clear();
   data_for_recursion.clip_tree->clear();
   data_for_recursion.effect_tree->clear();
+  data_for_recursion.scroll_tree->clear();
   data_for_recursion.compound_transform_since_render_target = gfx::Transform();
   data_for_recursion.axis_align_since_render_target = true;
   data_for_recursion.sequence_number = property_trees->sequence_number;
@@ -773,6 +840,7 @@ void BuildPropertyTreesTopLevelInternal(
   property_trees->transform_tree.set_needs_update(false);
   property_trees->clip_tree.set_needs_update(true);
   property_trees->effect_tree.set_needs_update(false);
+  property_trees->scroll_tree.set_needs_update(false);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(