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

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"
@@ skipping 121 matching lines @@
         scroll_offset_animation_player_->DetachLayer();
       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
+  // I.e. only one element can have an impl-only scroll offset animation at
   // any given time.
   scoped_refptr<AnimationPlayer> scroll_offset_animation_player_;
 
   DISALLOW_COPY_AND_ASSIGN(ScrollOffsetAnimations);
 };
 
 std::unique_ptr<AnimationHost> AnimationHost::Create(
     ThreadInstance thread_instance) {
   return base::WrapUnique(new AnimationHost(thread_instance));
 }
 
 AnimationHost::AnimationHost(ThreadInstance thread_instance)
     : mutator_host_client_(nullptr),
       thread_instance_(thread_instance),
       supports_scroll_animations_(false),
       animation_waiting_for_deletion_(false) {
   if (thread_instance_ == ThreadInstance::IMPL)
     scroll_offset_animations_ =
         base::WrapUnique(new ScrollOffsetAnimations(this));
 }
 
 AnimationHost::~AnimationHost() {
   scroll_offset_animations_ = nullptr;
 
   ClearTimelines();
   DCHECK(!mutator_host_client());
-  DCHECK(layer_to_element_animations_map_.empty());
+  DCHECK(element_to_animations_map_.empty());
 }
 
 AnimationTimeline* AnimationHost::GetTimelineById(int timeline_id) const {
   auto f = id_to_timeline_map_.find(timeline_id);
   return f == id_to_timeline_map_.end() ? nullptr : f->second.get();
 }
 
 void AnimationHost::ClearTimelines() {
   for (auto& kv : id_to_timeline_map_)
     EraseTimeline(kv.second);
@@ skipping 13 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(ElementId element_id,
-                                  LayerTreeType tree_type) {
+void AnimationHost::RegisterElement(ElementId element_id,
+                                    ElementListType list_type) {
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(element_id);
+      GetElementAnimationsForElementId(element_id);
   if (element_animations)
-    element_animations->LayerRegistered(element_id, tree_type);
+    element_animations->ElementRegistered(element_id, list_type);
 }
 
-void AnimationHost::UnregisterLayer(ElementId element_id,
-                                    LayerTreeType tree_type) {
+void AnimationHost::UnregisterElement(ElementId element_id,
+                                      ElementListType list_type) {
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(element_id);
+      GetElementAnimationsForElementId(element_id);
   if (element_animations)
-    element_animations->LayerUnregistered(element_id, tree_type);
+    element_animations->ElementUnregistered(element_id, list_type);
 }
 
-void AnimationHost::RegisterPlayerForLayer(ElementId element_id,
-                                           AnimationPlayer* player) {
+void AnimationHost::RegisterPlayerForElement(ElementId element_id,
+                                             AnimationPlayer* player) {
   DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(element_id);
+      GetElementAnimationsForElementId(element_id);
   if (!element_animations) {
     element_animations = ElementAnimations::Create();
     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(ElementId element_id,
-                                             AnimationPlayer* player) {
+void AnimationHost::UnregisterPlayerForElement(ElementId element_id,
+                                               AnimationPlayer* player) {
   DCHECK(element_id);
   DCHECK(player);
 
   scoped_refptr<ElementAnimations> element_animations =
-      GetElementAnimationsForLayerId(element_id);
+      GetElementAnimationsForElementId(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 54 matching lines @@
   // Firstly, sync all players with impl thread to create ElementAnimations.
   for (auto& kv : id_to_timeline_map_) {
     AnimationTimeline* timeline = kv.second.get();
     AnimationTimeline* timeline_impl =
         host_impl->GetTimelineById(timeline->id());
     if (timeline_impl)
       timeline->PushPropertiesTo(timeline_impl);
   }
 
   // Secondly, sync properties for created ElementAnimations.
-  for (auto& kv : layer_to_element_animations_map_) {
+  for (auto& kv : element_to_animations_map_) {
     const auto& element_animations = kv.second;
     auto element_animations_impl =
-        host_impl->GetElementAnimationsForLayerId(kv.first);
+        host_impl->GetElementAnimationsForElementId(kv.first);
     if (element_animations_impl)
       element_animations->PushPropertiesTo(std::move(element_animations_impl));
   }
 }
 
-scoped_refptr<ElementAnimations> AnimationHost::GetElementAnimationsForLayerId(
-    ElementId element_id) const {
+scoped_refptr<ElementAnimations>
+AnimationHost::GetElementAnimationsForElementId(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;
+  auto iter = element_to_animations_map_.find(element_id);
+  return iter == element_to_animations_map_.end() ? nullptr : iter->second;
 }
 
 void AnimationHost::SetSupportsScrollAnimations(
     bool supports_scroll_animations) {
   supports_scroll_animations_ = supports_scroll_animations;
 }
 
 bool AnimationHost::SupportsScrollAnimations() const {
   return supports_scroll_animations_;
 }
 
 bool AnimationHost::NeedsAnimateLayers() const {
-  return !active_element_animations_map_.empty();
+  return !active_element_to_animations_map_.empty();
 }
 
 bool AnimationHost::ActivateAnimations() {
   if (!NeedsAnimateLayers())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::ActivateAnimations");
-  LayerToElementAnimationsMap active_element_animations_map_copy =
-      active_element_animations_map_;
+  ElementToAnimationsMap active_element_animations_map_copy =
+      active_element_to_animations_map_;
   for (auto& it : active_element_animations_map_copy)
     it.second->ActivateAnimations();
 
   return true;
 }
 
 bool AnimationHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!NeedsAnimateLayers())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::AnimateLayers");
-  LayerToElementAnimationsMap active_element_animations_map_copy =
-      active_element_animations_map_;
+  ElementToAnimationsMap active_element_animations_map_copy =
+      active_element_to_animations_map_;
   for (auto& it : active_element_animations_map_copy)
     it.second->Animate(monotonic_time);
 
   return true;
 }
 
 bool AnimationHost::UpdateAnimationState(bool start_ready_animations,
                                          AnimationEvents* events) {
   if (!NeedsAnimateLayers())
     return false;
 
   TRACE_EVENT0("cc", "AnimationHost::UpdateAnimationState");
-  LayerToElementAnimationsMap active_element_animations_map_copy =
-      active_element_animations_map_;
+  ElementToAnimationsMap active_element_animations_map_copy =
+      active_element_to_animations_map_;
   for (auto& it : active_element_animations_map_copy)
     it.second->UpdateState(start_ready_animations, events);
 
   return true;
 }
 
 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].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_;
+    const ElementToAnimationsMap& all_element_animations =
+        element_to_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:
           (*iter).second->NotifyAnimationStarted(events->events_[event_index]);
           break;
 
         case AnimationEvent::FINISHED:
           (*iter).second->NotifyAnimationFinished(events->events_[event_index]);
           break;
@@ skipping 10 matching lines @@
         case AnimationEvent::TAKEOVER:
           (*iter).second->NotifyAnimationTakeover(events->events_[event_index]);
           break;
       }
     }
   }
 }
 
 bool AnimationHost::ScrollOffsetAnimationWasInterrupted(
     ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->scroll_offset_animation_was_interrupted()
              : false;
 }
 
 bool AnimationHost::IsAnimatingFilterProperty(ElementId element_id,
-                                              LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+                                              ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::FILTER, tree_type)
+                   TargetProperty::FILTER, list_type)
              : false;
 }
 
-bool AnimationHost::IsAnimatingOpacityProperty(ElementId element_id,
-                                               LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+bool AnimationHost::IsAnimatingOpacityProperty(
+    ElementId element_id,
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::OPACITY, tree_type)
+                   TargetProperty::OPACITY, list_type)
              : false;
 }
 
 bool AnimationHost::IsAnimatingTransformProperty(
     ElementId element_id,
-    LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsCurrentlyAnimatingProperty(
-                   TargetProperty::TRANSFORM, tree_type)
+                   TargetProperty::TRANSFORM, list_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningFilterAnimation(
     ElementId element_id,
-    LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::FILTER, tree_type)
+                   TargetProperty::FILTER, list_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningOpacityAnimation(
     ElementId element_id,
-    LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::OPACITY, tree_type)
+                   TargetProperty::OPACITY, list_type)
              : false;
 }
 
 bool AnimationHost::HasPotentiallyRunningTransformAnimation(
     ElementId element_id,
-    LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->IsPotentiallyAnimatingProperty(
-                   TargetProperty::TRANSFORM, tree_type)
+                   TargetProperty::TRANSFORM, list_type)
              : false;
 }
 
 bool AnimationHost::HasAnyAnimationTargetingProperty(
     ElementId element_id,
     TargetProperty::Type property) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   if (!element_animations)
     return false;
 
   return !!element_animations->GetAnimation(property);
 }
 
 bool AnimationHost::FilterIsAnimatingOnImplOnly(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::FILTER);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::OpacityIsAnimatingOnImplOnly(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::OPACITY);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::ScrollOffsetIsAnimatingOnImplOnly(
     ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::SCROLL_OFFSET);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::TransformIsAnimatingOnImplOnly(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   if (!element_animations)
     return false;
 
   Animation* animation =
       element_animations->GetAnimation(TargetProperty::TRANSFORM);
   return animation && animation->is_impl_only();
 }
 
 bool AnimationHost::HasFilterAnimationThatInflatesBounds(
     ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->HasFilterAnimationThatInflatesBounds()
              : false;
 }
 
 bool AnimationHost::HasTransformAnimationThatInflatesBounds(
     ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->HasTransformAnimationThatInflatesBounds()
              : false;
 }
 
 bool AnimationHost::HasAnimationThatInflatesBounds(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->HasAnimationThatInflatesBounds()
              : false;
 }
 
 bool AnimationHost::FilterAnimationBoundsForBox(ElementId element_id,
                                                 const gfx::BoxF& box,
                                                 gfx::BoxF* bounds) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->FilterAnimationBoundsForBox(box, bounds)
              : false;
 }
 
 bool AnimationHost::TransformAnimationBoundsForBox(ElementId element_id,
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->TransformAnimationBoundsForBox(box, bounds)
              : true;
 }
 
 bool AnimationHost::HasOnlyTranslationTransforms(
     ElementId element_id,
-    LayerTreeType tree_type) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+    ElementListType list_type) const {
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
-             ? element_animations->HasOnlyTranslationTransforms(tree_type)
+             ? element_animations->HasOnlyTranslationTransforms(list_type)
              : true;
 }
 
 bool AnimationHost::AnimationsPreserveAxisAlignment(
     ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
              ? element_animations->AnimationsPreserveAxisAlignment()
              : true;
 }
 
 bool AnimationHost::MaximumTargetScale(ElementId element_id,
-                                       LayerTreeType tree_type,
+                                       ElementListType list_type,
                                        float* max_scale) const {
   *max_scale = 0.f;
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
-             ? element_animations->MaximumTargetScale(tree_type, max_scale)
+             ? element_animations->MaximumTargetScale(list_type, max_scale)
              : true;
 }
 
 bool AnimationHost::AnimationStartScale(ElementId element_id,
-                                        LayerTreeType tree_type,
+                                        ElementListType list_type,
                                         float* start_scale) const {
   *start_scale = 0.f;
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations
-             ? element_animations->AnimationStartScale(tree_type, start_scale)
+             ? element_animations->AnimationStartScale(list_type, start_scale)
              : true;
 }
 
 bool AnimationHost::HasAnyAnimation(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations ? element_animations->has_any_animation() : false;
 }
 
 bool AnimationHost::HasActiveAnimationForTesting(ElementId element_id) const {
-  auto element_animations = GetElementAnimationsForLayerId(element_id);
+  auto element_animations = GetElementAnimationsForElementId(element_id);
   return element_animations ? element_animations->HasActiveAnimation() : false;
 }
 
 void AnimationHost::ImplOnlyScrollAnimationCreate(
     ElementId element_id,
     const gfx::ScrollOffset& target_offset,
     const gfx::ScrollOffset& current_offset) {
   DCHECK(scroll_offset_animations_);
   scroll_offset_animations_->ScrollAnimationCreate(element_id, target_offset,
                                                    current_offset);
@@ skipping 10 matching lines @@
 }
 
 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->element_id());
