Use element id's for animations

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 2790 matching lines @@
     scroll_tree.ScrollBy(scroll_node, delta, active_tree());
     return false;
   }
 
   scroll_tree.set_currently_scrolling_node(scroll_node->id);
 
   gfx::ScrollOffset current_offset =
       scroll_tree.current_scroll_offset(scroll_node->owner_id);
   gfx::ScrollOffset target_offset = scroll_tree.ClampScrollOffsetToLimits(
       current_offset + gfx::ScrollOffset(delta), scroll_node);
-  animation_host_->ImplOnlyScrollAnimationCreate(scroll_node->owner_id,
+  DCHECK_EQ(
+      ElementId(active_tree()->LayerById(scroll_node->owner_id)->element_id()),
+      scroll_node->data.element_id);
+
+  animation_host_->ImplOnlyScrollAnimationCreate(scroll_node->data.element_id,
                                                  target_offset, current_offset);
 
   SetNeedsOneBeginImplFrame();
 
   return true;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
@@ skipping 1005 matching lines @@
       active_tree_->max_page_scale_factor());
 }
 
 void LayerTreeHostImpl::ScrollAnimationAbort(LayerImpl* layer_impl) {
   return animation_host_->ScrollAnimationAbort(false /* needs_completion */);
 }
 
 bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
     ScrollNode* scroll_node,
     const gfx::Vector2dF& scroll_delta) {
+  DCHECK_EQ(
+      ElementId(active_tree()->LayerById(scroll_node->owner_id)->element_id()),
+      scroll_node->data.element_id);
+
   return animation_host_->ImplOnlyScrollAnimationUpdateTarget(
-      scroll_node->owner_id, scroll_delta,
+      scroll_node->data.element_id, scroll_delta,
       active_tree_->property_trees()->scroll_tree.MaxScrollOffset(
           scroll_node->id),
       CurrentBeginFrameArgs().frame_time);
 }
 
 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;
+    return active_tree()
+               ? active_tree()->LayerByElementId(element_id) != nullptr
+               : false;
   } else {
-    if (pending_tree() && pending_tree()->LayerById(element_id))
+    if (pending_tree() && pending_tree()->LayerByElementId(element_id))
       return true;
-    if (recycle_tree() && recycle_tree()->LayerById(element_id))
+    if (recycle_tree() && recycle_tree()->LayerByElementId(element_id))
       return true;
 
     return false;
   }
 }
 
 void LayerTreeHostImpl::SetMutatorsNeedCommit() {}
 
 void LayerTreeHostImpl::SetMutatorsNeedRebuildPropertyTrees() {}
 
 void LayerTreeHostImpl::SetTreeLayerFilterMutated(
-    int layer_id,
+    ElementId element_id,
     LayerTreeImpl* tree,
     const FilterOperations& filters) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerById(layer_id);
+  LayerImpl* layer = tree->LayerByElementId(element_id);
   if (layer)
     layer->OnFilterAnimated(filters);
 }
 
-void LayerTreeHostImpl::SetTreeLayerOpacityMutated(int layer_id,
+void LayerTreeHostImpl::SetTreeLayerOpacityMutated(ElementId element_id,
                                                    LayerTreeImpl* tree,
                                                    float opacity) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerById(layer_id);
+  LayerImpl* layer = tree->LayerByElementId(element_id);
   if (layer)
     layer->OnOpacityAnimated(opacity);
 }
 
 void LayerTreeHostImpl::SetTreeLayerTransformMutated(
-    int layer_id,
+    ElementId element_id,
     LayerTreeImpl* tree,
     const gfx::Transform& transform) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerById(layer_id);
+  LayerImpl* layer = tree->LayerByElementId(element_id);
   if (layer)
     layer->OnTransformAnimated(transform);
 }
 
 void LayerTreeHostImpl::SetTreeLayerScrollOffsetMutated(
-    int layer_id,
+    ElementId element_id,
     LayerTreeImpl* tree,
     const gfx::ScrollOffset& scroll_offset) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerById(layer_id);
+  LayerImpl* layer = tree->LayerByElementId(element_id);
   if (layer) {
     layer->OnScrollOffsetAnimated(scroll_offset);
     // Run mutation callbacks to respond to updated scroll offset.
     Mutate(CurrentBeginFrameArgs().frame_time);
   }
 }
 
 bool LayerTreeHostImpl::AnimationsPreserveAxisAlignment(
     const LayerImpl* layer) const {
-  return animation_host_->AnimationsPreserveAxisAlignment(layer->id());
+  return animation_host_->AnimationsPreserveAxisAlignment(layer->element_id());
 }
 
 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(element_id, pending_tree(), filters);
@@ skipping 38 matching lines @@
 
 void LayerTreeHostImpl::ElementTransformIsAnimatingChanged(
     ElementId element_id,
     ElementListType list_type,
     AnimationChangeType change_type,
     bool is_animating) {
   LayerTreeImpl* tree =
       list_type == ElementListType::ACTIVE ? active_tree() : pending_tree();
   if (!tree)
     return;
-  LayerImpl* layer = tree->LayerById(element_id);
+  LayerImpl* layer = tree->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 LayerTreeHostImpl::ElementOpacityIsAnimatingChanged(
     ElementId element_id,
     ElementListType list_type,
     AnimationChangeType change_type,
     bool is_animating) {
   LayerTreeImpl* tree =
       list_type == ElementListType::ACTIVE ? active_tree() : pending_tree();
   if (!tree)
     return;
-  LayerImpl* layer = tree->LayerById(element_id);
+  LayerImpl* layer = tree->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 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(
     ElementId element_id) const {
   if (active_tree()) {
-    LayerImpl* layer = active_tree()->LayerById(element_id);
+    LayerImpl* layer = active_tree()->LayerByElementId(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();
 }
 
 bool LayerTreeHostImpl::HasFixedRasterScalePotentialPerformanceRegression()
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc