Thread ui opacity animations

ui/compositor/layer_animation_element.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_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <set>
 
 #include "base/time.h"
+#include "cc/animation.h"
+#include "cc/animation_events.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/animation/tween.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 class InterpolatedTransform;
 class LayerAnimationDelegate;
 
 // LayerAnimationElements represent one segment of an animation between two
 // keyframes. They know how to update a LayerAnimationDelegate given a value
 // between 0 and 1 (0 for initial, and 1 for final).
 class COMPOSITOR_EXPORT LayerAnimationElement {
  public:
   enum AnimatableProperty {
     TRANSFORM = 0,
     BOUNDS,
     OPACITY,
     VISIBILITY,
     BRIGHTNESS,
     GRAYSCALE,
     COLOR,
   };
 
+  static AnimatableProperty ToAnimatableProperty(
+      cc::Animation::TargetProperty property);
+
   struct COMPOSITOR_EXPORT TargetValue {
     TargetValue();
     // Initializes the target value to match the delegate. NULL may be supplied.
     explicit TargetValue(const LayerAnimationDelegate* delegate);
 
     gfx::Rect bounds;
     gfx::Transform transform;
     float opacity;
     bool visibility;
     float brightness;
@@ skipping 62 matching lines @@
 
   // Creates an element that transitions to the given color. The caller owns the
   // return value.
   static LayerAnimationElement* CreateColorElement(
       SkColor color,
       base::TimeDelta duration);
 
   // Sets the start time for the animation. This must be called before the first
   // call to {Progress, IsFinished}. Once the animation is finished, this must
   // be called again in order to restart the animation.
-  void set_start_time(base::TimeTicks start_time) { start_time_ = start_time; }
-  base::TimeTicks start_time() const { return start_time_; }
+  void set_requested_start_time(base::TimeTicks start_time) {
+    requested_start_time_ = start_time;
+  }
+  base::TimeTicks requested_start_time() const { return requested_start_time_; }
+
+  // Sets the actual start time for the animation, taking into account any
+  // queueing delays.
+  void set_effective_start_time(base::TimeTicks start_time) {
+    effective_start_time_ = start_time;
+  }
+
+  // If starting the animation involves dispatching to another thread, then
+  // proceed with that dispatch; this will ultimately result in the animation
+  // getting an effective start time (the time the animation starts on the other
+  // thread).
+  void ProgressToEffectiveStart(LayerAnimationDelegate* delegate);

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

Can this be called Start() and always invoked? Internally it could do whatever
is appropriate based on if threaded or not.

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

Done. I've similarly renamed LayerAnimationSequence::ProgressToEffectiveStart to
Start() and required that it is always invoked.

 
   // Updates the delegate to the appropriate value for |now|. Returns true
   // if a redraw is required.
   bool Progress(base::TimeTicks now, LayerAnimationDelegate* delegate);
 
   // If calling Progress now, with the given time, will finish the animation,
   // returns true and sets |end_duration| to the actual duration for this
   // animation, incuding any queueing delays.
   bool IsFinished(base::TimeTicks time, base::TimeDelta* total_duration);
 
   // Updates the delegate to the end of the animation. Returns true if a
   // redraw is required.
   bool ProgressToEnd(LayerAnimationDelegate* delegate);
 
   // Called if the animation is not allowed to complete. This may be called
   // before OnStarted or Progress.
-  void Abort();
+  void Abort(LayerAnimationDelegate* delegate);
 
   // Assigns the target value to |target|.
   void GetTargetValue(TargetValue* target) const;
 
   // The properties that the element modifies.
   const AnimatableProperties& properties() const { return properties_; }
 
+  // Whether this element animates on the compositor thread.
+  virtual bool IsThreaded() const;
+
   Tween::Type tween_type() const { return tween_type_; }
   void set_tween_type(Tween::Type tween_type) { tween_type_ = tween_type; }
 
+  // Used to identify animations.

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

These need better descriptions. In particular how the two differ and what
they're used for. 

If possible, can animation_id_ be a const and set in the constructor?

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

Done. 
Done.

+  int animation_id() const { return animation_id_; }
+  void set_animation_id(int id) { animation_id_ = id; }
+  int animation_group_id() const { return animation_group_id_; }
+  void set_animation_group_id(int id) { animation_group_id_ = id; }
+
+  // The fraction of the animation that has been completed after the last
+  // call made to {Progress, ProgressToEnd}.
+  double last_progressed_fraction() const { return last_progressed_fraction_; }
+
  protected:
   // Called once each time the animation element is run before any call to
   // OnProgress.
   virtual void OnStart(LayerAnimationDelegate* delegate) = 0;
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) = 0;
   virtual void OnGetTarget(TargetValue* target) const = 0;
-  virtual void OnAbort() = 0;
+  virtual void OnAbort(LayerAnimationDelegate* delegate) = 0;
+
+  base::TimeDelta duration() const { return duration_; }
+
+  // Actually start the animation, dispatching to another thread if needed.
+  virtual void RequestEffectiveStart(LayerAnimationDelegate* delegate);
 
  private:
   // For debugging purposes, we sometimes alter the duration we actually use.
   // For example, during tests we often set duration = 0, and it is sometimes
   // useful to slow animations down to see them more clearly.
   base::TimeDelta GetEffectiveDuration(const base::TimeDelta& delta);
 
   bool first_frame_;
   const AnimatableProperties properties_;
-  base::TimeTicks start_time_;
+  base::TimeTicks requested_start_time_;
+
+  // When the animation actually started, taking into account queueing delays.
+  base::TimeTicks effective_start_time_;
   const base::TimeDelta duration_;
   Tween::Type tween_type_;
 
+  int animation_id_;
+  int animation_group_id_;
+
+  double last_progressed_fraction_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_