Refactors animation to allow for cleaner subclassing. I'm doing this

app/animation.cc

 // Copyright (c) 2010 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 "app/animation.h"
 
-#include "app/animation_container.h"
+#include "app/tween.h"
 #include "gfx/rect.h"
 
 #if defined(OS_WIN)
 #include "base/win_util.h"
 #endif
 
-using base::Time;
-using base::TimeDelta;
-
-Animation::Animation(int frame_rate,
-                     AnimationDelegate* delegate)
-  : animating_(false),
-    frame_rate_(frame_rate),
-    timer_interval_(CalculateInterval(frame_rate)),
-    state_(0.0),
-    delegate_(delegate) {
-}
-
-Animation::Animation(int duration,
-                     int frame_rate,
-                     AnimationDelegate* delegate)
-  : animating_(false),
-    frame_rate_(frame_rate),
-    timer_interval_(CalculateInterval(frame_rate)),
-    duration_(TimeDelta::FromMilliseconds(duration)),
-    state_(0.0),
-    delegate_(delegate) {
-
-  SetDuration(duration);
+Animation::Animation(base::TimeDelta timer_interval)
+    : timer_interval_(timer_interval),
+      is_animating_(false),
+      delegate_(NULL) {
 }
 
 Animation::~Animation() {
-  if (animating_)
+  // Don't send out notification from the destructor. Chances are the delegate
+  // owns us and is being deleted as well.
+  if (is_animating_)
     container_->Stop(this);
 }
 
-double Animation::GetCurrentValue() const {
-  // Default is linear relationship, subclass to adapt.
-  return state_;
+void Animation::Start() {
+  if (is_animating_)
+    return;
+
+  if (!container_.get())
+    container_ = new AnimationContainer();
+
+  is_animating_ = true;
+
+  container_->Start(this);
+
+  AnimationStarted();
+}
+
+void Animation::Stop() {
+  if (!is_animating_)
+    return;
+
+  is_animating_ = false;
+
+  // Notify the container first as the delegate may delete us.
+  container_->Stop(this);
+
+  AnimationStopped();
+
+  if (delegate_) {
+    if (ShouldSendCanceledFromStop())
+      delegate_->AnimationCanceled(this);
+    else
+      delegate_->AnimationEnded(this);
+  }
 }
 
 double Animation::CurrentValueBetween(double start, double target) const {
-  return start + (target - start) * GetCurrentValue();
+  return Tween::ValueBetween(GetCurrentValue(), start, target);
 }
 
 int Animation::CurrentValueBetween(int start, int target) const {
-  return static_cast<int>(CurrentValueBetween(static_cast<double>(start),
-                                              static_cast<double>(target)));
+  return Tween::ValueBetween(GetCurrentValue(), start, target);
+
 }
 
 gfx::Rect Animation::CurrentValueBetween(const gfx::Rect& start_bounds,
                                          const gfx::Rect& target_bounds) const {
-  return gfx::Rect(CurrentValueBetween(start_bounds.x(), target_bounds.x()),
-                   CurrentValueBetween(start_bounds.y(), target_bounds.y()),
-                   CurrentValueBetween(start_bounds.width(),
-                                       target_bounds.width()),
-                   CurrentValueBetween(start_bounds.height(),
-                                       target_bounds.height()));
+  return Tween::ValueBetween(GetCurrentValue(), start_bounds, target_bounds);
 }
 
-void Animation::Start() {
-  if (!animating_) {
-    if (!container_.get())
-      container_ = new AnimationContainer();
+void Animation::SetContainer(AnimationContainer* container) {
+  if (container == container_.get())
+    return;
 
-    animating_ = true;
-
-    container_->Start(this);
-
-    if (delegate_)
-      delegate_->AnimationStarted(this);
-  }
-}
-
-void Animation::Stop() {
-  if (animating_) {
-    animating_ = false;
-
-    // Notify the container first as the delegate may delete us.
+  if (is_animating_)
     container_->Stop(this);
 
-    if (delegate_) {
-      if (state_ >= 1.0)
-        delegate_->AnimationEnded(this);
-      else
-        delegate_->AnimationCanceled(this);
-    }
-  }
-}
+  if (container)
+    container_ = container;
+  else
+    container_ = new AnimationContainer();
 
-void Animation::End() {
-  if (animating_) {
-    animating_ = false;
-
-    // Notify the container first as the delegate may delete us.
-    container_->Stop(this);
-
-    AnimateToState(1.0);
-    if (delegate_)
-      delegate_->AnimationEnded(this);
-  }
-}
-
-bool Animation::IsAnimating() const {
-  return animating_;
-}
-
-void Animation::SetDuration(int duration) {
-  duration_ = TimeDelta::FromMilliseconds(duration);
-  if (duration_ < timer_interval_)
-    duration_ = timer_interval_;
-  if (animating_)
-    start_time_ = container_->last_tick_time();
+  if (is_animating_)
+    container_->Start(this);
 }
 
 // static
 bool Animation::ShouldRenderRichAnimation() {
 #if defined(OS_WIN)
   if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA) {
     BOOL result;
     // Get "Turn off all unnecessary animations" value.
     if (::SystemParametersInfo(SPI_GETCLIENTAREAANIMATION, 0, &result, 0)) {
       // There seems to be a typo in the MSDN document (as of May 2009):
       //   http://msdn.microsoft.com/en-us/library/ms724947(VS.85).aspx
       // The document states that the result is TRUE when animations are
       // _disabled_, but in fact, it is TRUE when they are _enabled_.
       return !!result;
     }
   }
   return !::GetSystemMetrics(SM_REMOTESESSION);
 #endif
   return true;
 }
 
-void Animation::SetContainer(AnimationContainer* container) {
-  if (container == container_.get())
-    return;
-
-  if (animating_)
-    container_->Stop(this);
-
-  if (container)
-    container_ = container;
-  else
-    container_ = new AnimationContainer();
-
-  if (animating_)
-    container_->Start(this);
+void Animation::SetStartTime(base::TimeTicks start_time) {
+  start_time_ = start_time;
 }
-
-void Animation::Step(base::TimeTicks time_now) {
-  TimeDelta elapsed_time = time_now - start_time_;
-  state_ = static_cast<double>(elapsed_time.InMicroseconds()) /
-           static_cast<double>(duration_.InMicroseconds());
-  if (state_ >= 1.0)
-    state_ = 1.0;
-
-  AnimateToState(state_);
-
-  if (delegate_)
-    delegate_->AnimationProgressed(this);
-
-  if (state_ == 1.0)
-    Stop();
-}
-
-TimeDelta Animation::CalculateInterval(int frame_rate) {
-  int timer_interval = 1000000 / frame_rate;
-  if (timer_interval < 10000)
-    timer_interval = 10000;
-  return TimeDelta::FromMicroseconds(timer_interval);
-}