Thread ui opacity animations

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>
 
@@ skipping 95 matching lines @@
 
   // Start an animation sequence. If an animation for the same property is in
   // progress, it needs to be interrupted with the new animation. The animator
   // takes ownership of this animation sequence.
   void StartAnimation(LayerAnimationSequence* animation);
 
   // Schedule an animation to be run when possible. The animator takes ownership
   // of this animation sequence.
   void ScheduleAnimation(LayerAnimationSequence* animation);
 
-  // Starts the animations to be run together. Obviously will not work if
-  // they animate any common properties. The animator takes ownership of the
+  // Starts the animations to be run together, ensuring that the first elements
+  // in these sequences have the same effective start time even when some of
+  // them start on the compositor thread (but there is no such guarantee for
+  // the effective start time of subsequent elements). Obviously will not work
+  // if they animate any common properties. The animator takes ownership of the
   // animation sequences. Takes PreemptionStrategy into account.
   void StartTogether(const std::vector<LayerAnimationSequence*>& animations);
 
-  // Schedules the animations to be run together. Obviously will not work if
-  // they animate any common properties. The animator takes ownership of the
-  // animation sequences.
+  // Schedules the animations to be run together, ensuring that the first
+  // elements in these sequences have the same effective start time even when
+  // some of them start on the compositor thread (but there is no such guarantee
+  // for the effective start time of subsequent elements). Obviously will not
+  // work if they animate any common properties. The animator takes ownership
+  // of the animation sequences.
   void ScheduleTogether(const std::vector<LayerAnimationSequence*>& animations);
 
   // Schedules a pause for length |duration| of all the specified properties.
   // End the list with -1.
   void SchedulePauseForProperties(
       base::TimeDelta duration,
       LayerAnimationElement::AnimatableProperty property,
       ...);
 
   // Returns true if there is an animation in the queue (animations remain in
@@ skipping 18 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);
+
   // 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(Tween::Type tween_type) { tween_type_ = tween_type; }
   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 19 matching lines @@
 
   // When set to true, all animations complete immediately.
   static void set_disable_animations_for_test(bool disable_animations) {
     disable_animations_for_test_ = disable_animations;
   }
 
   static bool disable_animations_for_test() {
     return disable_animations_for_test_;
   }
 
+  // Allows tests to access sequences owned by the animator.
+  class TestController {

[sky, 2013/02/19 17:06:56]

If this is only for tests move it into its own file so that its compiled only
for tests.

[ajuma, 2013/02/20 16:09:10]

Moved to ui/compositor/test/layer_animator_test_controller.h.

+   public:
+    TestController(scoped_refptr<LayerAnimator> animator);
+
+    ~TestController();
+
+    LayerAnimator* animator() { return animator_.get(); }
+
+    // Returns the running sequence animating the given property, if any.
+    LayerAnimationSequence* GetRunningSequence(
+        LayerAnimationElement::AnimatableProperty property);
+
+   private:
+    scoped_refptr<LayerAnimator> animator_;
+  };
+
  protected:
   virtual ~LayerAnimator();
 
   LayerAnimationDelegate* delegate() { return delegate_; }
   const LayerAnimationDelegate* delegate() const { return delegate_; }
 
   // Virtual for testing.
   virtual void ProgressAnimation(LayerAnimationSequence* sequence,
                                  base::TimeTicks now);
 
   void ProgressAnimationToEnd(LayerAnimationSequence* sequence);
 
   // Returns true if the sequence is owned by this animator.
   bool HasAnimation(LayerAnimationSequence* sequence) const;
 
  private:
   friend class base::RefCounted<LayerAnimator>;
   friend class ScopedLayerAnimationSettings;
+  friend class LayerAnimator::TestController;
 
   class RunningAnimation {
    public:
     RunningAnimation(const base::WeakPtr<LayerAnimationSequence>& sequence);
     ~RunningAnimation();
 
     bool is_sequence_alive() const { return !!sequence_; }
     LayerAnimationSequence* sequence() const { return sequence_.get(); }
 
    private:
@@ skipping 132 matching lines @@
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_