Added serialization to protobufs for property trees.

cc/trees/property_tree_unittest.cc

Index: cc/trees/property_tree_unittest.cc
diff --git a/cc/trees/property_tree_unittest.cc b/cc/trees/property_tree_unittest.cc
index e72a9ad83a86c7a11be6836addea234bf077b9b3..29c508250886114e9f8ebb231ea5f594c130843a 100644
--- a/cc/trees/property_tree_unittest.cc
+++ b/cc/trees/property_tree_unittest.cc
@@ -4,39 +4,123 @@
 
 #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;
+
+  proto::TreeNode proto;
+  original.ToProtobuf(&proto);
+  ClipNodeData result;
+  result.FromProtobuf(proto);
+
+  EXPECT_EQ(original, result);
+}
 
-  gfx::Transform expected;
-  gfx::Transform transform;
-  bool success = tree.ComputeTransform(0, 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;
 
-  transform.MakeIdentity();
-  expected.Translate(2, 2);
-  success = tree.ComputeTransform(0, -1, &transform);
-  EXPECT_TRUE(success);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+  proto::TreeNode proto;
+  original.ToProtobuf(&proto);
+  EffectNodeData result;
+  result.FromProtobuf(proto);
 
-  transform.MakeIdentity();
-  expected.MakeIdentity();
-  expected.Translate(-2, -2);
-  success = tree.ComputeTransform(-1, 0, &transform);
-  EXPECT_TRUE(success);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
+  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);