Add ScrollTree builder and unit test

cc/trees/property_tree_builder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 13 matching lines @@
 namespace {
 
 static const int kInvalidPropertyTreeNodeId = -1;
 static const int kRootPropertyTreeNodeId = 0;
 
 template <typename LayerType>
 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;
   const LayerType* overscroll_elasticity_layer;
   gfx::Vector2dF elastic_overscroll;
   float page_scale_factor;
   bool in_subtree_of_page_scale_layer;
   bool affected_by_inner_viewport_bounds_delta;
   bool affected_by_outer_viewport_bounds_delta;
   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;
   bool axis_align_since_render_target;
   int sequence_number;
 };
 
 template <typename LayerType>
 struct DataForRecursionFromChild {
   int num_copy_requests_in_subtree;
@@ skipping 21 matching lines @@
                                : layer->clip_parent()->clip_tree_index();
   return data.clip_tree->Node(id);
 }
 
 template <typename LayerType>
 static bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_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,
                          bool created_transform_node,
                          DataForRecursion<LayerType>* data_for_children) {
   ClipNode* parent = GetClipParent(data_from_ancestor, layer);
   int parent_id = parent->id;
 
   bool is_root = !layer->parent();
 
@@ skipping 511 matching lines @@
   layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
   if (should_create_render_surface) {
     data_for_children->compound_transform_since_render_target =
         gfx::Transform();
     data_for_children->axis_align_since_render_target = true;
   }
   return should_create_render_surface;
 }
 
 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,
     DataForRecursionFromChild<LayerType>* data_to_parent) {
   layer->set_property_tree_sequence_number(data_from_parent.sequence_number);
   if (layer->mask_layer())
     layer->mask_layer()->set_property_tree_sequence_number(
         data_from_parent.sequence_number);
 
   DataForRecursion<LayerType> data_for_children(data_from_parent);
 
   bool created_render_surface =
       AddEffectNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
   if (created_render_surface) {
     data_for_children.render_target = data_for_children.effect_tree_parent;
     layer->set_draw_blend_mode(SkXfermode::kSrcOver_Mode);
   } else {
     layer->set_draw_blend_mode(layer->blend_mode());
   }
 
   bool created_transform_node = AddTransformNodeIfNeeded(
       data_from_parent, layer, created_render_surface, &data_for_children);
   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);
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->child_at(i)->scroll_parent()) {
       DataForRecursionFromChild<LayerType> data_from_child;
       BuildPropertyTreesInternal(layer->child_at(i), data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
@@ skipping 61 matching lines @@
                                                       root_layer->position());
     return;
   }
 
   property_trees->sequence_number++;
 
   DataForRecursion<LayerType> data_for_recursion;
   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;
   data_for_recursion.overscroll_elasticity_layer = overscroll_elasticity_layer;
   data_for_recursion.elastic_overscroll = elastic_overscroll;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_layer = false;
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
   data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
   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;
   data_for_recursion.transform_tree->set_device_scale_factor(
       device_scale_factor);
 
   ClipNode root_clip;
   root_clip.data.resets_clip = true;
   root_clip.data.applies_local_clip = true;
   root_clip.data.clip = gfx::RectF(viewport);
   root_clip.data.transform_id = kRootPropertyTreeNodeId;
   data_for_recursion.clip_tree_parent =
       data_for_recursion.clip_tree->Insert(root_clip, kRootPropertyTreeNodeId);
 
   DataForRecursionFromChild<LayerType> data_from_child;
   BuildPropertyTreesInternal(root_layer, data_for_recursion, &data_from_child);
   property_trees->needs_rebuild = false;
 
   // The transform tree is kept up-to-date as it is built, but the
   // combined_clips stored in the clip tree aren't computed during tree
   // building.
   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(
     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
@@ skipping 21 matching lines @@
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
 }
 
 }  // namespace cc