Remove ui::LayerAnimationSequence::duration and ui::LayerAnimationElement::duration.

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"
@@ skipping 95 matching lines @@
   static LayerAnimationElement* CreatePauseElement(
       const AnimatableProperties& properties,
       base::TimeDelta duration);
 
   // Creates an element that transitions to the given color. The caller owns the
   // return value.
   static LayerAnimationElement* CreateColorElement(
       SkColor color,
       base::TimeDelta duration);
 
-  // Updates the delegate to the appropriate value for |t|, which is in the
-  // range [0, 1] (0 for initial, and 1 for final). If the animation is not
-  // aborted, it is guaranteed that Progress will eventually be called with
-  // t = 1.0. Returns true if a redraw is required.
-  bool Progress(double t, LayerAnimationDelegate* delegate);
+  // Updates the delegate to the appropriate value for |elapsed|. Returns true
+  // if a redraw is required.
+  bool Progress(base::TimeDelta elapsed, LayerAnimationDelegate* delegate);
+
+  // If calling Progress now, with the given elapsed time, will finish the
+  // animation, returns true and sets |total_duration| to the actual duration
+  // for this animation, incuding any queueing delays.
+  bool IsFinished(base::TimeDelta elapsed, 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();
 
   // Assigns the target value to |target|.
   void GetTargetValue(TargetValue* target) const;
 
   // The properties that the element modifies.
   const AnimatableProperties& properties() const { return properties_; }
 
-  // The duration of the animation
-  base::TimeDelta duration() const { return duration_; }
-
   Tween::Type tween_type() const { return tween_type_; }
   void set_tween_type(Tween::Type tween_type) { tween_type_ = tween_type; }
 
  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;
 
  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_;
   const base::TimeDelta duration_;
   Tween::Type tween_type_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_