Add ScrollTree builder and unit test

Remove ScrollBlocksOn from ScrollTree:
It will be moved from the code base soon, will work
to integrate the "passive event handler" if that
depends on layer tree hierarchy.

BUG=568830
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1626513003

Cr-Commit-Position: refs/heads/master@{#371914}

11 files changed, 260 insertions, 14 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index b3dca99..e0ab0d8 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -64,6 +64,7 @@ Layer::Layer(const LayerSettings& settings)
       transform_tree_index_(-1),
       effect_tree_index_(-1),
       clip_tree_index_(-1),
+      scroll_tree_index_(-1),
       property_tree_sequence_number_(-1),
       element_id_(0),
       mutable_properties_(MutableProperty::kNone),
@@ -1088,6 +1089,23 @@ int Layer::effect_tree_index() const {
   return effect_tree_index_;
 }
 
+void Layer::SetScrollTreeIndex(int index) {
+  DCHECK(IsPropertyChangeAllowed());
+  if (scroll_tree_index_ == index)
+    return;
+  scroll_tree_index_ = index;
+  SetNeedsPushProperties();
+}
+
+int Layer::scroll_tree_index() const {
+  if (!layer_tree_host_ ||
+      layer_tree_host_->property_trees()->sequence_number !=
+          property_tree_sequence_number_) {
+    return -1;
+  }
+  return scroll_tree_index_;
+}
+
 void Layer::InvalidatePropertyTreesIndices() {
   int invalid_property_tree_index = -1;
   SetTransformTreeIndex(invalid_property_tree_index);
@@ -1201,6 +1219,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetTransformTreeIndex(transform_tree_index());
   layer->SetEffectTreeIndex(effect_tree_index());
   layer->SetClipTreeIndex(clip_tree_index());
+  layer->SetScrollTreeIndex(scroll_tree_index());
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawsContent(DrawsContent());
@@ -1471,6 +1490,7 @@ void Layer::LayerSpecificPropertiesToProto(proto::LayerProperties* proto) {
   base->set_transform_free_index(transform_tree_index_);
   base->set_effect_tree_index(effect_tree_index_);
   base->set_clip_tree_index(clip_tree_index_);
+  base->set_scroll_tree_index(scroll_tree_index_);
   Vector2dFToProto(offset_to_transform_parent_,
                    base->mutable_offset_to_transform_parent());
   base->set_double_sided(double_sided_);
@@ -1561,6 +1581,7 @@ void Layer::FromLayerSpecificPropertiesProto(
   transform_tree_index_ = base.transform_free_index();
   effect_tree_index_ = base.effect_tree_index();
   clip_tree_index_ = base.clip_tree_index();
+  scroll_tree_index_ = base.scroll_tree_index();
   offset_to_transform_parent_ =
       ProtoToVector2dF(base.offset_to_transform_parent());
   double_sided_ = base.double_sided();
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 1ddb5e8..afc6dc3 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -483,6 +483,9 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void SetEffectTreeIndex(int index);
   int effect_tree_index() const;
 
+  void SetScrollTreeIndex(int index);
+  int scroll_tree_index() const;
+
   void set_offset_to_transform_parent(gfx::Vector2dF offset) {
     if (offset_to_transform_parent_ == offset)
       return;
@@ -716,6 +719,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   int transform_tree_index_;
   int effect_tree_index_;
   int clip_tree_index_;
+  int scroll_tree_index_;
   int property_tree_sequence_number_;
   uint64_t element_id_;
   uint32_t mutable_properties_;
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index f585bde..6f3b56be 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -88,6 +88,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
       transform_tree_index_(-1),
       effect_tree_index_(-1),
       clip_tree_index_(-1),
+      scroll_tree_index_(-1),
       draw_depth_(0.f),
       needs_push_properties_(false),
       num_dependents_need_push_properties_(0),
@@ -277,6 +278,11 @@ void LayerImpl::SetEffectTreeIndex(int index) {
   SetNeedsPushProperties();
 }
 
+void LayerImpl::SetScrollTreeIndex(int index) {
+  scroll_tree_index_ = index;
+  SetNeedsPushProperties();
+}
+
 void LayerImpl::PassCopyRequests(
     std::vector<scoped_ptr<CopyOutputRequest>>* requests) {
   // In the case that a layer still has a copy request, this means that there's
@@ -657,6 +663,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetTransformTreeIndex(transform_tree_index_);
   layer->SetClipTreeIndex(clip_tree_index_);
   layer->SetEffectTreeIndex(effect_tree_index_);
+  layer->SetScrollTreeIndex(scroll_tree_index_);
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
 
   LayerImpl* scroll_parent = nullptr;
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index e3d0c87..43a424f 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -170,6 +170,9 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   void SetEffectTreeIndex(int index);
   int effect_tree_index() const { return effect_tree_index_; }
 
+  void SetScrollTreeIndex(int index);
+  int scroll_tree_index() const { return scroll_tree_index_; }
+
   void set_offset_to_transform_parent(const gfx::Vector2dF& offset) {
     offset_to_transform_parent_ = offset;
     SetNeedsPushProperties();
@@ -829,6 +832,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   int transform_tree_index_;
   int effect_tree_index_;
   int clip_tree_index_;
+  int scroll_tree_index_;
 
   // The global depth value of the center of the layer. This value is used
   // to sort layers from back to front.
diff --git a/cc/proto/layer.proto b/cc/proto/layer.proto
index 4c8ba31..84ec3b7 100644
--- a/cc/proto/layer.proto
+++ b/cc/proto/layer.proto
@@ -69,6 +69,7 @@ message LayerProperties {
   optional PictureLayerProperties picture = 6;
 }
 
+// NEXT ID: 51
 message BaseLayerProperties {
   optional Point3F transform_origin = 1;
   optional uint32 background_color = 2;
@@ -76,6 +77,7 @@ message BaseLayerProperties {
   optional int64 transform_free_index = 4;
   optional int64 effect_tree_index = 5;
   optional int64 clip_tree_index = 6;
+  optional int64 scroll_tree_index = 50;
   optional Vector2dF offset_to_transform_parent = 7;
   optional bool double_sided = 8;
   optional bool draws_content = 9;
diff --git a/cc/proto/property_tree.proto b/cc/proto/property_tree.proto
index d35f264..d7d74b2 100644
--- a/cc/proto/property_tree.proto
+++ b/cc/proto/property_tree.proto
@@ -93,9 +93,8 @@ message EffectNodeData {
 message ScrollNodeData {
   optional bool scrollable = 1;
   optional bool should_scroll_on_main_thread = 2;
-  optional int32 scroll_blocks_on = 3;
-  optional bool contains_non_fast_scrollable_region = 4;
-  optional int64 transform_id = 5;
+  optional bool contains_non_fast_scrollable_region = 3;
+  optional int64 transform_id = 4;
 }
 
 // This defines the proto used for all types of struct TreeNode.
@@ -156,9 +155,9 @@ message PropertyTrees {
   optional PropertyTree transform_tree = 1;
   optional PropertyTree effect_tree = 2;
   optional PropertyTree clip_tree = 3;
-  optional PropertyTree scroll_tree = 4;
+  optional PropertyTree scroll_tree = 7;
 
-  optional bool needs_rebuild = 5;
-  optional bool non_root_surfaces_enabled = 6;
-  optional int64 sequence_number = 7;
+  optional bool needs_rebuild = 4;
+  optional bool non_root_surfaces_enabled = 5;
+  optional int64 sequence_number = 6;
 }
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 3a426ec..e98e138 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -9837,5 +9837,157 @@ TEST_F(LayerTreeHostCommonTest, SerializeScrollAndScale) {
   EXPECT_TRUE(scroll_and_scale_set.EqualsForTesting(new_scroll_and_scale_set));
 }
 
+TEST_F(LayerTreeHostCommonTest, ScrollTreeBuilderTest) {
+  // Test the behavior of scroll tree builder
+  // Topology:
+  // +root1(1)
+  // +--parent2(2)[should_scroll_on_main_thread & scrollable]
+  // +----child6(6)[should_scroll_on_main_thread]
+  // +------grand_child10(10)[should_scroll_on_main_thread]
+  // +--parent3(3)
+  // +----child7(7)[scrollable]
+  // +----child8(8)[scroll_parent=7]
+  // +------grand_child11(11)[scrollable]
+  // +--parent4(4)
+  // +----child9(9)
+  // +------grand_child12(12)
+  // +--parent5(5)[contains_non_fast_scrollable_region]
+  //
+  // Expected scroll tree topology:
+  // +property_tree_root---owner:-1
+  // +--root---owner:1, id:1
+  // +----node---owner:2, id:2
+  // +------node---owner:6, id:3
+  // +----node---owner:7, id:4
+  // +------node---owner:11, id:5
+  // +----node---owner:5, id:6
+  //
+  // Extra check:
+  //   scroll_tree_index() of:
+  //     grand_child10:3
+  //     parent3:1
+  //     child8:4
+  //     parent4:1
+  //     child9:1
+  //     grand_child12:1
+  scoped_refptr<Layer> root1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent3 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent4 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent5 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child6 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child7 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child8 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child9 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child10 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child11 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child12 = Layer::Create(layer_settings());
+
+  root1->AddChild(parent2);
+  root1->AddChild(parent3);
+  root1->AddChild(parent4);
+  root1->AddChild(parent5);
+  parent2->AddChild(child6);
+  parent3->AddChild(child7);
+  parent3->AddChild(child8);
+  parent4->AddChild(child9);
+  child6->AddChild(grand_child10);
+  child8->AddChild(grand_child11);
+  child9->AddChild(grand_child12);
+  host()->SetRootLayer(root1);
+
+  parent2->AddMainThreadScrollingReasons(
+      MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
+  parent2->SetScrollClipLayerId(root1->id());
+  child6->AddMainThreadScrollingReasons(
+      MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
+  grand_child10->AddMainThreadScrollingReasons(
+      MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
+
+  child7->SetScrollClipLayerId(root1->id());
+  child8->SetScrollParent(child7.get());
+  grand_child11->SetScrollClipLayerId(root1->id());
+
+  parent5->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
+
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root1.get());
+
+  const int kInvalidPropertyTreeNodeId = -1;
+  const int kRootPropertyTreeNodeId = 0;
+
+  // Property tree root
+  ScrollTree scroll_tree = host()->property_trees()->scroll_tree;
+  ScrollTree expected_scroll_tree;
+  ScrollNode* property_tree_root = expected_scroll_tree.Node(0);
+  property_tree_root->id = kRootPropertyTreeNodeId;
+  property_tree_root->parent_id = kInvalidPropertyTreeNodeId;
+  property_tree_root->owner_id = kInvalidPropertyTreeNodeId;
+  property_tree_root->data.scrollable = false;
+  property_tree_root->data.should_scroll_on_main_thread = false;
+  property_tree_root->data.contains_non_fast_scrollable_region = false;
+  property_tree_root->data.transform_id = kRootPropertyTreeNodeId;
+
+  // The node owned by root1
+  ScrollNode scroll_root1;
+  scroll_root1.id = 1;
+  scroll_root1.owner_id = root1->id();
+  scroll_root1.data.transform_id = root1->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_root1, 0);
+
+  // The node owned by parent2
+  ScrollNode scroll_parent2;
+  scroll_parent2.id = 2;
+  scroll_parent2.owner_id = parent2->id();
+  scroll_parent2.data.scrollable = true;
+  scroll_parent2.data.should_scroll_on_main_thread = true;
+  scroll_parent2.data.transform_id = parent2->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_parent2, 1);
+
+  // The node owned by child6
+  ScrollNode scroll_child6;
+  scroll_child6.id = 3;
+  scroll_child6.owner_id = child6->id();
+  scroll_child6.data.should_scroll_on_main_thread = true;
+  scroll_child6.data.transform_id = child6->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_child6, 2);
+
+  // The node owned by child7, child7 also owns a transform node
+  ScrollNode scroll_child7;
+  scroll_child7.id = 4;
+  scroll_child7.owner_id = child7->id();
+  scroll_child7.data.scrollable = true;
+  scroll_child7.data.transform_id = child7->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_child7, 1);
+
+  // The node owned by grand_child11, grand_child11 also owns a transform node
+  ScrollNode scroll_grand_child11;
+  scroll_grand_child11.id = 5;
+  scroll_grand_child11.owner_id = grand_child11->id();
+  scroll_grand_child11.data.scrollable = true;
+  scroll_grand_child11.data.transform_id =
+      grand_child11->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_grand_child11, 4);
+
+  // The node owned by parent5
+  ScrollNode scroll_parent5;
+  scroll_parent5.id = 8;
+  scroll_parent5.owner_id = parent5->id();
+  scroll_parent5.data.contains_non_fast_scrollable_region = true;
+  scroll_parent5.data.transform_id = parent5->transform_tree_index();
+  expected_scroll_tree.Insert(scroll_parent5, 1);
+
+  expected_scroll_tree.set_needs_update(false);
+
+  EXPECT_EQ(expected_scroll_tree, scroll_tree);
+
+  // Check other layers' scroll_tree_index
+  EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
+  EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
+  EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
+  EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
+  EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
+  EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index aae88ae..54d885e 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -471,14 +471,12 @@ void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
       should_scroll_on_main_thread(false),
-      scroll_blocks_on(ScrollBlocksOn::SCROLL_BLOCKS_ON_NONE),
       contains_non_fast_scrollable_region(false),
       transform_id(0) {}
 
 bool ScrollNodeData::operator==(const ScrollNodeData& other) const {
   return scrollable == other.scrollable &&
          should_scroll_on_main_thread == other.should_scroll_on_main_thread &&
-         scroll_blocks_on == other.scroll_blocks_on &&
          contains_non_fast_scrollable_region ==
              other.contains_non_fast_scrollable_region &&
          transform_id == other.transform_id;
@@ -489,7 +487,6 @@ void ScrollNodeData::ToProtobuf(proto::TreeNode* proto) const {
   proto::ScrollNodeData* data = proto->mutable_scroll_node_data();
   data->set_scrollable(scrollable);
   data->set_should_scroll_on_main_thread(should_scroll_on_main_thread);
-  data->set_scroll_blocks_on(scroll_blocks_on);
   data->set_contains_non_fast_scrollable_region(
       contains_non_fast_scrollable_region);
   data->set_transform_id(transform_id);
@@ -501,7 +498,6 @@ void ScrollNodeData::FromProtobuf(const proto::TreeNode& proto) {
 
   scrollable = data.scrollable();
   should_scroll_on_main_thread = data.should_scroll_on_main_thread();
-  scroll_blocks_on = (ScrollBlocksOn)data.scroll_blocks_on();
   contains_non_fast_scrollable_region =
       data.contains_non_fast_scrollable_region();
   transform_id = data.transform_id();
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index dc479a9..a833e02 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -265,7 +265,6 @@ struct CC_EXPORT ScrollNodeData {
 
   bool scrollable;
   bool should_scroll_on_main_thread;
-  ScrollBlocksOn scroll_blocks_on;
   bool contains_non_fast_scrollable_region;
 
   int transform_id;
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index 8af9eb8..8bb23ca 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,7 @@ struct DataForRecursion {
   bool should_flatten;
   bool target_is_clipped;
   bool is_hidden;
+  bool scroll_tree_parent_created_by_uninheritable_criteria;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_compensation_adjustment;
   gfx::Transform compound_transform_since_render_target;
@@ -77,7 +80,7 @@ static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
 template <typename LayerType>
 static ClipNode* GetClipParent(const DataForRecursion<LayerType>& data,
                                LayerType* layer) {
-  const bool inherits_clip = !layer->parent() || !layer->clip_parent();
+  const bool inherits_clip = !layer->clip_parent();
   const int id = inherits_clip ? data.clip_tree_parent
                                : layer->clip_parent()->clip_tree_index();
   return data.clip_tree->Node(id);
@@ -89,6 +92,15 @@ static bool LayerClipsSubtree(LayerType* layer) {
 }
 
 template <typename LayerType>
+static int GetScrollParentId(const DataForRecursion<LayerType>& data,
+                             LayerType* layer) {
+  const bool inherits_scroll = !layer->scroll_parent();
+  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,
@@ -622,6 +634,46 @@ 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();
+  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 scroll_node_uninheritable_criteria =
+      is_root || scrollable || contains_non_fast_scrollable_region;
+  bool requires_node =
+      scroll_node_uninheritable_criteria ||
+      (should_scroll_on_main_thread &&
+       data_from_ancestor.scroll_tree_parent_created_by_uninheritable_criteria);
+
+  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.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_tree_parent_created_by_uninheritable_criteria =
+        scroll_node_uninheritable_criteria;
+  }
+
+  layer->SetScrollTreeIndex(data_for_children->scroll_tree_parent);
+}
+
+template <typename LayerType>
 void BuildPropertyTreesInternal(
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent,
@@ -648,6 +700,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);
+
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->child_at(i)->scroll_parent()) {
       DataForRecursionFromChild<LayerType> data_from_child;
@@ -725,11 +779,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;
@@ -742,11 +798,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_tree_parent_created_by_uninheritable_criteria =
+      true;
   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;
@@ -771,6 +830,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(true);
+  property_trees->scroll_tree.set_needs_update(false);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
diff --git a/cc/trees/property_tree_unittest.cc b/cc/trees/property_tree_unittest.cc
index ac3e067..9d0c907 100644
--- a/cc/trees/property_tree_unittest.cc
+++ b/cc/trees/property_tree_unittest.cc
@@ -230,7 +230,6 @@ TEST(PropertyTreeSerializationTest, ScrollNodeDataSerialization) {
   ScrollNodeData original;
   original.scrollable = true;
   original.should_scroll_on_main_thread = false;
-  original.scroll_blocks_on = SCROLL_BLOCKS_ON_WHEEL_EVENT;
   original.contains_non_fast_scrollable_region = false;
   original.transform_id = 2;
 
@@ -267,6 +266,9 @@ TEST(PropertyTreeSerializationTest, ScrollTreeSerialization) {
   third.data.transform_id = 5;
   third.data.contains_non_fast_scrollable_region = true;
 
+  original.Insert(second, 0);
+  original.Insert(third, 1);
+
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   ScrollTree result;