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

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 1400 matching lines @@
   if (proto.has_replica_layer()) {
     replica_layer_ = LayerProtoConverter::FindOrAllocateAndConstruct(
         proto.replica_layer(), layer_map);
     replica_layer_->FromLayerNodeProto(proto.replica_layer(), layer_map);
     replica_layer_->SetParent(this);
   } else {
     replica_layer_ = nullptr;
   }
 }
 
+void Layer::ToLayerPropertiesProto(proto::LayerUpdate* layer_update) {
+  if (!needs_push_properties_ && num_dependents_need_push_properties_ == 0)
+    return;
+
+  // Always set properties metadata for serialized layers.
+  proto::LayerProperties* proto = layer_update->add_layers();
+  proto->set_id(layer_id_);
+  proto->set_needs_push_properties(needs_push_properties_);
+  proto->set_num_dependents_need_push_properties(
+      num_dependents_need_push_properties_);
+
+  if (needs_push_properties_)

[vmpstr, 2015/11/17 21:05:44]

Is this to reduce the size of the proto? That is, we have skeleton type of nodes
when needs_push_properties_ is false, just so we can have the
num_dependents_need_push_properties_?

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

Yes. I do think that we could optimize this in the future though, at the cost of
some complexity.

+    LayerSpecificPropertiesToProto(proto);
+
+  if (num_dependents_need_push_properties_ > 0) {
+    for (const auto& child : children_) {
+      child->ToLayerPropertiesProto(layer_update);
+    }
+    if (mask_layer_)
+      mask_layer_->ToLayerPropertiesProto(layer_update);
+    if (replica_layer_)
+      replica_layer_->ToLayerPropertiesProto(layer_update);
+  }
+
+  needs_push_properties_ = false;
+  num_dependents_need_push_properties_ = 0;
+}
+
+void Layer::FromLayerPropertiesProto(const proto::LayerProperties& proto) {

[vmpstr, 2015/11/17 21:05:44]

It's a little bit confusing that ToLayerPropertiesProto serializes the
properties of this layer, and the properties of the children. 

However, the reverse function FromLayerPropertiesProto only deserializes the
properties of this layer. Where are the properties of children deserialized?

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

Yeah, that's in LayerProtoConverter. I've made them symmetric now.

+  DCHECK(proto.has_id());
+  DCHECK_EQ(layer_id_, proto.id());
+  DCHECK(proto.has_needs_push_properties());
+  needs_push_properties_ = proto.needs_push_properties();
+  DCHECK(proto.has_num_dependents_need_push_properties());
+  num_dependents_need_push_properties_ =
+      proto.num_dependents_need_push_properties();
+
+  if (!needs_push_properties_)
+    return;
+
+  FromLayerSpecificPropertiesProto(proto);
+}
+
+void Layer::LayerSpecificPropertiesToProto(proto::LayerProperties* proto) {
+  // TODO(nyquist): Write all required properties to |proto|.
+  // Create an empty proto::LayerProperties::base message.
+  proto->mutable_base();
+}
+
+void Layer::FromLayerSpecificPropertiesProto(
+    const proto::LayerProperties& proto) {
+  DCHECK(proto.has_base());
+  // TODO(nyquist): Read all required properties from |proto|.
+}
+
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_,
                            new LayerImpl::SyncedScrollOffset);
 }
 
 bool Layer::DrawsContent() const {
   return draws_content_;
 }
 
 bool Layer::HasDrawableContent() const {
@@ skipping 345 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc