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

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"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/simple_enclosed_region.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/layer_proto_factory.h"
 #include "cc/layers/scrollbar_layer_interface.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
+#include "cc/proto/layer.pb.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 base::StaticAtomicSequenceNumber g_next_layer_id;
@@ skipping 1301 matching lines @@
   layer->SetIsAffectedByPageScale(is_page_scale_layer || parent_affected);
 
   // Reset any state that should be cleared for the next update.
   stacking_order_changed_ = false;
   update_rect_ = gfx::Rect();
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
+void Layer::ToLayerNodeProto(proto::LayerNode* proto) {

[vmpstr, 2015/10/21 22:34:14]

Can this function be const?

[nyquist, 2015/10/23 00:12:30]

Done.

+  proto->set_id(layer_id_);
+  proto->set_type(proto::Base);
+
+  if (parent_) {

[vmpstr, 2015/10/21 22:34:14]

nit: braces optional.

[nyquist, 2015/10/23 00:12:30]

Done.

+    proto->set_parent_id(parent_->id());
+  }
+  proto->clear_children();

[vmpstr, 2015/10/21 22:34:13]

DCHECK that children size is 0 instead? Or are there situations where there may
be children? What are those situations?

[nyquist, 2015/10/23 00:12:30]

Done.

+  for (auto child : children_) {

[vmpstr, 2015/10/21 22:34:14]

What's the type of child? if it's a raw pointer, then you should say auto*, if
it's a ref pointer then you should do const auto& child.

[nyquist, 2015/10/23 00:12:30]

Done.

+    child->ToLayerNodeProto(proto->add_children());
+  }
+
+  if (mask_layer_)
+    mask_layer_->ToLayerNodeProto(proto->mutable_mask_layer());
+  if (replica_layer_)
+    replica_layer_->ToLayerNodeProto(proto->mutable_replica_layer());
+}
+
+void Layer::FromLayerNodeProto(const proto::LayerNode& proto,
+                               const LayerIdMap& layer_map) {
+  if (proto.has_id())

[vmpstr, 2015/10/21 22:34:13]

Are there cases where this isn't set? If not, then DCHECK(proto.has_id());
instead

[nyquist, 2015/10/23 00:12:30]

Done.

+    layer_id_ = proto.id();
+
+  // Recursively remove all children.
+  RemoveAllChildren();

[vmpstr, 2015/10/21 22:34:13]

I assume this is needed because we're using layer_map, right? That is, the
layers that we get might already have children.

[nyquist, 2015/10/23 00:12:30]

Yeah, the issue is if you remove all children from a Layer, we will send no
children through the proto, which means that we will not add any new ones. But,
we also don't delete the old ones...

Since the proto structure contains the whole hierarchy, we can safely first
delete all children, and then add the ones we got.

We could of course check if the children are the same as last time, but I
figured that'd complicate things.

The test "...RemoveSubtree..." tests this specific line in fact, since it
ensures that the number of children are correct.

Added a comment to clarify this in the code as well.

+  for (int i = 0; i < proto.children_size(); ++i) {
+    const proto::LayerNode& child_proto = proto.children(i);
+    if (!child_proto.has_type()) {

[vmpstr, 2015/10/21 22:34:13]

When would this happen?

[nyquist, 2015/10/23 00:12:30]

DCHECK here as well now, so done.

+      continue;
+    }
+    scoped_refptr<Layer> child =
+        LayerProtoFactory::FindOrAllocateAndConstruct(child_proto, layer_map);
+    child->FromLayerNodeProto(child_proto, layer_map);
+    AddChild(child);
+  }
+
+  if (mask_layer_)
+    mask_layer_->RemoveFromParent();
+  if (proto.has_mask_layer()) {
+    mask_layer_ = LayerProtoFactory::FindOrAllocateAndConstruct(
+        proto.mask_layer(), layer_map);
+    mask_layer_->FromLayerNodeProto(proto.mask_layer(), layer_map);
+    mask_layer_->SetParent(this);
+  } else {
+    mask_layer_ = nullptr;
+  }
+
+  if (replica_layer_)
+    replica_layer_->RemoveFromParent();
+  if (proto.has_replica_layer()) {
+    replica_layer_ = LayerProtoFactory::FindOrAllocateAndConstruct(
+        proto.replica_layer(), layer_map);
+    replica_layer_->FromLayerNodeProto(proto.replica_layer(), layer_map);
+    replica_layer_->SetParent(this);
+  } else {
+    replica_layer_ = nullptr;
+  }
+}
+
 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