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

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>
@@ skipping 51 matching lines @@
 class LayerTreeImpl;
 class LayerTreeSettings;
 class RenderingStatsInstrumentation;
 class ResourceUpdateQueue;
 class ScrollbarLayerInterface;
 class SimpleEnclosedRegion;
 struct AnimationEvent;
 
 namespace proto {
 class LayerNode;
+class LayerProperties;
+class LayerUpdate;
 }  // namespace proto
 
 // 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;
@@ skipping 298 matching lines @@
   // construction of the correct layer on the client.
   void ToLayerNodeProto(proto::LayerNode* proto) const;
 
   // 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);
 
+  // Recursively iterate over this layer and all children to find layers with
+  // changed properties. Layers that have changed properties and layers that
+  // contain children that have changed properties are added to the
+  // proto::LayerUpdate. Only layers with changed properties will contain
+  // properties in the resulting proto::LayerProperties proto. This method also
+  // resets |needs_push_properties_| and |num_dependents_need_push_properties_|.
+  void ToLayerPropertiesProto(proto::LayerUpdate* layer_update);
+
+  // Read all property values from the given LayerProperties object and update
+  // the current layer. The values for |needs_push_properties_| and
+  // |num_dependents_need_push_properties_| are always updated, but the rest
+  // of |proto| is only read if |needs_push_properties_| is set.
+  void FromLayerPropertiesProto(const proto::LayerProperties& proto);
+
   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 182 matching lines @@
   void AddDrawableDescendants(int num);
 
   void AddDependentNeedsPushProperties();
   void RemoveDependentNeedsPushProperties();
   bool parent_should_know_need_push_properties() const {
     return needs_push_properties() || descendant_needs_push_properties();
   }
 
   bool IsPropertyChangeAllowed() const;
 
+  // Serialize all the necessary properties to be able to reconstruct this Layer
+  // into proto::LayerProperties. This function must not set values for
+  // |needs_push_properties_| or |num_dependents_need_push_properties_| as they
+  // are dealt with at a higher level. This is only called if
+  // |needs_push_properties_| is set. For descendants of Layer, implementations
+  // must first call their parent class.
+  virtual void LayerSpecificPropertiesToProto(proto::LayerProperties* proto);
+
+  // Deerialize all the necessary properties from proto::LayerProperties into

[David Trainor- moved to gerrit, 2015/11/11 15:34:22]

Deerialize -> Deserialize

[nyquist, 2015/11/11 18:31:57]

Done.

+  // this Layer. This function must not set values for |needs_push_properties_|
+  // or |num_dependents_need_push_properties_| as they are dealt with at a
+  // higher level. This is only called if |needs_push_properties_| is set. For
+  // descendants of Layer, implementations must first call their parent class.
+  virtual void FromLayerSpecificPropertiesProto(
+      const proto::LayerProperties& proto);
+
   // This flag is set when the layer needs to push properties to the impl
   // side.
   bool needs_push_properties_;
 
   // The number of direct children or dependent layers that need to be recursed
   // to in order for them or a descendent of them to push properties to the impl
   // side.
   int num_dependents_need_push_properties_;
 
   // Tracks whether this layer may have changed stacking order with its
@@ skipping 140 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_