CC Animation: Use ElementId to attach CC animation players.

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 89e1ebb179cce05fffe452724bca7143f55ae8a7..063171b983a3026c52d05f6d728e032e3b22852b 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -2759,7 +2759,10 @@ bool LayerTreeHostImpl::ScrollAnimationCreate(ScrollNode* scroll_node,
       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,
+  LayerImpl* owner = active_tree_->LayerById(scroll_node->owner_id);
+  DCHECK(owner);
+  DCHECK(owner->element_id());
+  animation_host_->ImplOnlyScrollAnimationCreate(owner->element_id(),
                                                  target_offset, current_offset);
 
   SetNeedsOneBeginImplFrame();
@@ -3782,8 +3785,11 @@ void LayerTreeHostImpl::ScrollAnimationAbort(LayerImpl* layer_impl) {
 bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
     ScrollNode* scroll_node,
     const gfx::Vector2dF& scroll_delta) {
+  LayerImpl* owner = active_tree_->LayerById(scroll_node->owner_id);
+  DCHECK(owner);
+  DCHECK(owner->element_id());
   return animation_host_->ImplOnlyScrollAnimationUpdateTarget(
-      scroll_node->owner_id, scroll_delta,
+      owner->element_id(), scroll_delta,
       active_tree_->property_trees()->scroll_tree.MaxScrollOffset(
           scroll_node->id),
       CurrentBeginFrameArgs().frame_time);
@@ -3792,12 +3798,11 @@ bool LayerTreeHostImpl::ScrollAnimationUpdateTarget(
 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()->HasAnyLayerForElementId(element_id);
   } else {
-    if (pending_tree() && pending_tree()->LayerById(element_id))
+    if (pending_tree() && pending_tree()->HasAnyLayerForElementId(element_id))
       return true;
-    if (recycle_tree() && recycle_tree()->LayerById(element_id))
+    if (recycle_tree() && recycle_tree()->HasAnyLayerForElementId(element_id))
       return true;
 
     return false;
@@ -3809,67 +3814,67 @@ 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->LayerForElementId(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->LayerForElementId(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->LayerForElementId(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->ScrollLayerForElementId(element_id);
   if (layer)
     layer->OnScrollOffsetAnimated(scroll_offset);
 }
 
 void LayerTreeHostImpl::TreeLayerTransformIsPotentiallyAnimatingChanged(
-    int layer_id,
+    ElementId element_id,
     LayerTreeImpl* tree,
     bool is_animating) {
   if (!tree)
     return;
 
-  LayerImpl* layer = tree->LayerById(layer_id);
+  LayerImpl* layer = tree->LayerForElementId(element_id);
   if (layer)
     layer->OnTransformIsPotentiallyAnimatingChanged(is_animating);
 }
 
 bool LayerTreeHostImpl::AnimationsPreserveAxisAlignment(
     const LayerImpl* layer) const {
-  return animation_host_->AnimationsPreserveAxisAlignment(layer->id());
+  return animation_host_->AnimationsPreserveAxisAlignment(layer->element_id());
 }
 
 void LayerTreeHostImpl::SetElementFilterMutated(
@@ -3942,7 +3947,7 @@ void LayerTreeHostImpl::ScrollOffsetAnimationFinished() {
 gfx::ScrollOffset LayerTreeHostImpl::GetScrollOffsetForAnimation(
     ElementId element_id) const {
   if (active_tree()) {
-    LayerImpl* layer = active_tree()->LayerById(element_id);
+    LayerImpl* layer = active_tree()->ScrollLayerForElementId(element_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }