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

app/slide_animation.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// 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/slide_animation.h"
 
 #include <math.h>
 
 // How many frames per second to target.
 static const int kDefaultFramerateHz = 50;
 
 // How long animations should take by default.
 static const int kDefaultDurationMs = 120;
 
 SlideAnimation::SlideAnimation(AnimationDelegate* target)
-    : Animation(kDefaultFramerateHz, target),
+    : LinearAnimation(kDefaultFramerateHz, target),
       target_(target),
-      tween_type_(EASE_OUT),
+      tween_type_(Tween::EASE_OUT),
       showing_(false),
       value_start_(0),
       value_end_(0),
       value_current_(0),
       slide_duration_(kDefaultDurationMs) {
 }
 
 SlideAnimation::~SlideAnimation() {
 }
 
@@ skipping 48 matching lines @@
 
   // This will also reset the currently-occuring animation.
   SetDuration(static_cast<int>(slide_duration_ * value_current_));
   Start();
 }
 
 void SlideAnimation::AnimateToState(double state) {
   if (state > 1.0)
     state = 1.0;
 
-  // Make our animation ease-out.
-  switch (tween_type_) {
-    case EASE_IN:
-      state = pow(state, 2);
-      break;
-    case EASE_IN_OUT:
-      if (state < 0.5)
-        state = pow(state * 2, 2) / 2.0;
-      else
-        state = 1.0 - (pow((state - 1.0) * 2, 2) / 2.0);
-      break;
-    case FAST_IN_OUT:
-      state = (pow(state - 0.5, 3) + 0.125) / 0.25;
-      break;
-    case NONE:
-      // state remains linear.
-      break;
-    case EASE_OUT_SNAP:
-      state = 0.95 * (1.0 - pow(1.0 - state, 2));
-      break;
-    case EASE_OUT:
-    default:
-      state = 1.0 - pow(1.0 - state, 2);
-      break;
-  }
+  state = Tween::CalculateValue(tween_type_, state);
 
   value_current_ = value_start_ + (value_end_ - value_start_) * state;
 
   // Implement snapping.
-  if (tween_type_ == EASE_OUT_SNAP && fabs(value_current_ - value_end_) <= 0.06)
+  if (tween_type_ == Tween::EASE_OUT_SNAP &&
+      fabs(value_current_ - value_end_) <= 0.06)
     value_current_ = value_end_;
 
   // Correct for any overshoot (while state may be capped at 1.0, let's not
   // take any rounding error chances.
   if ((value_end_ >= value_start_ && value_current_ > value_end_) ||
       (value_end_ < value_start_ && value_current_ < value_end_)) {
     value_current_ = value_end_;
   }
 }