CC Animation: Erase ElementAnimations::ObserverType.

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 357 matching lines @@
             ->ToFilterAnimationCurve()
             ->HasFilterThatMovesPixels())
       return true;
   }
 
   return false;
 }
 
 bool ElementAnimations::HasTransformAnimationThatInflatesBounds() const {
   return IsCurrentlyAnimatingProperty(TargetProperty::TRANSFORM,
-                                      ObserverType::ACTIVE) ||
+                                      LayerTreeType::ACTIVE) ||
          IsCurrentlyAnimatingProperty(TargetProperty::TRANSFORM,
-                                      ObserverType::PENDING);
+                                      LayerTreeType::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(
-    ObserverType observer_type) const {
+    LayerTreeType observer_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->is_finished() ||
         animations_[i]->target_property() != TargetProperty::TRANSFORM)
       continue;
 
-    if ((observer_type == ObserverType::ACTIVE &&
+    if ((observer_type == LayerTreeType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
-        (observer_type == ObserverType::PENDING &&
+        (observer_type == LayerTreeType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       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(ObserverType observer_type,
+bool ElementAnimations::AnimationStartScale(LayerTreeType observer_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 ((observer_type == ObserverType::ACTIVE &&
+    if ((observer_type == LayerTreeType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
-        (observer_type == ObserverType::PENDING &&
+        (observer_type == LayerTreeType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       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(ObserverType observer_type,
+bool ElementAnimations::MaximumTargetScale(LayerTreeType observer_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 ((observer_type == ObserverType::ACTIVE &&
+    if ((observer_type == LayerTreeType::ACTIVE &&
          !animations_[i]->affects_active_observers()) ||
-        (observer_type == ObserverType::PENDING &&
+        (observer_type == LayerTreeType::PENDING &&
          !animations_[i]->affects_pending_observers()))
       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 584 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,
-    ObserverType observer_type) const {
+    LayerTreeType observer_type) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->target_property() == target_property) {
-      if ((observer_type == ObserverType::ACTIVE &&
+      if ((observer_type == LayerTreeType::ACTIVE &&
            animations_[i]->affects_active_observers()) ||
-          (observer_type == ObserverType::PENDING &&
+          (observer_type == LayerTreeType::PENDING &&
            animations_[i]->affects_pending_observers()))
         return true;
     }
   }
   return false;
 }
 
 bool ElementAnimations::IsCurrentlyAnimatingProperty(
     TargetProperty::Type target_property,
-    ObserverType observer_type) const {
+    LayerTreeType observer_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 ((observer_type == ObserverType::ACTIVE &&
+      if ((observer_type == LayerTreeType::ACTIVE &&
            animations_[i]->affects_active_observers()) ||
-          (observer_type == ObserverType::PENDING &&
+          (observer_type == LayerTreeType::PENDING &&
            animations_[i]->affects_pending_observers()))
         return true;
     }
   }
   return false;
 }
 
 void ElementAnimations::PauseAnimation(int animation_id,
                                        base::TimeDelta time_offset) {
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 194 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         layer_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc