CC Animation: Start replacing int layer_id with ElementId element_id.

cc/animation/element_animations.cc

 // Copyright 2015 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/animation/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 10 matching lines @@
 
 namespace cc {
 
 scoped_refptr<ElementAnimations> ElementAnimations::Create() {
   return make_scoped_refptr(new ElementAnimations());
 }
 
 ElementAnimations::ElementAnimations()
     : players_list_(new PlayersList()),
       animation_host_(),
-      layer_id_(),
+      element_id_(),
       is_active_(false),
       has_element_in_active_list_(false),
       has_element_in_pending_list_(false),
       needs_to_start_animations_(false),
       scroll_offset_animation_was_interrupted_(false),
       potentially_animating_transform_for_active_elements_(false),
       potentially_animating_transform_for_pending_elements_(false) {}
 
 ElementAnimations::~ElementAnimations() {}
 
 void ElementAnimations::SetAnimationHost(AnimationHost* host) {
   animation_host_ = host;
 }
 
-void ElementAnimations::SetLayerId(int layer_id) {
-  layer_id_ = layer_id;
+void ElementAnimations::SetElementId(ElementId element_id) {
+  element_id_ = element_id;
 }
 
 void ElementAnimations::InitAffectedElementTypes() {
-  DCHECK(layer_id_);
+  DCHECK(element_id_);
   DCHECK(animation_host_);
 
   UpdateActivation(FORCE_ACTIVATION);
 
   DCHECK(animation_host_->mutator_host_client());
   if (animation_host_->mutator_host_client()->IsLayerInTree(
-          layer_id_, LayerTreeType::ACTIVE)) {
+          element_id_, LayerTreeType::ACTIVE)) {
     set_has_element_in_active_list(true);
   }
   if (animation_host_->mutator_host_client()->IsLayerInTree(
-          layer_id_, LayerTreeType::PENDING)) {
+          element_id_, LayerTreeType::PENDING)) {
     set_has_element_in_pending_list(true);
   }
 }
 
 void ElementAnimations::ClearAffectedElementTypes() {
   DCHECK(animation_host_);
 
   if (has_element_in_active_list())
     OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::ACTIVE, false);
   set_has_element_in_active_list(false);
 
   if (has_element_in_pending_list())
     OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::PENDING, false);
   set_has_element_in_pending_list(false);
 
   animation_host_->DidDeactivateElementAnimations(this);
   UpdateActivation(FORCE_ACTIVATION);
 }
 
-void ElementAnimations::LayerRegistered(int layer_id, LayerTreeType tree_type) {
-  DCHECK_EQ(layer_id_, layer_id);
+void ElementAnimations::LayerRegistered(ElementId element_id,
+                                        LayerTreeType tree_type) {
+  DCHECK_EQ(element_id_, element_id);
 
   if (tree_type == LayerTreeType::ACTIVE)
     set_has_element_in_active_list(true);
   else
     set_has_element_in_pending_list(true);
 }
 
-void ElementAnimations::LayerUnregistered(int layer_id,
+void ElementAnimations::LayerUnregistered(ElementId element_id,
                                           LayerTreeType tree_type) {
-  DCHECK_EQ(this->layer_id(), layer_id);
+  DCHECK_EQ(this->element_id(), element_id);
   if (tree_type == LayerTreeType::ACTIVE)
     set_has_element_in_active_list(false);
   else
     set_has_element_in_pending_list(false);
 }
 
 void ElementAnimations::AddPlayer(AnimationPlayer* player) {
   players_list_->Append(player);
 }
 
@@ skipping 62 matching lines @@
     if (!animation->is_impl_only())
       continue;
 
     if (!animation->InEffect(monotonic_time))
       continue;
 
     base::TimeDelta trimmed =
         animation->TrimTimeToCurrentIteration(monotonic_time);
     switch (animation->target_property()) {
       case TargetProperty::OPACITY: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, layer_id_,
+        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
                              animation->group(), TargetProperty::OPACITY,
                              monotonic_time);
         const FloatAnimationCurve* float_animation_curve =
             animation->curve()->ToFloatAnimationCurve();
         event.opacity = float_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
       case TargetProperty::TRANSFORM: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, layer_id_,
+        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
                              animation->group(), TargetProperty::TRANSFORM,
                              monotonic_time);
         const TransformAnimationCurve* transform_animation_curve =
             animation->curve()->ToTransformAnimationCurve();
         event.transform = transform_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
       case TargetProperty::FILTER: {
-        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, layer_id_,
+        AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, element_id_,
                              animation->group(), TargetProperty::FILTER,
                              monotonic_time);
         const FilterAnimationCurve* filter_animation_curve =
             animation->curve()->ToFilterAnimationCurve();
         event.filters = filter_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->events_.push_back(event);
         break;
       }
 
@@ skipping 530 matching lines @@
       if (!animations_[i]->has_set_start_time() &&
           !animations_[i]->needs_synchronized_start_time())
         animations_[i]->set_start_time(monotonic_time);
       if (events) {
         base::TimeTicks start_time;
         if (animations_[i]->has_set_start_time())
           start_time = animations_[i]->start_time();
         else
           start_time = monotonic_time;
         AnimationEvent started_event(
-            AnimationEvent::STARTED, layer_id_, animations_[i]->group(),
+            AnimationEvent::STARTED, element_id_, animations_[i]->group(),
             animations_[i]->target_property(), start_time);
         started_event.is_impl_only = animations_[i]->is_impl_only();
         if (started_event.is_impl_only)
           NotifyAnimationStarted(started_event);
         else
           events->events_.push_back(started_event);
       }
     }
   }
 }
