cc/blimp: Add (de)-serialization for PictureLayer and ScrollbarLayer.

cc/blimp/compositor_state_deserializer.h

 // Copyright 2016 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_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_
 #define CC_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_
 
 #include <unordered_map>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
 
 namespace cc {
 namespace proto {
 class LayerNode;
 class LayerProperties;
 class LayerTree;
 class LayerTreeHost;
 }  // namespace proto
 
+class ClientPictureCache;
 class CompositorStateDeserializerClient;
+class DeserializedContentLayerClient;
 class Layer;
 class LayerFactory;
 class LayerTreeHost;
 
 // Deserializes the compositor updates into the LayerTreeHost.
 class CC_EXPORT CompositorStateDeserializer {
  public:
   // ScrollCallback used to notify the client when the scroll offset for a layer
   // is updated.
   using ScrollCallback = base::Callback<void(int engine_layer_id)>;
 
-  CompositorStateDeserializer(LayerTreeHost* layer_tree_host,
-                              ScrollCallback scroll_callback,
-                              CompositorStateDeserializerClient* client);
+  CompositorStateDeserializer(
+      LayerTreeHost* layer_tree_host,
+      std::unique_ptr<ClientPictureCache> client_picture_cache,

[vmpstr, 2016/10/06 18:34:21]

It looks a bit weird that the deserializer takes ownership of the cache. Can you
put a comment on the constructor explaining?

[Khushal, 2016/10/06 20:05:40]

TBH I want to restructure the code to eliminate the cache abstraction, and do
this in a better way in this class itself. For now I was steering clear of
rocking the boat too much and keeping things the old way where LTH used to take
ownership of this. It should be easy to have the caller own it too. So I don't
really have a good explainination for why. :P

+      ScrollCallback scroll_callback,

[vmpstr, 2016/10/06 18:34:21]

const ref

[Khushal, 2016/10/06 20:05:40]

Done.

+      CompositorStateDeserializerClient* client);
   ~CompositorStateDeserializer();
 
   // Returns the local layer on the client for the given |engine_layer_id|.
   Layer* GetLayerForEngineId(int engine_layer_id) const;
 
+  // Returns the local layer id on the client for the given |engine_layer_id|.
+  int GetClientIdFromEngineId(int engine_layer_id) const;

[vmpstr, 2016/10/06 18:34:21]

Is this just GetLayerForEngineId()->id()? (if one exists?). I wonder if we need
two public functions for getting pretty similar information.

[Khushal, 2016/10/06 20:05:40]

Meh. Was just being lazy. Removed.

+
   // Deserializes the |layer_tree_host_proto| into the LayerTreeHost.
   void DeserializeCompositorUpdate(
       const proto::LayerTreeHost& layer_tree_host_proto);
 
   // Allows tests to inject the LayerFactory.
   void SetLayerFactoryForTesting(std::unique_ptr<LayerFactory> layer_factory);
 
  private:
-  using EngineIdToLayerMap = std::unordered_map<int, scoped_refptr<Layer>>;
+  // A holder for the Layer and any data tied to it.
+  struct LayerData {
+    LayerData();
+    ~LayerData();
+
+    scoped_refptr<Layer> layer;
+
+    // Set only for PictureLayers.
+    std::unique_ptr<DeserializedContentLayerClient> content_layer_client;

[vmpstr, 2016/10/06 18:34:21]

Can this just be a member and not a unique_ptr?

[Khushal, 2016/10/06 20:05:40]

Only needed for PictureLayers so I used a unique_ptr.

+  };
+
+  using EngineIdToLayerMap =
+      std::unordered_map<int, std::unique_ptr<LayerData>>;

[vmpstr, 2016/10/06 18:34:21]

Can this be a map of int to LayerData? And maybe you can add a LayerData move
ctor?

[Khushal, 2016/10/06 20:05:40]

Good point. Done.

+  // Map of the scrollbar layer id to the corresponding scroll layer id. Both
+  // ids refer to the engine layer id.
+  using ScrollbarLayerToScrollLayerId = std::unordered_map<int, int>;
 
   void SychronizeLayerTreeState(const proto::LayerTree& layer_tree_proto);
   void SynchronizeLayerState(
       const proto::LayerProperties& layer_properties_proto);
-  void SynchronizeLayerHierarchyRecursive(Layer* layer,
-                                          const proto::LayerNode& layer_node,
-                                          EngineIdToLayerMap* new_layer_map);
+  void SynchronizeLayerHierarchyRecursive(
+      Layer* layer,
+      const proto::LayerNode& layer_node,
+      EngineIdToLayerMap* new_layer_map,
+      ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer);
   scoped_refptr<Layer> GetLayerAndAddToNewMap(
       const proto::LayerNode& layer_node,
-      EngineIdToLayerMap* new_layer_map);
+      EngineIdToLayerMap* new_layer_map,
+      ScrollbarLayerToScrollLayerId* scrollbar_layer_to_scroll_layer);
 
-  int GetClientIdFromEngineId(int engine_layer_id);
-  scoped_refptr<Layer> GetLayer(int engine_layer_id);
+  scoped_refptr<Layer> GetLayer(int engine_layer_id) const;
+  DeserializedContentLayerClient* GetContentLayerClient(
+      int engine_layer_id) const;
 
   std::unique_ptr<LayerFactory> layer_factory_;
+
   LayerTreeHost* layer_tree_host_;
+  std::unique_ptr<ClientPictureCache> client_picture_cache_;
   ScrollCallback scroll_callback_;
   CompositorStateDeserializerClient* client_;
 
   EngineIdToLayerMap engine_id_to_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorStateDeserializer);
 };
 
 }  // namespace cc
 
 #endif  // CC_BLIMP_COMPOSITOR_STATE_DESERIALIZER_H_