cc: Alow animations to be aborted from either thread

cc/animation/layer_animation_controller.h

 // Copyright 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 CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_
 #define CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
@@ skipping 20 matching lines @@
 class KeyframeValueList;
 class LayerAnimationValueObserver;
 
 class CC_EXPORT LayerAnimationController
     : public base::RefCounted<LayerAnimationController> {
  public:
   static scoped_refptr<LayerAnimationController> Create(int id);
 
   int id() const { return id_; }
 
-  // These methods are virtual for testing.
-  virtual void AddAnimation(scoped_ptr<Animation> animation);
-  virtual void PauseAnimation(int animation_id, double time_offset);
-  virtual void RemoveAnimation(int animation_id);
-  virtual void RemoveAnimation(int animation_id,
-                               Animation::TargetProperty target_property);
+  void AddAnimation(scoped_ptr<Animation> animation);
+  void PauseAnimation(int animation_id, double time_offset);
+  void RemoveAnimation(int animation_id);
+  void RemoveAnimation(int animation_id,
+                       Animation::TargetProperty target_property);

[ajuma, 2013/11/14 21:56:03]

These were marked "virtual for testing", but none of these seem to be overridden
anywhere.

[Ian Vollick, 2013/11/15 01:48:56]

Thanks for fixing up the comment/virts.

+  void AbortAnimations(Animation::TargetProperty target_property);
 
   // Ensures that the list of active animations on the main thread and the impl
   // thread are kept in sync. This function does not take ownership of the impl
-  // thread controller.
+  // thread controller. This method is virtual for testing.
   virtual void PushAnimationUpdatesTo(
       LayerAnimationController* controller_impl);
 
   void Animate(double monotonic_time);
   void AccumulatePropertyUpdates(double monotonic_time,
                                  AnimationEventsVector* events);
 
   void UpdateState(bool start_ready_animations,
                    AnimationEventsVector* events);
 
@@ skipping 22 matching lines @@
   // impl thread, all animations will be transferred.
   void set_force_sync() { force_sync_ = true; }
 
   void SetAnimationRegistrar(AnimationRegistrar* registrar);
   AnimationRegistrar* animation_registrar() { return registrar_; }
 
   void NotifyAnimationStarted(const AnimationEvent& event,
                               double wall_clock_time);
   void NotifyAnimationFinished(const AnimationEvent& event,
                                double wall_clock_time);
+  void NotifyAnimationAborted(const AnimationEvent& event);
   void NotifyAnimationPropertyUpdate(const AnimationEvent& event);
 
   void AddValueObserver(LayerAnimationValueObserver* observer);
   void RemoveValueObserver(LayerAnimationValueObserver* observer);
 
   void AddEventObserver(LayerAnimationEventObserver* observer);
   void RemoveEventObserver(LayerAnimationEventObserver* observer);
 
   void set_layer_animation_delegate(AnimationDelegate* delegate) {
     layer_animation_delegate_ = delegate;
@@ skipping 61 matching lines @@
   ObserverList<LayerAnimationEventObserver> event_observers_;
 
   AnimationDelegate* layer_animation_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_