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

cc/layers/layer.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_H_
 #define CC_LAYERS_LAYER_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/layer_animation_value_observer.h"
 #include "cc/animation/layer_animation_value_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/debug/frame_timing_request.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/layers/paint_properties.h"
 #include "cc/layers/scroll_blocks_on.h"
 #include "cc/output/filter_operations.h"
+#include "cc/proto/layer.pb.h"
 #include "cc/trees/property_tree.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
@@ skipping 29 matching lines @@
 class SimpleEnclosedRegion;
 struct AnimationEvent;
 
 // Base class for composited layers. Special layer types are derived from
 // this class.
 class CC_EXPORT Layer : public base::RefCounted<Layer>,
                         public LayerAnimationValueObserver,
                         public LayerAnimationValueProvider {
  public:
   typedef LayerList LayerListType;
+  typedef base::hash_map<int, scoped_refptr<Layer>> LayerIdMap;
 
   enum LayerIdLabels {
     INVALID_ID = -1,
   };
 
   static scoped_refptr<Layer> Create(const LayerSettings& settings);
 
   int id() const { return layer_id_; }
 
   Layer* RootLayer();
@@ skipping 264 matching lines @@
   virtual void SetIsMask(bool is_mask) {}
   virtual bool IsSuitableForGpuRasterization() const;
 
   virtual scoped_refptr<base::trace_event::ConvertableToTraceFormat>
   TakeDebugInfo();
 
   void SetLayerClient(LayerClient* client) { client_ = client; }
 
   virtual void PushPropertiesTo(LayerImpl* layer);
 
+  // Return the proto::LayerType that should be used for serialization of the
+  // current layer.
+  virtual proto::LayerType GetTypeForProtoSerialization() const;

[Wez, 2015/10/27 03:07:06]

IIUC this was previously implicit in the behaviours overridden by Layer
specializations?

[nyquist, 2015/10/28 16:03:44]

Yeah, it could have been done like that. However, vmpstr@ suggested that I'd
keep the main method non-virtual and only make the layer type accessor to be
virtual.

+
+  // Recursively iterate over this layer and all children and write the
+  // hierarchical structure to the given LayerNode proto. In addition to the
+  // structure itself, the Layer id and type is also written to facilitate
+  // construction of the correct layer on the client.
+  void ToLayerNodeProto(proto::LayerNode* proto) const;

[Wez, 2015/10/27 03:07:06]

Is it necessary for these to live on the actual Layer base - they don't seem to
touch anything private to the layer except for setting the mask_layer_ and
replica_layer_ to nullptr directly?

These methods are also non-virtual, so Layer specializations cannot override
them; what happens if a specialization has additional state to handle?

[nyquist, 2015/10/28 16:03:44]

AFAIK there is no way to set the Layer id outside of the class (only in
constructor), so it needs to live somewhere with write-access to that member.
If that becomes the case, we can change this. As of now, this is how the
hierarchy is organized.

[vmpstr, 2015/10/28 18:20:49]

Yeah, my suggestions only really apply if this is only used for hierarchical
information of the tree. If these functions are also meant to serialize the
actual contents of layers, then it needs a different approach. However, I'm
under the impression that this will be done in a second pass (ie structure and
contents are two different passes).

[Wez, 2015/10/28 23:59:23]

It's not clear that we want to be setting the Layer-id, though - Layer-ids are
allocated globally within the process, so if we allow marshalled data received
from outside to create them with specific Ids, we risk clashes with any
locally-allocated Layers.  That will bite us if we e.g. process serialized Layer
tree data from multiple sources.

Could we use the LayerIdMap to decouple the Ids allocated by the sender from
those we're managing at the receiver, i.e. allow the receiver to allocate
arbitrary Layer Ids locally, and translate all Layer Ids in serialized data into
those local Ids via the LayerIdMap?  We could make LayerProtoConverter a
stateful class and maintain the mapping there, for the various (de)serializers
to use, for example.

+
+  // Recursively iterate over the given LayerNode proto and read the structure
+  // into this node and its children. The |layer_map| should be used to look
+  // for previously existing Layers, since they should be re-used between each
+  // hierarchy update.
+  void FromLayerNodeProto(const proto::LayerNode& proto,
+                          const LayerIdMap& layer_map);
+
   LayerTreeHost* layer_tree_host() { return layer_tree_host_; }
   const LayerTreeHost* layer_tree_host() const { return layer_tree_host_; }
 
   bool AddAnimation(scoped_ptr<Animation> animation);
   void PauseAnimation(int animation_id, double time_offset);
   void RemoveAnimation(int animation_id);
   void RemoveAnimation(int animation_id, Animation::TargetProperty property);
   LayerAnimationController* layer_animation_controller() const {
     return layer_animation_controller_.get();
   }
@@ skipping 342 matching lines @@
 
   std::vector<FrameTimingRequest> frame_timing_requests_;
   bool frame_timing_requests_dirty_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_