Refactor MutatorHostClient from LayerTreeHost to LayerTree.

cc/trees/layer_tree.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_TREES_LAYER_TREE_H_
 #define CC_TREES_LAYER_TREE_H_
 
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
+#include "cc/layers/layer_list_iterator.h"
+#include "cc/trees/mutator_host_client.h"
 
 namespace cc {
 
 namespace proto {
 class LayerTree;
 class LayerUpdate;
 }
 
 class AnimationHost;
 class Layer;
+class LayerTreeHost;
 
-class CC_EXPORT LayerTree {
+class CC_EXPORT LayerTree : public MutatorHostClient {
  public:
   using LayerSet = std::unordered_set<Layer*>;
   using LayerIdMap = std::unordered_map<int, Layer*>;
 
-  explicit LayerTree(std::unique_ptr<AnimationHost> animation_host);
+  LayerTree(std::unique_ptr<AnimationHost> animation_host,
+            LayerTreeHost* layer_tree_host);
   ~LayerTree();
 
   void RegisterLayer(Layer* layer);
   void UnregisterLayer(Layer* layer);
   Layer* LayerById(int id) const;
   bool UpdateLayers(const LayerList& update_layer_list,
                     bool* content_is_suitable_for_gpu);
 
   void AddLayerShouldPushProperties(Layer* layer);
   void RemoveLayerShouldPushProperties(Layer* layer);
   std::unordered_set<Layer*>& LayersThatShouldPushProperties();
   bool LayerNeedsPushPropertiesForTesting(Layer* layer) const;
 
   void ToProtobuf(proto::LayerTree* proto);
   void FromProtobuf(const proto::LayerTree& proto);
 
   AnimationHost* animation_host() const { return animation_host_.get(); }
 
   bool in_paint_layer_contents() const { return in_paint_layer_contents_; }
 
+  Layer* LayerByElementId(ElementId element_id) const;
+  void AddToElementMap(Layer* layer);
+  void RemoveFromElementMap(Layer* layer);
+
+  // MutatorHostClient implementation.

[Khushal, 2016/08/15 17:46:39]

Can this be implemented privately instead?

[xingliu, 2016/08/15 21:29:12]

The interface functions are mainly called from cc/animation/. So maybe we can't.

[Khushal, 2016/08/16 05:37:17]

You can still make the implementation here private. AnimationHost accesses it
through the MutatorHostClient interface.

[xingliu, 2016/08/16 16:45:15]

Oh, this is cool, fixed.

+  bool IsElementInList(ElementId element_id,
+                       ElementListType list_type) const override;
+  void SetMutatorsNeedCommit() override;
+  void SetMutatorsNeedRebuildPropertyTrees() override;
+  void SetElementFilterMutated(ElementId element_id,
+                               ElementListType list_type,
+                               const FilterOperations& filters) override;
+  void SetElementOpacityMutated(ElementId element_id,
+                                ElementListType list_type,
+                                float opacity) override;
+  void SetElementTransformMutated(ElementId element_id,
+                                  ElementListType list_type,
+                                  const gfx::Transform& transform) override;
+  void SetElementScrollOffsetMutated(
+      ElementId element_id,
+      ElementListType list_type,
+      const gfx::ScrollOffset& scroll_offset) override;
+  void ElementTransformIsAnimatingChanged(ElementId element_id,
+                                          ElementListType list_type,
+                                          AnimationChangeType change_type,
+                                          bool is_animating) override;
+  void ElementOpacityIsAnimatingChanged(ElementId element_id,
+                                        ElementListType list_type,
+                                        AnimationChangeType change_type,
+                                        bool is_animating) override;
+  void ElementFilterIsAnimatingChanged(ElementId element_id,
+                                       ElementListType list_type,
+                                       AnimationChangeType change_type,
+                                       bool is_animating) override;
+  void ScrollOffsetAnimationFinished() override {}
+  gfx::ScrollOffset GetScrollOffsetForAnimation(
+      ElementId element_id) const override;
+
+  // Layer iterators.
+  LayerListIterator<Layer> begin() const;
+  LayerListIterator<Layer> end() const;
+  LayerListReverseIterator<Layer> rbegin();
+  LayerListReverseIterator<Layer> rend();
+
  private:
   friend class LayerTreeHostSerializationTest;
 
   // Set of layers that need to push properties.
   LayerSet layers_that_should_push_properties_;
 
   // Layer id to Layer map.
   LayerIdMap layer_id_map_;
 
+  using ElementLayersMap = std::unordered_map<ElementId, Layer*, ElementIdHash>;
+  ElementLayersMap element_layers_map_;
+
   bool in_paint_layer_contents_;
 
   std::unique_ptr<AnimationHost> animation_host_;
+  LayerTreeHost* layer_tree_host_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTree);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_H_