Refactor MutatorHostClient from LayerTreeHost to LayerTree.

cc/trees/layer_tree.cc

Index: cc/trees/layer_tree.cc
diff --git a/cc/trees/layer_tree.cc b/cc/trees/layer_tree.cc
index 83537d052e7788d035c974f579a93bf0937ca6b9..21b1409157906edd426a7a40e8f48e722e0785b5 100644
--- a/cc/trees/layer_tree.cc
+++ b/cc/trees/layer_tree.cc
@@ -7,13 +7,18 @@
 #include "cc/layers/layer.h"
 #include "cc/proto/layer_tree.pb.h"
 #include "cc/trees/layer_tree.h"
+#include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
-LayerTree::LayerTree(std::unique_ptr<AnimationHost> animation_host)
+LayerTree::LayerTree(std::unique_ptr<AnimationHost> animation_host,
+                     LayerTreeHost* layer_tree_host)
     : in_paint_layer_contents_(false),
-      animation_host_(std::move(animation_host)) {
+      animation_host_(std::move(animation_host)),
+      layer_tree_host_(layer_tree_host) {
   DCHECK(animation_host_);
+  DCHECK(layer_tree_host_);
+  animation_host_->SetMutatorHostClient(this);
 }
 
 LayerTree::~LayerTree() {}
@@ -86,4 +91,141 @@ void LayerTree::FromProtobuf(const proto::LayerTree& proto) {
   in_paint_layer_contents_ = proto.in_paint_layer_contents();
 }
 
+Layer* LayerTree::LayerByElementId(ElementId element_id) const {
+  ElementLayersMap::const_iterator iter = element_layers_map_.find(element_id);
+  return iter != element_layers_map_.end() ? iter->second : nullptr;
+}
+
+void LayerTree::AddToElementMap(Layer* layer) {
+  if (!layer->element_id())
+    return;
+
+  element_layers_map_[layer->element_id()] = layer;
+}
+
+void LayerTree::RemoveFromElementMap(Layer* layer) {
+  if (!layer->element_id())
+    return;
+
+  element_layers_map_.erase(layer->element_id());
+}
+
+bool LayerTree::IsElementInList(ElementId element_id,
+                                ElementListType list_type) const {
+  return list_type == ElementListType::ACTIVE && LayerByElementId(element_id);
+}
+
+void LayerTree::SetMutatorsNeedCommit() {
+  layer_tree_host_->SetNeedsCommit();
+}
+
+void LayerTree::SetMutatorsNeedRebuildPropertyTrees() {
+  layer_tree_host_->property_trees()->needs_rebuild = true;
+}
+
+void LayerTree::SetElementFilterMutated(ElementId element_id,
+                                        ElementListType list_type,
+                                        const FilterOperations& filters) {
+  Layer* layer = LayerByElementId(element_id);
+  DCHECK(layer);
+  layer->OnFilterAnimated(filters);
+}
+
+void LayerTree::SetElementOpacityMutated(ElementId element_id,
+                                         ElementListType list_type,
+                                         float opacity) {
+  Layer* layer = LayerByElementId(element_id);
+  DCHECK(layer);
+  layer->OnOpacityAnimated(opacity);
+}
+
+void LayerTree::SetElementTransformMutated(ElementId element_id,
+                                           ElementListType list_type,
+                                           const gfx::Transform& transform) {
+  Layer* layer = LayerByElementId(element_id);
+  DCHECK(layer);
+  layer->OnTransformAnimated(transform);
+}
+
+void LayerTree::SetElementScrollOffsetMutated(
+    ElementId element_id,
+    ElementListType list_type,
+    const gfx::ScrollOffset& scroll_offset) {
+  Layer* layer = LayerByElementId(element_id);
+  DCHECK(layer);
+  layer->OnScrollOffsetAnimated(scroll_offset);
+}
+
+void LayerTree::ElementTransformIsAnimatingChanged(
+    ElementId element_id,
+    ElementListType list_type,
+    AnimationChangeType change_type,
+    bool is_animating) {
+  Layer* layer = LayerByElementId(element_id);
+  if (layer) {
+    switch (change_type) {
+      case AnimationChangeType::POTENTIAL:
+        layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::RUNNING:
+        layer->OnTransformIsCurrentlyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::BOTH:
+        layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
+        layer->OnTransformIsCurrentlyAnimatingChanged(is_animating);
+        break;
+    }
+  }
+}
+
+void LayerTree::ElementOpacityIsAnimatingChanged(
+    ElementId element_id,
+    ElementListType list_type,
+    AnimationChangeType change_type,
+    bool is_animating) {
+  Layer* layer = LayerByElementId(element_id);
+  if (layer) {
+    switch (change_type) {
+      case AnimationChangeType::POTENTIAL:
+        layer->OnOpacityIsPotentiallyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::RUNNING:
+        layer->OnOpacityIsCurrentlyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::BOTH:
+        layer->OnOpacityIsPotentiallyAnimatingChanged(is_animating);
+        layer->OnOpacityIsCurrentlyAnimatingChanged(is_animating);
+        break;
+    }
+  }
+}
+
+void LayerTree::ElementFilterIsAnimatingChanged(ElementId element_id,
+                                                ElementListType list_type,
+                                                AnimationChangeType change_type,
+                                                bool is_animating) {
+  Layer* layer = LayerByElementId(element_id);
+  if (layer) {
+    switch (change_type) {
+      case AnimationChangeType::POTENTIAL:
+        layer->OnFilterIsPotentiallyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::RUNNING:
+        layer->OnFilterIsCurrentlyAnimatingChanged(is_animating);
+        break;
+      case AnimationChangeType::BOTH:
+        layer->OnFilterIsPotentiallyAnimatingChanged(is_animating);
+        layer->OnFilterIsCurrentlyAnimatingChanged(is_animating);
+        break;
+    }
+  }
+}
+
+gfx::ScrollOffset LayerTree::GetScrollOffsetForAnimation(
+    ElementId element_id) const {
+  Layer* layer = LayerByElementId(element_id);
+  DCHECK(layer);
+  return layer->ScrollOffsetForAnimation();
+}
+
 }  // namespace cc