Add support for (de)serializing cc::Layer properties.

cc/layers/layer_proto_converter_unittest.cc

 // Copyright 2015 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/layers/layer_proto_converter.h"
 
 #include "cc/layers/layer.h"
 #include "cc/proto/layer.pb.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 89 matching lines @@
   EXPECT_EQ(child_a_node->id(), child_a->id());
   EXPECT_EQ(child_b_node->id(), child_b->id());
 
   EXPECT_EQ(0u, child_a->children().size());
   ASSERT_EQ(1u, child_b->children().size());
 
   scoped_refptr<Layer> child_c = child_b->children()[0];
   EXPECT_EQ(child_c_node->id(), child_c->id());
 }
 
+TEST(LayerProtoConverterTest, RecursivePropertiesSerialization) {

[vmpstr, 2015/11/18 04:05:25]

Can you add a test for

root+ ----- b* [mask:*] ---- c

to ensure that you get "b" and "mask" 

[nyquist, 2015/11/18 07:15:59]

Yeah, but from what I understand, for the b-node, this will be:
b*+[mask:*] (note the added +)
since mask is considered a descendant of b.

+  /* Testing serialization of properties for a tree that looks like this:
+          root+
+          /  \
+         a*   b*+[mask:*,replica]
+        /      \
+       c        d*
+     Layers marked with * have changed properties.
+     Layers marked with + have descendants with changed properties.
+     Layer b also has a mask layer and a replica layer.
+  */
+  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_b_mask = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_b_replica = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_d = Layer::Create(LayerSettings());
+  layer_src_root->AddChild(layer_src_a);
+  layer_src_root->AddChild(layer_src_b);
+  layer_src_a->AddChild(layer_src_c);
+  layer_src_b->AddChild(layer_src_d);
+  layer_src_b->SetMaskLayer(layer_src_b_mask.get());
+  layer_src_b->SetReplicaLayer(layer_src_b_replica.get());
+
+  layer_src_a->SetNeedsPushProperties();
+  layer_src_b->SetNeedsPushProperties();
+  layer_src_b_mask->SetNeedsPushProperties();
+  layer_src_d->SetNeedsPushProperties();
+
+  proto::LayerUpdate layer_update;
+  LayerProtoConverter::SerializeLayerProperties(layer_src_root, &layer_update);

[nyquist, 2015/11/18 00:24:34]

This test is literally the same as LayerTest::RecursivePropertiesSerialization
from patch set 10, except the following change to this line:

-  layer_src_root->ToLayerPropertiesProto(&layer_update);
+  LayerProtoConverter::SerializeLayerProperties(layer_src_root, &layer_update);

+
+  // All flags for pushing properties should have been cleared.
+  EXPECT_FALSE(layer_src_root->needs_push_properties());
+  EXPECT_FALSE(layer_src_root->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_a->needs_push_properties());
+  EXPECT_FALSE(layer_src_a->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_b->needs_push_properties());
+  EXPECT_FALSE(layer_src_b->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_b_mask->needs_push_properties());
+  EXPECT_FALSE(layer_src_b_mask->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_b_replica->needs_push_properties());
+  EXPECT_FALSE(layer_src_b_replica->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_c->needs_push_properties());
+  EXPECT_FALSE(layer_src_c->descendant_needs_push_properties());
+  EXPECT_FALSE(layer_src_d->needs_push_properties());
+  EXPECT_FALSE(layer_src_d->descendant_needs_push_properties());
+
+  // Only 5 of the layers should have been serialized.
+  ASSERT_EQ(5, layer_update.layers_size());
+  EXPECT_EQ(layer_src_root->id(), layer_update.layers(0).id());
+  proto::LayerProperties dest_root = layer_update.layers(0);
+  EXPECT_EQ(layer_src_a->id(), layer_update.layers(1).id());
+  proto::LayerProperties dest_a = layer_update.layers(1);
+  EXPECT_EQ(layer_src_b->id(), layer_update.layers(2).id());
+  proto::LayerProperties dest_b = layer_update.layers(2);
+  EXPECT_EQ(layer_src_d->id(), layer_update.layers(3).id());
+  proto::LayerProperties dest_d = layer_update.layers(3);
+  EXPECT_EQ(layer_src_b_mask->id(), layer_update.layers(4).id());
+  proto::LayerProperties dest_b_mask = layer_update.layers(4);
+
+  // Ensure the properties and dependants metadata is correctly serialized.
+  EXPECT_FALSE(dest_root.needs_push_properties());
+  EXPECT_EQ(2, dest_root.num_dependents_need_push_properties());
+  EXPECT_FALSE(dest_root.has_base());
+
+  EXPECT_TRUE(dest_a.needs_push_properties());
+  EXPECT_EQ(0, dest_a.num_dependents_need_push_properties());
+  EXPECT_TRUE(dest_a.has_base());
+
+  EXPECT_TRUE(dest_b.needs_push_properties());
+  EXPECT_EQ(2, dest_b.num_dependents_need_push_properties());
+  EXPECT_TRUE(dest_b.has_base());
+
+  EXPECT_TRUE(dest_d.needs_push_properties());
+  EXPECT_EQ(0, dest_d.num_dependents_need_push_properties());
+  EXPECT_TRUE(dest_d.has_base());
+
+  EXPECT_TRUE(dest_b_mask.needs_push_properties());
+  EXPECT_EQ(0, dest_b_mask.num_dependents_need_push_properties());
+  EXPECT_TRUE(dest_b_mask.has_base());
+}
+
+TEST(LayerProtoConverterTest, DeserializeLayerProperties) {
+  /* Testing deserialization of properties for a tree that looks like this:
+          root*+
+          /  \
+         a    b+
+               \
+                c*
+     Layers marked with * have changed properties.
+     Layers marked with + have descendants with changed properties.
+  */
+  proto::LayerUpdate updates;
+
+  scoped_refptr<Layer> root = Layer::Create(LayerSettings());
+  proto::LayerProperties* root_props = updates.add_layers();
+  root_props->set_id(root->id());
+  root_props->set_needs_push_properties(true);
+  root_props->set_num_dependents_need_push_properties(1);
+  root_props->mutable_base();
+
+  scoped_refptr<Layer> a = Layer::Create(LayerSettings());
+  proto::LayerProperties* a_props = updates.add_layers();
+  a_props->set_id(a->id());
+  a_props->set_needs_push_properties(false);
+  a_props->set_num_dependents_need_push_properties(0);
+  root->AddChild(a);
+
+  scoped_refptr<Layer> b = Layer::Create(LayerSettings());
+  proto::LayerProperties* b_props = updates.add_layers();
+  b_props->set_id(b->id());
+  b_props->set_needs_push_properties(false);
+  b_props->set_num_dependents_need_push_properties(1);
+  root->AddChild(b);
+
+  scoped_refptr<Layer> c = Layer::Create(LayerSettings());
+  proto::LayerProperties* c_props = updates.add_layers();
+  c_props->set_id(c->id());
+  c_props->set_needs_push_properties(true);
+  c_props->set_num_dependents_need_push_properties(0);
+  c_props->mutable_base();
+  b->AddChild(c);
+
+  LayerProtoConverter::DeserializeLayerProperties(root, updates);
+
+  EXPECT_TRUE(root->needs_push_properties());
+  EXPECT_TRUE(root->descendant_needs_push_properties());
+
+  EXPECT_FALSE(a->needs_push_properties());
+  EXPECT_FALSE(a->descendant_needs_push_properties());
+
+  EXPECT_FALSE(b->needs_push_properties());
+  EXPECT_TRUE(b->descendant_needs_push_properties());
+
+  EXPECT_TRUE(c->needs_push_properties());
+  EXPECT_FALSE(c->descendant_needs_push_properties());
+}
+
 }  // namespace cc