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

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 36 matching lines @@
   element_id_ = element_id;
 }
 
 void ElementAnimations::InitAffectedElementTypes() {
   DCHECK(element_id_);
   DCHECK(animation_host_);
 
   UpdateActivation(FORCE_ACTIVATION);
 
   DCHECK(animation_host_->mutator_host_client());
-  if (animation_host_->mutator_host_client()->IsLayerInTree(
-          element_id_, LayerTreeType::ACTIVE)) {
+  if (animation_host_->mutator_host_client()->IsElementInList(
+          element_id_, ElementListType::ACTIVE)) {
     set_has_element_in_active_list(true);
   }
-  if (animation_host_->mutator_host_client()->IsLayerInTree(
-          element_id_, LayerTreeType::PENDING)) {
+  if (animation_host_->mutator_host_client()->IsElementInList(
+          element_id_, ElementListType::PENDING)) {
     set_has_element_in_pending_list(true);
   }
 }
 
 void ElementAnimations::ClearAffectedElementTypes() {
   DCHECK(animation_host_);
 
   if (has_element_in_active_list())
-    OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::ACTIVE, false);
+    OnTransformIsPotentiallyAnimatingChanged(ElementListType::ACTIVE, false);
   set_has_element_in_active_list(false);
 
   if (has_element_in_pending_list())
-    OnTransformIsPotentiallyAnimatingChanged(LayerTreeType::PENDING, false);
+    OnTransformIsPotentiallyAnimatingChanged(ElementListType::PENDING, false);
   set_has_element_in_pending_list(false);
 
   animation_host_->DidDeactivateElementAnimations(this);
   UpdateActivation(FORCE_ACTIVATION);
 }
 
-void ElementAnimations::LayerRegistered(ElementId element_id,
-                                        LayerTreeType tree_type) {
+void ElementAnimations::ElementRegistered(ElementId element_id,
+                                          ElementListType list_type) {
   DCHECK_EQ(element_id_, element_id);
 
-  if (tree_type == LayerTreeType::ACTIVE)
+  if (list_type == ElementListType::ACTIVE)
     set_has_element_in_active_list(true);
   else
     set_has_element_in_pending_list(true);
 }
 
-void ElementAnimations::LayerUnregistered(ElementId element_id,
-                                          LayerTreeType tree_type) {
+void ElementAnimations::ElementUnregistered(ElementId element_id,
+                                            ElementListType list_type) {
   DCHECK_EQ(this->element_id(), element_id);
-  if (tree_type == LayerTreeType::ACTIVE)
+  if (list_type == ElementListType::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);
 }
 
 void ElementAnimations::RemovePlayer(AnimationPlayer* player) {
@@ skipping 263 matching lines @@
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
       return true;
   }
 
   return false;
 }
 
 bool ElementAnimations::HasTransformAnimationThatInflatesBounds() const {
   return IsCurrentlyAnimatingProperty(TargetProperty::TRANSFORM,
-                                      LayerTreeType::ACTIVE) ||
+                                      ElementListType::ACTIVE) ||
          IsCurrentlyAnimatingProperty(TargetProperty::TRANSFORM,
-                                      LayerTreeType::PENDING);
+                                      ElementListType::PENDING);
 }
 
 bool ElementAnimations::FilterAnimationBoundsForBox(const gfx::BoxF& box,
                                                     gfx::BoxF* bounds) const {
   // TODO(avallee): Implement.
   return false;
 }
 
 bool ElementAnimations::TransformAnimationBoundsForBox(
     const gfx::BoxF& box,
@@ skipping 35 matching lines @@
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (transform_animation_curve->AffectsScale())
       return true;
   }
 
   return false;
 }
 
 bool ElementAnimations::HasOnlyTranslationTransforms(
-    LayerTreeType tree_type) const {
+    ElementListType list_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((tree_type == LayerTreeType::ACTIVE &&
+    if ((list_type == ElementListType::ACTIVE &&
          !animations_[i]->affects_active_elements()) ||
-        (tree_type == LayerTreeType::PENDING &&
+        (list_type == ElementListType::PENDING &&
          !animations_[i]->affects_pending_elements()))
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->IsTranslation())
       return false;
   }
 
   return true;
 }
 
 bool ElementAnimations::AnimationsPreserveAxisAlignment() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     if (!transform_animation_curve->PreservesAxisAlignment())
       return false;
   }
 
   return true;
 }
 
-bool ElementAnimations::AnimationStartScale(LayerTreeType tree_type,
+bool ElementAnimations::AnimationStartScale(ElementListType list_type,
                                             float* start_scale) const {
   *start_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((tree_type == LayerTreeType::ACTIVE &&
+    if ((list_type == ElementListType::ACTIVE &&
          !animations_[i]->affects_active_elements()) ||
-        (tree_type == LayerTreeType::PENDING &&
+        (list_type == ElementListType::PENDING &&
          !animations_[i]->affects_pending_elements()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
       case Animation::DIRECTION_NORMAL:
       case Animation::DIRECTION_ALTERNATE:
         forward_direction = animations_[i]->playback_rate() >= 0.0;
         break;
       case Animation::DIRECTION_REVERSE:
       case Animation::DIRECTION_ALTERNATE_REVERSE:
         forward_direction = animations_[i]->playback_rate() < 0.0;
         break;
     }
 
     const TransformAnimationCurve* transform_animation_curve =
         animations_[i]->curve()->ToTransformAnimationCurve();
     float animation_start_scale = 0.f;
     if (!transform_animation_curve->AnimationStartScale(forward_direction,
                                                         &animation_start_scale))
       return false;
     *start_scale = std::max(*start_scale, animation_start_scale);
   }
   return true;
 }
 
-bool ElementAnimations::MaximumTargetScale(LayerTreeType tree_type,
+bool ElementAnimations::MaximumTargetScale(ElementListType list_type,
                                            float* max_scale) const {
   *max_scale = 0.f;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((tree_type == LayerTreeType::ACTIVE &&
+    if ((list_type == ElementListType::ACTIVE &&
          !animations_[i]->affects_active_elements()) ||
-        (tree_type == LayerTreeType::PENDING &&
+        (list_type == ElementListType::PENDING &&
          !animations_[i]->affects_pending_elements()))
       continue;
 
     bool forward_direction = true;
     switch (animations_[i]->direction()) {
       case Animation::DIRECTION_NORMAL:
       case Animation::DIRECTION_ALTERNATE:
         forward_direction = animations_[i]->playback_rate() >= 0.0;
         break;
       case Animation::DIRECTION_REVERSE:
@@ skipping 487 matching lines @@
     else if (!is_active_ && (was_active || force))
       animation_host_->DidDeactivateElementAnimations(this);
   }
 }
 
 void ElementAnimations::NotifyClientOpacityAnimated(
     float opacity,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
-    OnOpacityAnimated(LayerTreeType::ACTIVE, opacity);
+    OnOpacityAnimated(ElementListType::ACTIVE, opacity);
   if (notify_pending_elements && has_element_in_pending_list())
-    OnOpacityAnimated(LayerTreeType::PENDING, opacity);
+    OnOpacityAnimated(ElementListType::PENDING, opacity);
 }
 
 void ElementAnimations::NotifyClientTransformAnimated(
     const gfx::Transform& transform,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
-    OnTransformAnimated(LayerTreeType::ACTIVE, transform);
+    OnTransformAnimated(ElementListType::ACTIVE, transform);
   if (notify_pending_elements && has_element_in_pending_list())
-    OnTransformAnimated(LayerTreeType::PENDING, transform);
+    OnTransformAnimated(ElementListType::PENDING, transform);
 }
 
 void ElementAnimations::NotifyClientFilterAnimated(
     const FilterOperations& filters,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
-    OnFilterAnimated(LayerTreeType::ACTIVE, filters);
+    OnFilterAnimated(ElementListType::ACTIVE, filters);
   if (notify_pending_elements && has_element_in_pending_list())
-    OnFilterAnimated(LayerTreeType::PENDING, filters);
+    OnFilterAnimated(ElementListType::PENDING, filters);
 }
 
 void ElementAnimations::NotifyClientScrollOffsetAnimated(
     const gfx::ScrollOffset& scroll_offset,
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
-    OnScrollOffsetAnimated(LayerTreeType::ACTIVE, scroll_offset);
+    OnScrollOffsetAnimated(ElementListType::ACTIVE, scroll_offset);
   if (notify_pending_elements && has_element_in_pending_list())
-    OnScrollOffsetAnimated(LayerTreeType::PENDING, scroll_offset);
+    OnScrollOffsetAnimated(ElementListType::PENDING, scroll_offset);
 }
 
 void ElementAnimations::NotifyClientAnimationWaitingForDeletion() {
   OnAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::NotifyClientTransformIsPotentiallyAnimatingChanged(
     bool notify_active_elements,
     bool notify_pending_elements) {
   if (notify_active_elements && has_element_in_active_list())
     OnTransformIsPotentiallyAnimatingChanged(
-        LayerTreeType::ACTIVE,
+        ElementListType::ACTIVE,
         potentially_animating_transform_for_active_elements_);
   if (notify_pending_elements && has_element_in_pending_list())
     OnTransformIsPotentiallyAnimatingChanged(
-        LayerTreeType::PENDING,
+        ElementListType::PENDING,
         potentially_animating_transform_for_pending_elements_);
 }
 
 void ElementAnimations::UpdatePotentiallyAnimatingTransform() {
   bool was_potentially_animating_transform_for_active_elements =
       potentially_animating_transform_for_active_elements_;
   bool was_potentially_animating_transform_for_pending_elements =
       potentially_animating_transform_for_pending_elements_;
 
   potentially_animating_transform_for_active_elements_ = false;
@@ skipping 26 matching lines @@
 bool ElementAnimations::HasActiveAnimation() const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished())
       return true;
   }
   return false;
 }
 
 bool ElementAnimations::IsPotentiallyAnimatingProperty(
     TargetProperty::Type target_property,
-    LayerTreeType tree_type) const {
+    ElementListType list_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == target_property) {
-      if ((tree_type == LayerTreeType::ACTIVE &&
+      if ((list_type == ElementListType::ACTIVE &&
            animations_[i]->affects_active_elements()) ||
-          (tree_type == LayerTreeType::PENDING &&
+          (list_type == ElementListType::PENDING &&
            animations_[i]->affects_pending_elements()))
         return true;
     }
   }
   return false;
 }
 
 bool ElementAnimations::IsCurrentlyAnimatingProperty(
     TargetProperty::Type target_property,
-    LayerTreeType tree_type) const {
+    ElementListType list_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->InEffect(last_tick_time_) &&
         animations_[i]->target_property() == target_property) {
-      if ((tree_type == LayerTreeType::ACTIVE &&
+      if ((list_type == ElementListType::ACTIVE &&
            animations_[i]->affects_active_elements()) ||
-          (tree_type == LayerTreeType::PENDING &&
+          (list_type == ElementListType::PENDING &&
            animations_[i]->affects_pending_elements()))
         return true;
     }
   }
   return false;
 }
 
 void ElementAnimations::PauseAnimation(int animation_id,
                                        base::TimeDelta time_offset) {
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 78 matching lines @@
   return nullptr;
 }
 
 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,
+void ElementAnimations::OnFilterAnimated(ElementListType list_type,
                                          const FilterOperations& filters) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
-  animation_host()->mutator_host_client()->SetLayerFilterMutated(
-      element_id(), tree_type, filters);
+  animation_host()->mutator_host_client()->SetElementFilterMutated(
+      element_id(), list_type, filters);
 }
 
-void ElementAnimations::OnOpacityAnimated(LayerTreeType tree_type,
+void ElementAnimations::OnOpacityAnimated(ElementListType list_type,
                                           float opacity) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
-  animation_host()->mutator_host_client()->SetLayerOpacityMutated(
-      element_id(), tree_type, opacity);
+  animation_host()->mutator_host_client()->SetElementOpacityMutated(
+      element_id(), list_type, opacity);
 }
 
-void ElementAnimations::OnTransformAnimated(LayerTreeType tree_type,
+void ElementAnimations::OnTransformAnimated(ElementListType list_type,
                                             const gfx::Transform& transform) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
-  animation_host()->mutator_host_client()->SetLayerTransformMutated(
-      element_id(), tree_type, transform);
+  animation_host()->mutator_host_client()->SetElementTransformMutated(
+      element_id(), list_type, transform);
 }
 
 void ElementAnimations::OnScrollOffsetAnimated(
-    LayerTreeType tree_type,
+    ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
-  animation_host()->mutator_host_client()->SetLayerScrollOffsetMutated(
-      element_id(), tree_type, scroll_offset);
+  animation_host()->mutator_host_client()->SetElementScrollOffsetMutated(
+      element_id(), list_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,
+    ElementListType list_type,
     bool is_animating) {
   DCHECK(element_id());
   DCHECK(animation_host());
   DCHECK(animation_host()->mutator_host_client());
   animation_host()
       ->mutator_host_client()
-      ->LayerTransformIsPotentiallyAnimatingChanged(element_id(), tree_type,
-                                                    is_animating);
+      ->ElementTransformIsPotentiallyAnimatingChanged(element_id(), list_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();
     player->NotifyAnimationStarted(monotonic_time, target_property, group);
@@ skipping 42 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc