CC Animation: Erase ElementAnimations::ObserverType.

cc/animation/element_animations.h

 // 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.
 
 #ifndef CC_ANIMATION_ELEMENT_ANIMATIONS_H_
 #define CC_ANIMATION_ELEMENT_ANIMATIONS_H_
 
 #include <bitset>
 #include <memory>
 #include <vector>
@@ skipping 23 matching lines @@
 class FilterOperations;
 class KeyframeValueList;
 enum class LayerTreeType;
 
 // An ElementAnimations owns a list of all AnimationPlayers, attached to
 // the layer.
 // This is a CC counterpart for blink::ElementAnimations (in 1:1 relationship).
 // No pointer to/from respective blink::ElementAnimations object for now.
 class CC_EXPORT ElementAnimations : public base::RefCounted<ElementAnimations> {
  public:
-  enum class ObserverType { ACTIVE, PENDING };
-
   static scoped_refptr<ElementAnimations> Create();
 
   int layer_id() const { return layer_id_; }
   void SetLayerId(int layer_id);
 
   // Parent AnimationHost.
   AnimationHost* animation_host() { return animation_host_; }
   const AnimationHost* animation_host() const { return animation_host_; }
   void SetAnimationHost(AnimationHost* host);
 
@@ skipping 46 matching lines @@
   // aborted.
   bool HasActiveAnimation() const;
 
   // Returns true if there are any animations at all to process.
   bool has_any_animation() const { return !animations_.empty(); }
 
   // Returns true if there is an animation that is either currently animating
   // the given property or scheduled to animate this property in the future, and
   // that affects the given observer type.
   bool IsPotentiallyAnimatingProperty(TargetProperty::Type target_property,
-                                      ObserverType observer_type) const;
+                                      LayerTreeType observer_type) const;
 
   // Returns true if there is an animation that is currently animating the given
   // property and that affects the given observer type.
   bool IsCurrentlyAnimatingProperty(TargetProperty::Type target_property,
-                                    ObserverType observer_type) const;
+                                    LayerTreeType observer_type) const;
 
   void NotifyAnimationStarted(const AnimationEvent& event);
   void NotifyAnimationFinished(const AnimationEvent& event);
   void NotifyAnimationAborted(const AnimationEvent& event);
   void NotifyAnimationPropertyUpdate(const AnimationEvent& event);
   void NotifyAnimationTakeover(const AnimationEvent& event);
 
   bool needs_active_value_observations() const {
     return needs_active_value_observations_;
   }
@@ skipping 17 matching lines @@
            HasFilterAnimationThatInflatesBounds();
   }
 
   bool FilterAnimationBoundsForBox(const gfx::BoxF& box,
                                    gfx::BoxF* bounds) const;
   bool TransformAnimationBoundsForBox(const gfx::BoxF& box,
                                       gfx::BoxF* bounds) const;
 
   bool HasAnimationThatAffectsScale() const;
 
-  bool HasOnlyTranslationTransforms(ObserverType observer_type) const;
+  bool HasOnlyTranslationTransforms(LayerTreeType observer_type) const;
 
   bool AnimationsPreserveAxisAlignment() const;
 
   // Sets |start_scale| to the maximum of starting animation scale along any
   // dimension at any destination in active animations. Returns false if the
   // starting scale cannot be computed.
-  bool AnimationStartScale(ObserverType observer_type,
+  bool AnimationStartScale(LayerTreeType observer_type,
                            float* start_scale) const;
 
   // Sets |max_scale| to the maximum scale along any dimension at any
   // destination in active animations. Returns false if the maximum scale cannot
   // be computed.
-  bool MaximumTargetScale(ObserverType observer_type, float* max_scale) const;
+  bool MaximumTargetScale(LayerTreeType observer_type, float* max_scale) const;
 
   // When a scroll animation is removed on the main thread, its compositor
   // thread counterpart continues producing scroll deltas until activation.
   // These scroll deltas need to be cleared at activation, so that the active
   // layer's scroll offset matches the offset provided by the main thread
   // rather than a combination of this offset and scroll deltas produced by
   // the removed animation. This is to provide the illusion of synchronicity to
   // JS that simultaneously removes an animation and sets the scroll offset.
   bool scroll_offset_animation_was_interrupted() const {
     return scroll_offset_animation_was_interrupted_;
@@ skipping 104 matching lines @@
 
   bool potentially_animating_transform_for_active_observers_;
   bool potentially_animating_transform_for_pending_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementAnimations);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_ELEMENT_ANIMATIONS_H_