@@ skipping 22 matching lines @@
   animations_with_same_group_id.reserve(animations_.size());
   // Non-aborted animations are marked for deletion after a corresponding
   // AnimationEvent::FINISHED event is sent or received. This means that if
   // we don't have an events vector, we must ensure that non-aborted animations
   // have received a finished event before marking them for deletion.
   for (size_t i = 0; i < animations_.size(); i++) {
     int group_id = animations_[i]->group();
     if (animations_[i]->run_state() == Animation::ABORTED) {
       if (events && !animations_[i]->is_impl_only()) {
         AnimationEvent aborted_event(
-            AnimationEvent::ABORTED, layer_id_, group_id,
+            AnimationEvent::ABORTED, element_id_, group_id,
             animations_[i]->target_property(), monotonic_time);
         events->events_.push_back(aborted_event);
       }
       // If on the compositor or on the main thread and received finish event,
       // animation can be marked for deletion.
       if (events || animations_[i]->received_finished_event()) {
         animations_[i]->SetRunState(Animation::WAITING_FOR_DELETION,
                                     monotonic_time);
         marked_animations_for_deletions = true;
       }
       continue;
     }
 
     // If running on the compositor and need to complete an aborted animation
     // on the main thread.
     if (events &&
         animations_[i]->run_state() ==
             Animation::ABORTED_BUT_NEEDS_COMPLETION) {
-      AnimationEvent aborted_event(AnimationEvent::TAKEOVER, layer_id_,
+      AnimationEvent aborted_event(AnimationEvent::TAKEOVER, element_id_,
                                    group_id, animations_[i]->target_property(),
                                    monotonic_time);
       aborted_event.animation_start_time =
           (animations_[i]->start_time() - base::TimeTicks()).InSecondsF();
       const ScrollOffsetAnimationCurve* scroll_offset_animation_curve =
           animations_[i]->curve()->ToScrollOffsetAnimationCurve();
       aborted_event.curve = scroll_offset_animation_curve->Clone();
       // Notify the compositor that the animation is finished.
       NotifyPlayersAnimationFinished(aborted_event.monotonic_time,
                                      aborted_event.target_property,
@@ skipping 50 matching lines @@
       }
     }
     if (all_anims_with_same_id_are_finished) {
       // We now need to remove all animations with the same group id as
       // group_id (and send along animation finished notifications, if
       // necessary).
       for (size_t j = 0; j < animations_with_same_group_id.size(); j++) {
         size_t animation_index = animations_with_same_group_id[j];
         if (events) {
           AnimationEvent finished_event(
-              AnimationEvent::FINISHED, layer_id_,
+              AnimationEvent::FINISHED, element_id_,
               animations_[animation_index]->group(),
               animations_[animation_index]->target_property(), monotonic_time);
           finished_event.is_impl_only =
               animations_[animation_index]->is_impl_only();
           if (finished_event.is_impl_only)
             NotifyAnimationFinished(finished_event);
           else
             events->events_.push_back(finished_event);
         }
         animations_[animation_index]->SetRunState(
@@ skipping 341 matching lines @@
 
 Animation* ElementAnimations::GetAnimationById(int animation_id) const {
   for (size_t i = 0; i < animations_.size(); ++i)
     if (animations_[i]->id() == animation_id)
       return animations_[i].get();
   return nullptr;
 }
 
 void ElementAnimations::OnFilterAnimated(LayerTreeType tree_type,
                                          const FilterOperations& filters) {
-  DCHECK(layer_id());
+  DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetLayerFilterMutated(
-      layer_id(), tree_type, filters);
+      element_id(), tree_type, filters);
 }
 
 void ElementAnimations::OnOpacityAnimated(LayerTreeType tree_type,
                                           float opacity) {
-  DCHECK(layer_id());
+  DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetLayerOpacityMutated(
-      layer_id(), tree_type, opacity);
+      element_id(), tree_type, opacity);
 }
 
 void ElementAnimations::OnTransformAnimated(LayerTreeType tree_type,
                                             const gfx::Transform& transform) {
-  DCHECK(layer_id());
+  DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetLayerTransformMutated(
-      layer_id(), tree_type, transform);
+      element_id(), tree_type, transform);
 }
 
 void ElementAnimations::OnScrollOffsetAnimated(
     LayerTreeType tree_type,
     const gfx::ScrollOffset& scroll_offset) {
-  DCHECK(layer_id());
+  DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()->mutator_host_client()->SetLayerScrollOffsetMutated(
-      layer_id(), tree_type, scroll_offset);
+      element_id(), tree_type, scroll_offset);
 }
 
 void ElementAnimations::OnAnimationWaitingForDeletion() {
   // TODO(loyso): Invalidate AnimationHost::SetNeedsPushProperties here.
   // But we always do PushProperties in AnimationHost for now. crbug.com/604280
   DCHECK(animation_host());
   animation_host()->OnAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::OnTransformIsPotentiallyAnimatingChanged(
     LayerTreeType tree_type,
     bool is_animating) {
-  DCHECK(layer_id());
+  DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()
       ->mutator_host_client()
-      ->LayerTransformIsPotentiallyAnimatingChanged(layer_id(), tree_type,
+      ->LayerTransformIsPotentiallyAnimatingChanged(element_id(), tree_type,
                                                     is_animating);
 }
 
 void ElementAnimations::NotifyPlayersAnimationStarted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   for (PlayersListNode* node = players_list_->head();
        node != players_list_->end(); node = node->next()) {
     AnimationPlayer* player = node->value();
@@ skipping 36 matching lines @@
     player->NotifyAnimationTakeover(monotonic_time, target_property,
                                     animation_start_time,
                                     std::move(animation_curve));
   }
 }
 
 gfx::ScrollOffset ElementAnimations::ScrollOffsetForAnimation() const {
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
-        layer_id());
+        element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc