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

ui/compositor/layer_animator.cc

 // 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.
 
 #include "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
@@ skipping 315 matching lines @@
 
 void LayerAnimator::ProgressAnimation(LayerAnimationSequence* sequence,
                                       base::TimeDelta delta) {
   if (!delegate())
     return;
 
   sequence->Progress(delta, delegate());
 }
 
 void LayerAnimator::ProgressAnimationToEnd(LayerAnimationSequence* sequence) {
-  ProgressAnimation(sequence, sequence->duration());
+  if (!delegate())
+    return;
+
+  sequence->ProgressToEnd(delegate());
 }
 
 
 bool LayerAnimator::HasAnimation(LayerAnimationSequence* sequence) const {
   for (AnimationQueue::const_iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     if ((*queue_iter).get() == sequence)
       return true;
   }
   return false;
@@ skipping 11 matching lines @@
 
   // We need to make a copy of the running animations because progressing them
   // and finishing them may indirectly affect the collection of running
   // animations.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
     base::TimeDelta delta = now - running_animations_copy[i].start_time();
-    if (delta >= running_animations_copy[i].sequence()->duration() &&
-        !running_animations_copy[i].sequence()->is_cyclic()) {
+    if (running_animations_copy[i].sequence()->IsFinished(delta)) {
       SAFE_INVOKE_VOID(FinishAnimation, running_animations_copy[i]);
     } else
       SAFE_INVOKE_VOID(ProgressAnimation, running_animations_copy[i], delta);
   }
 }
 
 void LayerAnimator::SetStartTime(base::TimeTicks start_time) {
   // Do nothing.
 }
 
@@ skipping 36 matching lines @@
       break;
     }
   }
 
   return to_return.release();
 }
 
 void LayerAnimator::FinishAnimation(LayerAnimationSequence* sequence) {
   scoped_refptr<LayerAnimator> retain(this);
   scoped_ptr<LayerAnimationSequence> removed(RemoveAnimation(sequence));
-  if (delegate())
-    sequence->Progress(sequence->duration(), delegate());
+  ProgressAnimationToEnd(sequence);
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::FinishAnyAnimationWithZeroDuration() {
   scoped_refptr<LayerAnimator> retain(this);
   // Special case: if we've started a 0 duration animation, just finish it now
   // and get rid of it. We need to make a copy because Progress may indirectly
   // cause new animations to start running.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
       continue;
 
-    if (running_animations_copy[i].sequence()->duration() ==
-        base::TimeDelta()) {
+    if (running_animations_copy[i].sequence()->IsFinished(base::TimeDelta())) {
       SAFE_INVOKE_VOID(ProgressAnimationToEnd, running_animations_copy[i]);
       scoped_ptr<LayerAnimationSequence> removed(
           SAFE_INVOKE_PTR(RemoveAnimation, running_animations_copy[i]));
     }
   }
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::ClearAnimations() {
@@ skipping 79 matching lines @@
   const bool abort = false;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
   if (!weak_sequence_ptr)
     return;
 
   LayerAnimationSequence* removed = RemoveAnimation(sequence);
   DCHECK(removed == NULL || removed == sequence);
   if (!weak_sequence_ptr)
     return;
 
-  ProgressAnimation(sequence, sequence->duration());
+  ProgressAnimationToEnd(sequence);
   if (!weak_sequence_ptr)
     return;
 
   delete sequence;
 }
 
 void LayerAnimator::ImmediatelyAnimateToNewTarget(
     LayerAnimationSequence* sequence) {
   // Need to detect if our sequence gets destroyed.
   base::WeakPtr<LayerAnimationSequence> weak_sequence_ptr =
@@ skipping 195 matching lines @@
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence,
     base::TimeTicks start_time)
     : sequence_(sequence),
       start_time_(start_time) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui