Added serialization to protobufs for 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/proto/property_tree.pb.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/draw_property_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Maybe anonymous namespace in here for everything?

[Khushal, 2015/11/13 10:33:13]

Done.

 
-TEST(PropertyTreeTest, ComputeTransformRoot) {
-  TransformTree tree;
-  TransformNode& root = *tree.Node(0);
-  root.data.local.Translate(2, 2);
-  root.data.target_id = 0;
-  tree.UpdateTransforms(0);
+TEST(PropertyTreeSerializationTest, ClipNodeDataSerialization) {

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Add transform one.

[Khushal, 2015/11/13 10:33:13]

Done.

+  ClipNodeData original;
+  original.clip = gfx::RectF(0.5f, 0.5f);
+  original.combined_clip_in_target_space = gfx::RectF(0.6f, 0.6f);
+  original.clip_in_target_space = gfx::RectF(0.7f, 0.7f);
+  original.transform_id = 2;
+  original.target_id = 3;
+  original.applies_local_clip = false;
+  original.layer_clipping_uses_only_local_clip = false;
+  original.target_is_clipped = false;
+  original.layers_are_clipped = false;
+  original.layers_are_clipped_when_surfaces_disabled = false;
+  original.resets_clip = false;
 
-  gfx::Transform expected;
-  gfx::Transform transform;
-  bool success = tree.ComputeTransform(0, 0, &transform);
-  EXPECT_TRUE(success);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+  proto::TreeNode proto;
+  original.ToProtobuf(&proto);
+  ClipNodeData result;
+  result.FromProtobuf(proto);
 
-  transform.MakeIdentity();
-  expected.Translate(2, 2);
-  success = tree.ComputeTransform(0, -1, &transform);
-  EXPECT_TRUE(success);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+  EXPECT_EQ(original, result);
+}
 
-  transform.MakeIdentity();
-  expected.MakeIdentity();
-  expected.Translate(-2, -2);
-  success = tree.ComputeTransform(-1, 0, &transform);
-  EXPECT_TRUE(success);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+TEST(PropertyTreeSerializationTest, EffectNodeDataSerialization) {
+  EffectNodeData original;
+  original.opacity = 0.5f;
+  original.screen_space_opacity = 0.6f;
+  original.has_render_surface = false;
+  original.transform_id = 2;
+  original.clip_id = 3;
+
+  proto::TreeNode proto;
+  original.ToProtobuf(&proto);
+  EffectNodeData result;
+  result.FromProtobuf(proto);
+
+  EXPECT_EQ(original, result);
 }
 
+class PropertyTreeTest : public testing::Test {

[Khushal, 2015/11/12 00:33:11]

Would it be a good idea to use something like this to run the same property tree
tests after serializing an object. This validates that the serialization doesn't
change the expected behaviour of the class.

+ public:
+  PropertyTreeTest() : test_serialization_(false) {}
+
+ protected:
+  void RunTest(bool test_serialization) {
+    test_serialization_ = test_serialization;
+    StartTest();
+  }
+
+  virtual void StartTest() = 0;
+
+  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);
+    return new_tree;
+  }
+
+ private:
+  bool test_serialization_;
+};
+
+#define DIRECT_PROPERTY_TREE_TEST_F(TEST_FIXTURE_NAME) \

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Good idea IMO :).

Maybe #undef these after the test code just to be clean?

[Khushal, 2015/11/13 10:33:13]

Done.

+  TEST_F(TEST_FIXTURE_NAME, RunDirect) { RunTest(false); }

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Always use PropertyTreeTest as the fixture name.  Then build the test name with
something like TEST_FIXTURE_NAME##Direct or ##Serialized.  I forget the macro
format though.

[David Trainor- moved to gerrit, 2015/11/12 22:49:33]

Just a note from our offline discussion, it looks like this follows the
layer_tree_test existing macro format.  Carry on!

[Khushal, 2015/11/13 10:33:13]

Done.

+
+#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;
+    TransformNode& root = *tree.Node(0);
+    root.data.local.Translate(2, 2);
+    root.data.target_id = 0;
+    tree.UpdateTransforms(0);
+
+    TransformTree test_tree = TransformTreeForTest(tree);
+
+    gfx::Transform expected;
+    gfx::Transform transform;
+    bool success = test_tree.ComputeTransform(0, 0, &transform);
+    EXPECT_TRUE(success);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+
+    transform.MakeIdentity();
+    expected.Translate(2, 2);
+    success = test_tree.ComputeTransform(0, -1, &transform);
+    EXPECT_TRUE(success);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+
+    transform.MakeIdentity();
+    expected.MakeIdentity();
+    expected.Translate(-2, -2);
+    success = test_tree.ComputeTransform(-1, 0, &transform);
+    EXPECT_TRUE(success);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+  }
+};
+
+DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
+    PropertyTreeTestComputeTransformRoot);

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Can we just call this ComputeTransformRoot?  That might look a little cleaner.

[David Trainor- moved to gerrit, 2015/11/12 22:49:33]

Same as above, ignore.

+
 TEST(PropertyTreeTest, ComputeTransformChild) {
   TransformTree 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;
@@ skipping 528 matching lines @@
   tree.Node(child)->data.target_id = child;
   tree.set_needs_update(true);
   ComputeTransforms(&tree);
   EXPECT_TRUE(
       tree.Node(parent)->data.node_and_ancestors_have_only_integer_translation);
   EXPECT_TRUE(
       tree.Node(child)->data.node_and_ancestors_have_only_integer_translation);
 }
 
 }  // namespace cc