CC Animation: Let MutatorHostClient deals with elements instead of layers.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3759 matching lines @@
 bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
     ScrollNode* scroll_node,
     const gfx::Vector2dF& scroll_delta) {
   return animation_host_->ImplOnlyScrollAnimationUpdateTarget(
       scroll_node->owner_id, scroll_delta,
       active_tree_->property_trees()->scroll_tree.MaxScrollOffset(
           scroll_node->id),
       CurrentBeginFrameArgs().frame_time);
 }
 
-bool LayerTreeHostImpl::IsLayerInTree(int layer_id,
-                                      LayerTreeType tree_type) const {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    return active_tree() ? active_tree()->LayerById(layer_id) != nullptr
+bool LayerTreeHostImpl::IsElementInList(ElementId element_id,
+                                        ElementListType list_type) const {
+  if (list_type == ElementListType::ACTIVE) {
+    return active_tree() ? active_tree()->LayerById(element_id) != nullptr
                          : false;
   } else {
-    if (pending_tree() && pending_tree()->LayerById(layer_id))
+    if (pending_tree() && pending_tree()->LayerById(element_id))
       return true;
-    if (recycle_tree() && recycle_tree()->LayerById(layer_id))
+    if (recycle_tree() && recycle_tree()->LayerById(element_id))
       return true;
 
     return false;
   }
 }
 
 void LayerTreeHostImpl::SetMutatorsNeedCommit() {}
 
 void LayerTreeHostImpl::SetMutatorsNeedRebuildPropertyTrees() {}
 
@@ skipping 54 matching lines @@
   LayerImpl* layer = tree->LayerById(layer_id);
   if (layer)
     layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
 }
 
 bool LayerTreeHostImpl::AnimationsPreserveAxisAlignment(
     const LayerImpl* layer) const {
   return animation_host_->AnimationsPreserveAxisAlignment(layer->id());
 }
 
-void LayerTreeHostImpl::SetLayerFilterMutated(int layer_id,
-                                              LayerTreeType tree_type,
-                                              const FilterOperations& filters) {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    SetTreeLayerFilterMutated(layer_id, active_tree(), filters);
+void LayerTreeHostImpl::SetElementFilterMutated(
+    ElementId element_id,
+    ElementListType list_type,
+    const FilterOperations& filters) {
+  if (list_type == ElementListType::ACTIVE) {
+    SetTreeLayerFilterMutated(element_id, active_tree(), filters);
   } else {
-    SetTreeLayerFilterMutated(layer_id, pending_tree(), filters);
-    SetTreeLayerFilterMutated(layer_id, recycle_tree(), filters);
+    SetTreeLayerFilterMutated(element_id, pending_tree(), filters);
+    SetTreeLayerFilterMutated(element_id, recycle_tree(), filters);
   }
 }
 
-void LayerTreeHostImpl::SetLayerOpacityMutated(int layer_id,
-                                               LayerTreeType tree_type,
-                                               float opacity) {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    SetTreeLayerOpacityMutated(layer_id, active_tree(), opacity);
+void LayerTreeHostImpl::SetElementOpacityMutated(ElementId element_id,
+                                                 ElementListType list_type,
+                                                 float opacity) {
+  if (list_type == ElementListType::ACTIVE) {
+    SetTreeLayerOpacityMutated(element_id, active_tree(), opacity);
   } else {
-    SetTreeLayerOpacityMutated(layer_id, pending_tree(), opacity);
-    SetTreeLayerOpacityMutated(layer_id, recycle_tree(), opacity);
+    SetTreeLayerOpacityMutated(element_id, pending_tree(), opacity);
+    SetTreeLayerOpacityMutated(element_id, recycle_tree(), opacity);
   }
 }
 
-void LayerTreeHostImpl::SetLayerTransformMutated(
-    int layer_id,
-    LayerTreeType tree_type,
+void LayerTreeHostImpl::SetElementTransformMutated(
+    ElementId element_id,
+    ElementListType list_type,
     const gfx::Transform& transform) {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    SetTreeLayerTransformMutated(layer_id, active_tree(), transform);
+  if (list_type == ElementListType::ACTIVE) {
+    SetTreeLayerTransformMutated(element_id, active_tree(), transform);
   } else {
-    SetTreeLayerTransformMutated(layer_id, pending_tree(), transform);
-    SetTreeLayerTransformMutated(layer_id, recycle_tree(), transform);
+    SetTreeLayerTransformMutated(element_id, pending_tree(), transform);
+    SetTreeLayerTransformMutated(element_id, recycle_tree(), transform);
   }
 }
 
-void LayerTreeHostImpl::SetLayerScrollOffsetMutated(
-    int layer_id,
-    LayerTreeType tree_type,
+void LayerTreeHostImpl::SetElementScrollOffsetMutated(
+    ElementId element_id,
+    ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    SetTreeLayerScrollOffsetMutated(layer_id, active_tree(), scroll_offset);
+  if (list_type == ElementListType::ACTIVE) {
+    SetTreeLayerScrollOffsetMutated(element_id, active_tree(), scroll_offset);
   } else {
-    SetTreeLayerScrollOffsetMutated(layer_id, pending_tree(), scroll_offset);
-    SetTreeLayerScrollOffsetMutated(layer_id, recycle_tree(), scroll_offset);
+    SetTreeLayerScrollOffsetMutated(element_id, pending_tree(), scroll_offset);
+    SetTreeLayerScrollOffsetMutated(element_id, recycle_tree(), scroll_offset);
   }
 }
 
-void LayerTreeHostImpl::LayerTransformIsPotentiallyAnimatingChanged(
-    int layer_id,
-    LayerTreeType tree_type,
+void LayerTreeHostImpl::ElementTransformIsPotentiallyAnimatingChanged(
+    ElementId element_id,
+    ElementListType list_type,
     bool is_animating) {
-  if (tree_type == LayerTreeType::ACTIVE) {
-    TreeLayerTransformIsPotentiallyAnimatingChanged(layer_id, active_tree(),
+  if (list_type == ElementListType::ACTIVE) {
+    TreeLayerTransformIsPotentiallyAnimatingChanged(element_id, active_tree(),
                                                     is_animating);
   } else {
-    TreeLayerTransformIsPotentiallyAnimatingChanged(layer_id, pending_tree(),
+    TreeLayerTransformIsPotentiallyAnimatingChanged(element_id, pending_tree(),
                                                     is_animating);
   }
 }
 
 void LayerTreeHostImpl::ScrollOffsetAnimationFinished() {
   // TODO(majidvp): We should pass in the original starting scroll position here
   ScrollStateData scroll_state_data;
   ScrollState scroll_state(scroll_state_data);
   ScrollEnd(&scroll_state);
 }
 
 gfx::ScrollOffset LayerTreeHostImpl::GetScrollOffsetForAnimation(
-    int layer_id) const {
+    ElementId element_id) const {
   if (active_tree()) {
-    LayerImpl* layer = active_tree()->LayerById(layer_id);
+    LayerImpl* layer = active_tree()->LayerById(element_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 bool LayerTreeHostImpl::SupportsImplScrolling() const {
   // Supported in threaded mode.
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc