Move MaxScrollOffset to property_trees

cc/trees/property_tree_unittest.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.h"
 
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/draw_property_utils.h"
@@ skipping 82 matching lines @@
   original.Insert(second, 0);
   original.Insert(third, 1);
   original.set_needs_update(true);
 
   original.set_page_scale_factor(0.5f);
   original.set_device_scale_factor(0.6f);
   gfx::Transform transform =
       gfx::Transform(1.05f, 2.15f, 3.14f, 4.13f, 5.12f, 6.11f, 7.1f, 8.9f, 9.8f,
                      10.7f, 11.6f, 12.5f, 13.4f, 14.3f, 15.2f, 16.1f);
   original.SetDeviceTransformScaleFactor(transform);
-  original.SetInnerViewportBoundsDelta(gfx::Vector2dF(0.4f, 0.6f));
-  original.SetOuterViewportBoundsDelta(gfx::Vector2dF(0.5f, 0.7f));
   original.AddNodeAffectedByInnerViewportBoundsDelta(0);
   original.AddNodeAffectedByOuterViewportBoundsDelta(1);
 
   proto::PropertyTree proto;
   original.ToProtobuf(&proto);
   TransformTree result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
@@ skipping 111 matching lines @@
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ScrollNodeDataSerialization) {
   ScrollNodeData original;
   original.scrollable = true;
   original.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kScrollbarScrolling;
   original.contains_non_fast_scrollable_region = false;
-  original.transform_id = 2;
+  original.scroll_clip_layer_bounds = gfx::Size(10, 10);
+  original.bounds = gfx::Size(15, 15);
+  original.max_scroll_offset_affected_by_page_scale = true;
+  original.is_inner_viewport_scroll_layer = true;
+  original.is_outer_viewport_scroll_layer = false;
 
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   ScrollNodeData result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ScrollNodeSerialization) {
   ScrollNode original;
   original.id = 3;
   original.parent_id = 2;
   original.owner_id = 4;
 
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   ScrollNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, ScrollTreeSerialization) {
   ScrollTree original;
-  ScrollNode& root = *original.Node(0);
-  root.data.transform_id = 2;
   ScrollNode second;
-  second.data.transform_id = 4;
   second.data.scrollable = true;
+  second.data.bounds = gfx::Size(15, 15);
   ScrollNode third;
-  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;
   result.FromProtobuf(proto);
 
@@ skipping 36 matching lines @@
 
   TransformTree TransformTreeForTest(const TransformTree& transform_tree) {
     if (!test_serialization_) {
       return transform_tree;
     }
     TransformTree new_tree;
     proto::PropertyTree proto;
     transform_tree.ToProtobuf(&proto);
     new_tree.FromProtobuf(proto);
 
+    new_tree.SetPropertyTrees(transform_tree.property_trees());
+
     EXPECT_EQ(transform_tree, new_tree);
     return new_tree;
   }
 
   EffectTree EffectTreeForTest(const EffectTree& effect_tree) {
     if (!test_serialization_) {
       return effect_tree;
     }
     EffectTree new_tree;
     proto::PropertyTree proto;
@@ skipping 14 matching lines @@
 #define SERIALIZED_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME) \
   TEST_F(TEST_FIXTURE_NAME, RunSerialized) { RunTest(true); }
 
 #define DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME) \
   DIRECT_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME);                     \
   SERIALIZED_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME)
 
 class PropertyTreeTestComputeTransformRoot : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.local.Translate(2, 2);
     root.data.target_id = 0;
     tree = TransformTreeForTest(tree);
     tree.UpdateTransforms(0);
 
     gfx::Transform expected;
     gfx::Transform transform;
     bool success = tree.ComputeTransform(0, 0, &transform);
     EXPECT_TRUE(success);
@@ skipping 13 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformRoot);
 
 class PropertyTreeTestComputeTransformChild : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.local.Translate(2, 2);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode child;
     child.data.local.Translate(3, 3);
     child.data.target_id = 0;
     child.data.source_node_id = 0;
 
@@ skipping 31 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformChild);
 
 class PropertyTreeTestComputeTransformSibling : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.local.Translate(2, 2);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode child;
     child.data.local.Translate(3, 3);
     child.data.source_node_id = 0;
     child.data.target_id = 0;
 
@@ skipping 36 matching lines @@
   void StartTest() override {
     // In this test, we have the following tree:
     // root
     //   + singular
     //     + child
     //     + sibling
     // Since the lowest common ancestor of |child| and |sibling| has a singular
     // transform, we cannot use screen space transforms to compute change of
     // basis
     // transforms between these nodes.
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.local.Translate(2, 2);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode singular;
     singular.data.local.matrix().set(2, 2, 0.0);
     singular.data.source_node_id = 0;
     singular.data.target_id = 0;
 
@@ skipping 33 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformSiblingSingularAncestor);
 
 class PropertyTreeTestTransformsWithFlattening : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
 
     int grand_parent = tree.Insert(TransformNode(), 0);
     tree.Node(grand_parent)->data.content_target_id = grand_parent;
     tree.Node(grand_parent)->data.target_id = grand_parent;
     tree.Node(grand_parent)->data.source_node_id = 0;
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int parent = tree.Insert(TransformNode(), grand_parent);
@@ skipping 64 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x, grand_child_to_child);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestTransformsWithFlattening);
 
 class PropertyTreeTestMultiplicationOrder : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.local.Translate(2, 2);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode child;
     child.data.local.Scale(2, 2);
     child.data.target_id = 0;
     child.data.source_node_id = 0;
 
@@ skipping 20 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(PropertyTreeTestMultiplicationOrder);
 
 class PropertyTreeTestComputeTransformWithUninvertibleTransform
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode child;
     child.data.local.Scale(0, 0);
     child.data.target_id = 0;
     child.data.source_node_id = 0;
 
     tree.Insert(child, 0);
@@ skipping 17 matching lines @@
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformWithUninvertibleTransform);
 
 class PropertyTreeTestComputeTransformWithSublayerScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode grand_parent;
     grand_parent.data.local.Scale(2.f, 2.f);
     grand_parent.data.target_id = 0;
     grand_parent.data.source_node_id = 0;
     grand_parent.data.needs_sublayer_scale = true;
     int grand_parent_id = tree.Insert(grand_parent, 0);
@@ skipping 96 matching lines @@
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformWithSublayerScale);
 
 class PropertyTreeTestComputeTransformToTargetWithZeroSublayerScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.data.target_id = 0;
     tree.UpdateTransforms(0);
 
     TransformNode grand_parent;
     grand_parent.data.local.Scale(2.f, 0.f);
     grand_parent.data.target_id = 0;
     grand_parent.data.source_node_id = 0;
     grand_parent.data.needs_sublayer_scale = true;
     int grand_parent_id = tree.Insert(grand_parent, 0);
@@ skipping 54 matching lines @@
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformToTargetWithZeroSublayerScale);
 
 class PropertyTreeTestFlatteningWhenDestinationHasOnlyFlatAncestors
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that flattening is performed correctly when
     // destination and its ancestors are flat, but there are 3d transforms
     // and flattening between the source and destination.
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
 
     int parent = tree.Insert(TransformNode(), 0);
     tree.Node(parent)->data.content_target_id = parent;
     tree.Node(parent)->data.target_id = parent;
     tree.Node(parent)->data.source_node_id = 0;
     tree.Node(parent)->data.local.Translate(2, 2);
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
@@ skipping 55 matching lines @@
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestScreenSpaceOpacityUpdateTest);
 
 class PropertyTreeTestNonIntegerTranslationTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that when a node has non-integer translation, the information
     // is propagated to the subtree.
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
 
     int parent = tree.Insert(TransformNode(), 0);
     tree.Node(parent)->data.target_id = parent;
     tree.Node(parent)->data.local.Translate(1.5f, 1.5f);
 
     int child = tree.Insert(TransformNode(), parent);
     tree.Node(child)->data.target_id = parent;
     tree.Node(child)->data.local.Translate(1, 1);
     tree.set_needs_update(true);
     tree = TransformTreeForTest(tree);
@@ skipping 26 matching lines @@
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestNonIntegerTranslationTest);
 
 class PropertyTreeTestSingularTransformSnapTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that to_target transform is not snapped when it has a singular
     // transform.
-    TransformTree tree;
+    PropertyTrees property_trees;
+    TransformTree tree = property_trees.transform_tree;
 
     int parent = tree.Insert(TransformNode(), 0);
     tree.Node(parent)->data.target_id = parent;
     tree.Node(parent)->data.scrolls = true;
 
     int child = tree.Insert(TransformNode(), parent);
     TransformNode* child_node = tree.Node(child);
     child_node->data.target_id = parent;
     child_node->data.scrolls = true;
     child_node->data.local.Scale3d(6.0f, 6.0f, 0.0f);
@@ skipping 21 matching lines @@
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestSingularTransformSnapTest);
 
 #undef DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F
 #undef SERIALIZED_PROPERTY_TREE_TEST_F
 #undef DIRECT_PROPERTY_TREE_TEST_F
 
 }  // namespace
 }  // namespace cc