Refactor MutatorHostClient from LayerTreeHost to LayerTree.

cc/trees/layer_tree.cc

 // 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.
 
 #include "base/auto_reset.h"
 #include "cc/animation/animation_host.h"
 #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"
+#include "cc/trees/layer_tree_host_common.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() {}
+LayerTree::~LayerTree() {
+  animation_host_->SetMutatorHostClient(nullptr);
+}
 
 void LayerTree::RegisterLayer(Layer* layer) {
   DCHECK(!LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
   layer_id_map_[layer->id()] = layer;
   if (layer->element_id()) {
     animation_host_->RegisterElement(layer->element_id(),
                                      ElementListType::ACTIVE);
   }
 }
@@ skipping 49 matching lines @@
   proto->set_in_paint_layer_contents(in_paint_layer_contents());
 }
 
 void LayerTree::FromProtobuf(const proto::LayerTree& proto) {
   for (auto layer_id : proto.layers_that_should_push_properties()) {
     AddLayerShouldPushProperties(layer_id_map_[layer_id]);
   }
   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::RegisterElement(ElementId element_id,
+                                ElementListType list_type,
+                                Layer* layer) {
+  if (layer->element_id()) {
+    element_layers_map_[layer->element_id()] = layer;
+  }
+
+  animation_host_->RegisterElement(element_id, list_type);
+}
+
+void LayerTree::UnregisterElement(ElementId element_id,
+                                  ElementListType list_type,
+                                  Layer* layer) {
+  animation_host_->UnregisterElement(element_id, list_type);
+
+  if (layer->element_id()) {
+    element_layers_map_.erase(layer->element_id());
+  }
+}
+
+static void SetElementIdForTesting(Layer* layer) {
+  layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
+}
+
+void LayerTree::SetElementIdsForTesting() {
+  LayerTreeHostCommon::CallFunctionForEveryLayer(this, SetElementIdForTesting);
+}
+
+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();
+}
+
+LayerListIterator<Layer> LayerTree::begin() const {
+  return LayerListIterator<Layer>(layer_tree_host_->root_layer());
+}
+
+LayerListIterator<Layer> LayerTree::end() const {
+  return LayerListIterator<Layer>(nullptr);
+}
+
+LayerListReverseIterator<Layer> LayerTree::rbegin() {
+  return LayerListReverseIterator<Layer>(layer_tree_host_->root_layer());
+}
+
+LayerListReverseIterator<Layer> LayerTree::rend() {
+  return LayerListReverseIterator<Layer>(nullptr);
+}
+
+void LayerTree::SetNeedsDisplayOnAllLayers() {
+  for (auto* layer : *this)
+    layer->SetNeedsDisplay();
+}
+
 }  // namespace cc