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

chrome/browser/views/browser_actions_container.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 "chrome/browser/views/browser_actions_container.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/stl_util-inl.h"
@@ skipping 934 matching lines @@
     // Some icons were hidden, don't increase the size of the container.
     OnBrowserActionVisibilityChanged();
   } else {
     // Container was at max, increase the size of it by one icon.
     int target_size = IconCountToWidth(visible_actions + 1);
 
     // We don't want the chevron to appear while we animate. See documentation
     // in the header for why we do this.
     suppress_chevron_ = !chevron_->IsVisible();
 
-    Animate(SlideAnimation::NONE, target_size);
+    Animate(Tween::LINEAR, target_size);
   }
 }
 
 void BrowserActionsContainer::BrowserActionRemoved(Extension* extension) {
   CloseOverflowMenu();
 
   if (popup_ && popup_->host()->extension() == extension)
     HidePopup();
 
   // Before we change anything, determine the number of visible browser
@@ skipping 17 matching lines @@
       // header.
 
       // Calculate the target size we'll animate to (end state). This might be
       // the same size (if the icon we are removing is in the overflow bucket
       // and there are other icons there). We don't decrement visible_actions
       // because we want the container to stay the same size (clamping will take
       // care of shrinking the container if there aren't enough icons to show).
       int target_size =
           ClampToNearestIconCount(IconCountToWidth(visible_actions), true);
 
-      Animate(SlideAnimation::EASE_OUT, target_size);
+      Animate(Tween::EASE_OUT, target_size);
       return;
     }
   }
 }
 
 void BrowserActionsContainer::BrowserActionMoved(Extension* extension,
                                                  int index) {
   if (!ShouldDisplayBrowserAction(extension))
     return;
 
@@ skipping 37 matching lines @@
 
   int icon_width = kButtonSize + kBrowserActionButtonPadding;
 
   return WidthOfNonIconArea() + (icons * icon_width);
 }
 
 int BrowserActionsContainer::ContainerMinSize() const {
   return resize_gripper_->width() + chevron_->width() + kChevronRightMargin;
 }
 
-void BrowserActionsContainer::Animate(
-    SlideAnimation::TweenType tween_type, int target_size) {
+void BrowserActionsContainer::Animate(Tween::Type tween_type, int target_size) {
   if (!disable_animations_during_testing_) {
     // Animate! We have to set the animation_target_size_ after calling Reset(),
     // because that could end up calling AnimationEnded which clears the value.
     resize_animation_->Reset();
     resize_animation_->SetTweenType(tween_type);
     animation_target_size_ = target_size;
     resize_animation_->Show();
   } else {
     animation_target_size_ = target_size;
     AnimationEnded(resize_animation_.get());
@@ skipping 23 matching lines @@
     int new_width = std::max(0, container_size_.width() - resize_amount);
     int max_width = ClampToNearestIconCount(-1, false);
     new_width = std::min(new_width, max_width);
 
     // Up until now we've only been modifying the resize_amount, but now it is
     // time to set the container size to the size we have resized to, but then
     // animate to the nearest icon count size (or down to min size if no icon).
     container_size_.set_width(new_width);
     animation_target_size_ = ClampToNearestIconCount(new_width, true);
     resize_animation_->Reset();
-    resize_animation_->SetTweenType(SlideAnimation::EASE_OUT);
+    resize_animation_->SetTweenType(Tween::EASE_OUT);
     resize_animation_->Show();
   }
 }
 
 void BrowserActionsContainer::AnimationProgressed(const Animation* animation) {
   DCHECK(animation == resize_animation_.get());
 
   double e = resize_animation_->GetCurrentValue();
   int difference = container_size_.width() - animation_target_size_;
 
@@ skipping 34 matching lines @@
   popup_ = NULL;
   popup_button_->SetButtonNotPushed();
   popup_button_ = NULL;
 }
 
 bool BrowserActionsContainer::ShouldDisplayBrowserAction(Extension* extension) {
   // Only display incognito-enabled extensions while in incognito mode.
   return (!profile_->IsOffTheRecord() ||
           profile_->GetExtensionsService()->IsIncognitoEnabled(extension));
 }