-  active_element_animations_map_[element_animations->element_id()] =
+  active_element_to_animations_map_[element_animations->element_id()] =
       element_animations;
 }
 
 void AnimationHost::DidDeactivateElementAnimations(
     ElementAnimations* element_animations) {
   DCHECK(element_animations->element_id());
-  active_element_animations_map_.erase(element_animations->element_id());
+  active_element_to_animations_map_.erase(element_animations->element_id());
 }
 
 void AnimationHost::RegisterElementAnimations(
     ElementAnimations* element_animations) {
   DCHECK(element_animations->element_id());
-  layer_to_element_animations_map_[element_animations->element_id()] =
+  element_to_animations_map_[element_animations->element_id()] =
       element_animations;
 }
 
 void AnimationHost::UnregisterElementAnimations(
     ElementAnimations* element_animations) {
   DCHECK(element_animations->element_id());
-  layer_to_element_animations_map_.erase(element_animations->element_id());
+  element_to_animations_map_.erase(element_animations->element_id());
   DidDeactivateElementAnimations(element_animations);
 }
 
-const AnimationHost::LayerToElementAnimationsMap&
+const AnimationHost::ElementToAnimationsMap&
 AnimationHost::active_element_animations_for_testing() const {
-  return active_element_animations_map_;
+  return active_element_to_animations_map_;
 }
 
-const AnimationHost::LayerToElementAnimationsMap&
+const AnimationHost::ElementToAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
-  return layer_to_element_animations_map_;
+  return element_to_animations_map_;
 }
 
 void AnimationHost::OnAnimationWaitingForDeletion() {
   animation_waiting_for_deletion_ = true;
 }
 
 }  // namespace cc