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

app/animation.cc

Index: app/animation.cc
diff --git a/app/animation.cc b/app/animation.cc
index 5e9d10cf75bcc9b3818fe97b0b49f5a846527418..2dc2bcf6bce0ebf8d12320701987fba75170e7b9 100644
--- a/app/animation.cc
+++ b/app/animation.cc
@@ -4,120 +4,87 @@
 
 #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;
 
-double Animation::CurrentValueBetween(double start, double target) const {
-  return start + (target - start) * GetCurrentValue();
-}
+  if (!container_.get())
+    container_ = new AnimationContainer();
 
-int Animation::CurrentValueBetween(int start, int target) const {
-  return static_cast<int>(CurrentValueBetween(static_cast<double>(start),
-                                              static_cast<double>(target)));
-}
+  is_animating_ = true;
 
-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()));
+  container_->Start(this);
+
+  AnimationStarted();
 }
 
-void Animation::Start() {
-  if (!animating_) {
-    if (!container_.get())
-      container_ = new AnimationContainer();
+void Animation::Stop() {
+  if (!is_animating_)
+    return;
 
-    animating_ = true;
+  is_animating_ = false;
 
-    container_->Start(this);
+  // Notify the container first as the delegate may delete us.
+  container_->Stop(this);
 
-    if (delegate_)
-      delegate_->AnimationStarted(this);
+  AnimationStopped();
+
+  if (delegate_) {
+    if (ShouldSendCanceledFromStop())
+      delegate_->AnimationCanceled(this);
+    else
+      delegate_->AnimationEnded(this);
   }
 }
 
-void Animation::Stop() {
-  if (animating_) {
-    animating_ = false;
+double Animation::CurrentValueBetween(double start, double target) const {
+  return Tween::ValueBetween(GetCurrentValue(), start, target);
+}
 
-    // Notify the container first as the delegate may delete us.
-    container_->Stop(this);
+int Animation::CurrentValueBetween(int start, int target) const {
+  return Tween::ValueBetween(GetCurrentValue(), start, target);
 
-    if (delegate_) {
-      if (state_ >= 1.0)
-        delegate_->AnimationEnded(this);
-      else
-        delegate_->AnimationCanceled(this);
-    }
-  }
 }
 
-void Animation::End() {
-  if (animating_) {
-    animating_ = false;
+gfx::Rect Animation::CurrentValueBetween(const gfx::Rect& start_bounds,
+                                         const gfx::Rect& target_bounds) const {
+  return Tween::ValueBetween(GetCurrentValue(), start_bounds, target_bounds);
+}
 
-    // Notify the container first as the delegate may delete us.
-    container_->Stop(this);
+void Animation::SetContainer(AnimationContainer* container) {
+  if (container == container_.get())
+    return;
 
-    AnimateToState(1.0);
-    if (delegate_)
-      delegate_->AnimationEnded(this);
-  }
-}
+  if (is_animating_)
+    container_->Stop(this);
 
-bool Animation::IsAnimating() const {
-  return animating_;
-}
+  if (container)
+    container_ = container;
+  else
+    container_ = new AnimationContainer();
 
-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
@@ -139,41 +106,6 @@ bool Animation::ShouldRenderRichAnimation() {
   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::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);
+void Animation::SetStartTime(base::TimeTicks start_time) {
+  start_time_ = start_time;
 }