CC Animation: Start replacing int layer_id with ElementId element_id.

cc/animation/animation_host.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/animation_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
-#include "cc/trees/mutator_host_client.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 
 namespace cc {
 
 class AnimationHost::ScrollOffsetAnimations : public AnimationDelegate {
  public:
   explicit ScrollOffsetAnimations(AnimationHost* animation_host)
       : animation_host_(animation_host),
         scroll_offset_timeline_(
             AnimationTimeline::Create(AnimationIdProvider::NextTimelineId())),
         scroll_offset_animation_player_(
             AnimationPlayer::Create(AnimationIdProvider::NextPlayerId())) {
     scroll_offset_timeline_->set_is_impl_only(true);
     scroll_offset_animation_player_->set_layer_animation_delegate(this);
 
     animation_host_->AddAnimationTimeline(scroll_offset_timeline_.get());
     scroll_offset_timeline_->AttachPlayer(
         scroll_offset_animation_player_.get());
   }
 
   ~ScrollOffsetAnimations() override {
     scroll_offset_timeline_->DetachPlayer(
         scroll_offset_animation_player_.get());
     animation_host_->RemoveAnimationTimeline(scroll_offset_timeline_.get());
   }
 
-  void ScrollAnimationCreate(int layer_id,
+  void ScrollAnimationCreate(ElementId element_id,
                              const gfx::ScrollOffset& target_offset,
                              const gfx::ScrollOffset& current_offset) {
     std::unique_ptr<ScrollOffsetAnimationCurve> curve =
         ScrollOffsetAnimationCurve::Create(
             target_offset, EaseInOutTimingFunction::Create(),
             ScrollOffsetAnimationCurve::DurationBehavior::INVERSE_DELTA);
     curve->SetInitialValue(current_offset);
 
     std::unique_ptr<Animation> animation = Animation::Create(
         std::move(curve), AnimationIdProvider::NextAnimationId(),
         AnimationIdProvider::NextGroupId(), TargetProperty::SCROLL_OFFSET);
     animation->set_is_impl_only(true);
 
     DCHECK(scroll_offset_animation_player_);
     DCHECK(scroll_offset_animation_player_->animation_timeline());
 
-    ReattachScrollOffsetPlayerIfNeeded(layer_id);
+    ReattachScrollOffsetPlayerIfNeeded(element_id);
 
     scroll_offset_animation_player_->AddAnimation(std::move(animation));
   }
 
-  bool ScrollAnimationUpdateTarget(int layer_id,
+  bool ScrollAnimationUpdateTarget(ElementId element_id,
                                    const gfx::Vector2dF& scroll_delta,
                                    const gfx::ScrollOffset& max_scroll_offset,
                                    base::TimeTicks frame_monotonic_time) {
     DCHECK(scroll_offset_animation_player_);
     if (!scroll_offset_animation_player_->element_animations())
       return false;
 
-    DCHECK_EQ(layer_id, scroll_offset_animation_player_->layer_id());
+    DCHECK_EQ(element_id, scroll_offset_animation_player_->element_id());
 
     Animation* animation = scroll_offset_animation_player_->element_animations()
                                ->GetAnimation(TargetProperty::SCROLL_OFFSET);
     if (!animation) {
       scroll_offset_animation_player_->DetachLayer();
       return false;
     }
 
     ScrollOffsetAnimationCurve* curve =
         animation->curve()->ToScrollOffsetAnimationCurve();
@@ skipping 30 matching lines @@
   void NotifyAnimationAborted(base::TimeTicks monotonic_time,
                               TargetProperty::Type target_property,
                               int group) override {}
   void NotifyAnimationTakeover(base::TimeTicks monotonic_time,
                                TargetProperty::Type target_property,
                                double animation_start_time,
                                std::unique_ptr<AnimationCurve> curve) override {
   }
 
  private:
-  void ReattachScrollOffsetPlayerIfNeeded(int layer_id) {
-    if (scroll_offset_animation_player_->layer_id() != layer_id) {
-      if (scroll_offset_animation_player_->layer_id())
+  void ReattachScrollOffsetPlayerIfNeeded(ElementId element_id) {
+    if (scroll_offset_animation_player_->element_id() != element_id) {
+      if (scroll_offset_animation_player_->element_id())
         scroll_offset_animation_player_->DetachLayer();
-      if (layer_id)
-        scroll_offset_animation_player_->AttachLayer(layer_id);
+      if (element_id)
+        scroll_offset_animation_player_->AttachLayer(element_id);
     }
   }
 
   AnimationHost* animation_host_;
   scoped_refptr<AnimationTimeline> scroll_offset_timeline_;
 
   // We have just one player for impl-only scroll offset animations.
   // I.e. only one layer can have an impl-only scroll offset animation at
   // any given time.
   scoped_refptr<AnimationPlayer> scroll_offset_animation_player_;
@@ skipping 48 matching lines @@
       std::make_pair(timeline->id(), std::move(timeline)));
 }
 
 void AnimationHost::RemoveAnimationTimeline(
     scoped_refptr<AnimationTimeline> timeline) {
   DCHECK(timeline->id());
   EraseTimeline(timeline);
   id_to_timeline_map_.erase(timeline->id());
 }
 
-void AnimationHost::RegisterLayer(int layer_id, LayerTreeType tree_type) {
+void AnimationHost::RegisterLayer(ElementId element_id,
+                                  LayerTreeType tree_type) {
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(layer_id);
+      GetElementAnimationsForLayerId(element_id);
   if (element_animations)
-    element_animations->LayerRegistered(layer_id, tree_type);
+    element_animations->LayerRegistered(element_id, tree_type);
 }
 
-void AnimationHost::UnregisterLayer(int layer_id, LayerTreeType tree_type) {
+void AnimationHost::UnregisterLayer(ElementId element_id,
+                                    LayerTreeType tree_type) {
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(layer_id);
+      GetElementAnimationsForLayerId(element_id);
   if (element_animations)
-    element_animations->LayerUnregistered(layer_id, tree_type);
+    element_animations->LayerUnregistered(element_id, tree_type);
 }
 
-void AnimationHost::RegisterPlayerForLayer(int layer_id,
+void AnimationHost::RegisterPlayerForLayer(ElementId element_id,
                                            AnimationPlayer* player) {
-  DCHECK(layer_id);
+  DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(layer_id);
+      GetElementAnimationsForLayerId(element_id);
   if (!element_animations) {
     element_animations = ElementAnimations::Create();
-    element_animations->SetLayerId(layer_id);
+    element_animations->SetElementId(element_id);
     RegisterElementAnimations(element_animations.get());
   }
 
   if (element_animations->animation_host() != this) {
     element_animations->SetAnimationHost(this);
     element_animations->InitAffectedElementTypes();
   }
 
   element_animations->AddPlayer(player);
 }
 
-void AnimationHost::UnregisterPlayerForLayer(int layer_id,
+void AnimationHost::UnregisterPlayerForLayer(ElementId element_id,
                                              AnimationPlayer* player) {
-  DCHECK(layer_id);
+  DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(layer_id);
+      GetElementAnimationsForLayerId(element_id);
   DCHECK(element_animations);
   element_animations->RemovePlayer(player);
 
   if (element_animations->IsEmpty()) {
     element_animations->ClearAffectedElementTypes();
     UnregisterElementAnimations(element_animations.get());
     element_animations->SetAnimationHost(nullptr);
   }
 }
 
@@ skipping 64 matching lines @@
   for (auto& kv : layer_to_element_animations_map_) {
     const auto& element_animations = kv.second;
     auto element_animations_impl =
         host_impl->GetElementAnimationsForLayerId(kv.first);
     if (element_animations_impl)
       element_animations->PushPropertiesTo(std::move(element_animations_impl));
   }
 }
 
 scoped_refptr<ElementAnimations> AnimationHost::GetElementAnimationsForLayerId(
-    int layer_id) const {
-  DCHECK(layer_id);
-  auto iter = layer_to_element_animations_map_.find(layer_id);
+    ElementId element_id) const {
+  DCHECK(element_id);
+  auto iter = layer_to_element_animations_map_.find(element_id);
   return iter == layer_to_element_animations_map_.end() ? nullptr
                                                         : iter->second;
 }
 
 void AnimationHost::SetSupportsScrollAnimations(
     bool supports_scroll_animations) {
   supports_scroll_animations_ = supports_scroll_animations;
 }
 
 bool AnimationHost::SupportsScrollAnimations() const {
@@ skipping 45 matching lines @@
 }
 
 std::unique_ptr<AnimationEvents> AnimationHost::CreateEvents() {
   return base::WrapUnique(new AnimationEvents());
 }
 
 void AnimationHost::SetAnimationEvents(
     std::unique_ptr<AnimationEvents> events) {
   for (size_t event_index = 0; event_index < events->events_.size();
        ++event_index) {
-    int event_layer_id = events->events_[event_index].layer_id;
+    int event_layer_id = events->events_[event_index].element_id;
 
     // Use the map of all ElementAnimations, not just active ones, since
     // non-active ElementAnimations may still receive events for impl-only
     // animations.
     const LayerToElementAnimationsMap& all_element_animations =
         layer_to_element_animations_map_;
     auto iter = all_element_animations.find(event_layer_id);
     if (iter != all_element_animations.end()) {
       switch (events->events_[event_index].type) {
         case AnimationEvent::STARTED:
@@ skipping 14 matching lines @@
           break;
 
         case AnimationEvent::TAKEOVER:
           (*iter).second->NotifyAnimationTakeover(events->events_[event_index]);
           break;
       }
     }
   }
 }
 
-bool AnimationHost::ScrollOffsetAnimationWasInterrupted(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::ScrollOffsetAnimationWasInterrupted(
+    ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->scroll_offset_animation_was_interrupted()
              : false;
 }
 
-bool AnimationHost::IsAnimatingFilterProperty(int layer_id,
+bool AnimationHost::IsAnimatingFilterProperty(ElementId element_id,
                                               LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
                    TargetProperty::FILTER, tree_type)
              : false;
 }
 
-bool AnimationHost::IsAnimatingOpacityProperty(int layer_id,
+bool AnimationHost::IsAnimatingOpacityProperty(ElementId element_id,
                                                LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
                    TargetProperty::OPACITY, tree_type)
              : false;
 }
 
 bool AnimationHost::IsAnimatingTransformProperty(
-    int layer_id,
+    ElementId element_id,
     LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
                    TargetProperty::TRANSFORM, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningFilterAnimation(
-    int layer_id,
+    ElementId element_id,
     LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
                    TargetProperty::FILTER, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningOpacityAnimation(
-    int layer_id,
+    ElementId element_id,
     LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
                    TargetProperty::OPACITY, tree_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningTransformAnimation(
-    int layer_id,
+    ElementId element_id,
     LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
                    TargetProperty::TRANSFORM, tree_type)
              : false;
 }
 
 bool AnimationHost::HasAnyAnimationTargetingProperty(
-    int layer_id,
+    ElementId element_id,
     TargetProperty::Type property) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   if (!element_animations)
     return false;
 
   return !!element_animations->GetAnimation(property);
 }
 
-bool AnimationHost::FilterIsAnimatingOnImplOnly(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::FilterIsAnimatingOnImplOnly(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::FILTER);
   return animation && animation->is_impl_only();
 }
 
-bool AnimationHost::OpacityIsAnimatingOnImplOnly(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::OpacityIsAnimatingOnImplOnly(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::OPACITY);
   return animation && animation->is_impl_only();
 }
 
-bool AnimationHost::ScrollOffsetIsAnimatingOnImplOnly(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::ScrollOffsetIsAnimatingOnImplOnly(
+    ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::SCROLL_OFFSET);
   return animation && animation->is_impl_only();
 }
 
-bool AnimationHost::TransformIsAnimatingOnImplOnly(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::TransformIsAnimatingOnImplOnly(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::TRANSFORM);
   return animation && animation->is_impl_only();
 }
 
-bool AnimationHost::HasFilterAnimationThatInflatesBounds(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::HasFilterAnimationThatInflatesBounds(
+    ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->HasFilterAnimationThatInflatesBounds()
              : false;
 }
 
 bool AnimationHost::HasTransformAnimationThatInflatesBounds(
-    int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+    ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->HasTransformAnimationThatInflatesBounds()
              : false;
 }
 
-bool AnimationHost::HasAnimationThatInflatesBounds(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::HasAnimationThatInflatesBounds(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->HasAnimationThatInflatesBounds()
              : false;
 }
 
-bool AnimationHost::FilterAnimationBoundsForBox(int layer_id,
+bool AnimationHost::FilterAnimationBoundsForBox(ElementId element_id,
                                                 const gfx::BoxF& box,
                                                 gfx::BoxF* bounds) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->FilterAnimationBoundsForBox(box, bounds)
              : false;
 }
 
-bool AnimationHost::TransformAnimationBoundsForBox(int layer_id,
+bool AnimationHost::TransformAnimationBoundsForBox(ElementId element_id,
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->TransformAnimationBoundsForBox(box, bounds)
              : true;
 }
 
 bool AnimationHost::HasOnlyTranslationTransforms(
-    int layer_id,
+    ElementId element_id,
     LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->HasOnlyTranslationTransforms(tree_type)
              : true;
 }
 
-bool AnimationHost::AnimationsPreserveAxisAlignment(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::AnimationsPreserveAxisAlignment(
+    ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->AnimationsPreserveAxisAlignment()
              : true;
 }
 
-bool AnimationHost::MaximumTargetScale(int layer_id,
+bool AnimationHost::MaximumTargetScale(ElementId element_id,
                                        LayerTreeType tree_type,
                                        float* max_scale) const {
   *max_scale = 0.f;
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->MaximumTargetScale(tree_type, max_scale)
              : true;
 }
 
-bool AnimationHost::AnimationStartScale(int layer_id,
+bool AnimationHost::AnimationStartScale(ElementId element_id,
                                         LayerTreeType tree_type,
                                         float* start_scale) const {
   *start_scale = 0.f;
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations
              ? element_animations->AnimationStartScale(tree_type, start_scale)
              : true;
 }
 
-bool AnimationHost::HasAnyAnimation(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::HasAnyAnimation(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations ? element_animations->has_any_animation() : false;
 }
 
-bool AnimationHost::HasActiveAnimationForTesting(int layer_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(layer_id);
+bool AnimationHost::HasActiveAnimationForTesting(ElementId element_id) const {
+  auto element_animations = GetElementAnimationsForLayerId(element_id);
   return element_animations ? element_animations->HasActiveAnimation() : false;
 }
 
 void AnimationHost::ImplOnlyScrollAnimationCreate(
-    int layer_id,
+    ElementId element_id,
     const gfx::ScrollOffset& target_offset,
     const gfx::ScrollOffset& current_offset) {
   DCHECK(scroll_offset_animations_);
-  scroll_offset_animations_->ScrollAnimationCreate(layer_id, target_offset,
+  scroll_offset_animations_->ScrollAnimationCreate(element_id, target_offset,
                                                    current_offset);
 }
 
 bool AnimationHost::ImplOnlyScrollAnimationUpdateTarget(
-    int layer_id,
+    ElementId element_id,
     const gfx::Vector2dF& scroll_delta,
     const gfx::ScrollOffset& max_scroll_offset,
     base::TimeTicks frame_monotonic_time) {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationUpdateTarget(
-      layer_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
+      element_id, scroll_delta, max_scroll_offset, frame_monotonic_time);
 }
 
 void AnimationHost::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animations_);
   return scroll_offset_animations_->ScrollAnimationAbort(needs_completion);
 }
 
 void AnimationHost::DidActivateElementAnimations(
     ElementAnimations* element_animations) {
-  DCHECK(element_animations->layer_id());
-  active_element_animations_map_[element_animations->layer_id()] =
+  DCHECK(element_animations->element_id());
+  active_element_animations_map_[element_animations->element_id()] =
       element_animations;
 }
 
 void AnimationHost::DidDeactivateElementAnimations(
     ElementAnimations* element_animations) {
-  DCHECK(element_animations->layer_id());
-  active_element_animations_map_.erase(element_animations->layer_id());
+  DCHECK(element_animations->element_id());
+  active_element_animations_map_.erase(element_animations->element_id());
 }
 
 void AnimationHost::RegisterElementAnimations(
     ElementAnimations* element_animations) {
-  DCHECK(element_animations->layer_id());
-  layer_to_element_animations_map_[element_animations->layer_id()] =
+  DCHECK(element_animations->element_id());
+  layer_to_element_animations_map_[element_animations->element_id()] =
       element_animations;
 }
 
 void AnimationHost::UnregisterElementAnimations(
     ElementAnimations* element_animations) {
-  DCHECK(element_animations->layer_id());
-  layer_to_element_animations_map_.erase(element_animations->layer_id());
+  DCHECK(element_animations->element_id());
+  layer_to_element_animations_map_.erase(element_animations->element_id());
   DidDeactivateElementAnimations(element_animations);
 }
 
 const AnimationHost::LayerToElementAnimationsMap&
 AnimationHost::active_element_animations_for_testing() const {
   return active_element_animations_map_;
 }
 
 const AnimationHost::LayerToElementAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
   return layer_to_element_animations_map_;
 }
 
 void AnimationHost::OnAnimationWaitingForDeletion() {
   animation_waiting_for_deletion_ = true;
 }
 
 }  // namespace cc