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 "cc/trees/layer_tree.h"
 
 #include "base/auto_reset.h"
 #include "base/time/time.h"
 #include "cc/animation/animation_host.h"
 #include "cc/input/page_scale_animation.h"
@@ skipping 48 matching lines @@
 
 LayerTree::LayerTree(std::unique_ptr<AnimationHost> animation_host,
                      LayerTreeHost* layer_tree_host)
     : needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
       in_paint_layer_contents_(false),
       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() {
   animation_host_->SetMutatorHostClient(nullptr);
 
   // We must clear any pointers into the layer tree prior to destroying it.
   RegisterViewportLayers(nullptr, nullptr, nullptr, nullptr);
 
   if (inputs_.root_layer) {
     inputs_.root_layer->SetLayerTreeHost(nullptr);
@@ skipping 444 matching lines @@
   // It is required to create new PropertyTrees before deserializing it.
   property_trees_ = PropertyTrees();
   property_trees_.FromProtobuf(proto.property_trees());
 
   // Forcefully override the sequence number of all layers in the tree to have
   // a valid sequence number. Changing the sequence number for a layer does not
   // need a commit, so the value will become out of date for layers that are not
   // updated for other reasons. All layers that at this point are part of the
   // layer tree are valid, so it is OK that they have a valid sequence number.
   int seq_num = property_trees_.sequence_number;
-  LayerTreeHostCommon::CallFunctionForEveryLayer(
-      layer_tree_host_, [seq_num](Layer* layer) {
-        layer->set_property_tree_sequence_number(seq_num);
-      });
+  LayerTreeHostCommon::CallFunctionForEveryLayer(this, [seq_num](Layer* layer) {
+    layer->set_property_tree_sequence_number(seq_num);
+  });
+}
+
+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() {
+  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>(inputs_.root_layer.get());
+}
+
+LayerListIterator<Layer> LayerTree::end() const {
+  return LayerListIterator<Layer>(nullptr);
+}
+
+LayerListReverseIterator<Layer> LayerTree::rbegin() {
+  return LayerListReverseIterator<Layer>(inputs_.root_layer.get());
+}
+
+LayerListReverseIterator<Layer> LayerTree::rend() {
+  return LayerListReverseIterator<Layer>(nullptr);
+}
+
+void LayerTree::SetNeedsDisplayOnAllLayers() {
+  for (auto* layer : *this)
+    layer->SetNeedsDisplay();
 }
 
 }  // namespace cc