CC Animation: Erase LayerAnimationEventObserver.

ui/compositor/layer_animator.h

 // Copyright (c) 2012 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 UI_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_COMPOSITOR_LAYER_ANIMATOR_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
-#include "cc/animation/layer_animation_event_observer.h"
+#include "cc/animation/animation_delegate.h"
+#include "cc/animation/target_property.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_threaded_animation_delegate.h"
 #include "ui/gfx/animation/tween.h"
 
 namespace cc {
 class Animation;
 class AnimationPlayer;
 class AnimationTimeline;
 class Layer;
@@ skipping 20 matching lines @@
 // NB: during many tests, set_disable_animations_for_test is used and causes
 // all animations to complete immediately. The layer animation is ref counted
 // so that if its owning layer is deleted (and the owning layer is only other
 // class that should ever hold a ref ptr to a LayerAnimator), the animator can
 // ensure that it is not disposed of until it finishes executing. It does this
 // by holding a reference to itself for the duration of methods for which it
 // must guarantee that |this| is valid.
 class COMPOSITOR_EXPORT LayerAnimator
     : public base::RefCounted<LayerAnimator>,
       public LayerThreadedAnimationDelegate,
-      NON_EXPORTED_BASE(public cc::LayerAnimationEventObserver) {
+      NON_EXPORTED_BASE(public cc::AnimationDelegate) {
  public:
   enum PreemptionStrategy {
     IMMEDIATELY_SET_NEW_TARGET,
     IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
     ENQUEUE_NEW_ANIMATION,
     REPLACE_QUEUED_ANIMATIONS,
     BLEND_WITH_CURRENT_ANIMATION
   };
 
   explicit LayerAnimator(base::TimeDelta transition_duration);
@@ skipping 119 matching lines @@
   // This is similar to StopAnimating, but aborts rather than finishes the
   // animations and notifies all observers.
   void AbortAllAnimations() { StopAnimatingInternal(true); }
 
   // These functions are used for adding or removing observers from the observer
   // list. The observers are notified when animations end.
   void AddObserver(LayerAnimationObserver* observer);
   void RemoveObserver(LayerAnimationObserver* observer);
 
   // Called when a threaded animation is actually started.
-  void OnThreadedAnimationStarted(const cc::AnimationEvent& event);
+  void OnThreadedAnimationStarted(base::TimeTicks monotonic_time,
+                                  cc::TargetProperty::Type target_property,
+                                  int group_id);
 
   // This determines how implicit animations will be tweened. This has no
   // effect on animations that are explicitly started or scheduled. The default
   // is Tween::LINEAR.
   void set_tween_type(gfx::Tween::Type tween_type) { tween_type_ = tween_type; }
   gfx::Tween::Type tween_type() const { return tween_type_; }
 
   // For testing purposes only.
   void set_disable_timer_for_test(bool disable_timer) {
     disable_timer_for_test_ = disable_timer;
@@ skipping 122 matching lines @@
 
   // Clears the animation queues and notifies any running animations that they
   // have been aborted.
   void ClearAnimationsInternal();
 
   // Cleans up any running animations that may have been deleted.
   void PurgeDeletedAnimations();
 
   LayerAnimatorCollection* GetLayerAnimatorCollection();
 
-  // LayerAnimationEventObserver
-  void OnAnimationStarted(const cc::AnimationEvent& event) override;
+  // cc::AnimationDelegate implementation.
+  void NotifyAnimationStarted(base::TimeTicks monotonic_time,
+                              cc::TargetProperty::Type target_property,
+                              int group_id) override;
+  void NotifyAnimationFinished(base::TimeTicks monotonic_time,
+                               cc::TargetProperty::Type target_property,
+                               int group_id) override {}
+  void NotifyAnimationAborted(base::TimeTicks monotonic_time,
+                              cc::TargetProperty::Type target_property,
+                              int group_id) override {}
+  void NotifyAnimationTakeover(
+      base::TimeTicks monotonic_time,
+      cc::TargetProperty::Type target_property,
+      double animation_start_time,
+      std::unique_ptr<cc::AnimationCurve> curve) override {}
 
   // Implementation of LayerThreadedAnimationDelegate.
   void AddThreadedAnimation(std::unique_ptr<cc::Animation> animation) override;
   void RemoveThreadedAnimation(int animation_id) override;
 
   void AttachLayerToAnimationPlayer(int layer_id);
   void DetachLayerFromAnimationPlayer();
 
   // This is the queue of animations to run.
   AnimationQueue animation_queue_;
@@ skipping 42 matching lines @@
   // ResetCompositor/SetCompositor scope.
   // TODO(loyso): Remove it. crbug.com/592873.
   scoped_refptr<cc::LayerAnimationController> animation_controller_state_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_