Move animation code to new ui/base/animation directory....

chrome/browser/ui/views/tabs/base_tab.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/tabs/base_tab.h"
 
 #include <limits>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "app/slide_animation.h"
 #include "app/theme_provider.h"
-#include "app/throb_animation.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "chrome/common/chrome_switches.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/favicon_size.h"
 #include "gfx/font.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
+#include "ui/base/animation/slide_animation.h"
+#include "ui/base/animation/throb_animation.h"
 #include "views/controls/button/image_button.h"
 
 // How long the pulse throb takes.
 static const int kPulseDurationMs = 200;
 
 // How long the hover state takes.
 static const int kHoverDurationMs = 400;
 
 namespace {
 
@@ skipping 37 matching lines @@
 
 // static
 gfx::Font* BaseTab::font_ = NULL;
 // static
 int BaseTab::font_height_ = 0;
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
-class BaseTab::FavIconCrashAnimation : public LinearAnimation,
-                                       public AnimationDelegate {
+class BaseTab::FavIconCrashAnimation : public ui::LinearAnimation,
+                                       public ui::AnimationDelegate {
  public:
   explicit FavIconCrashAnimation(BaseTab* target)
-      : ALLOW_THIS_IN_INITIALIZER_LIST(LinearAnimation(1000, 25, this)),
+      : ALLOW_THIS_IN_INITIALIZER_LIST(ui::LinearAnimation(1000, 25, this)),
         target_(target) {
   }
   virtual ~FavIconCrashAnimation() {}
 
-  // Animation overrides:
+  // ui::Animation overrides:
   virtual void AnimateToState(double state) {
     const double kHidingOffset = 27;
 
     if (state < .5) {
       target_->SetFavIconHidingOffset(
           static_cast<int>(floor(kHidingOffset * 2.0 * state)));
     } else {
       target_->DisplayCrashedFavIcon();
       target_->SetFavIconHidingOffset(
           static_cast<int>(
               floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
     }
   }
 
-  // AnimationDelegate overrides:
-  virtual void AnimationCanceled(const Animation* animation) {
+  // ui::AnimationDelegate overrides:
+  virtual void AnimationCanceled(const ui::Animation* animation) {
     target_->SetFavIconHidingOffset(0);
   }
 
  private:
   BaseTab* target_;
 
   DISALLOW_COPY_AND_ASSIGN(FavIconCrashAnimation);
 };
 
 BaseTab::BaseTab(TabController* controller)
@@ skipping 70 matching lines @@
     return;
   }
 
   TabRendererData::NetworkState old_state = data_.network_state;
   data_.network_state = state;
   AdvanceLoadingAnimation(old_state, state);
 }
 
 void BaseTab::StartPulse() {
   if (!pulse_animation_.get()) {
-    pulse_animation_.reset(new ThrobAnimation(this));
+    pulse_animation_.reset(new ui::ThrobAnimation(this));
     pulse_animation_->SetSlideDuration(kPulseDurationMs);
     if (animation_container_.get())
       pulse_animation_->SetContainer(animation_container_.get());
   }
   pulse_animation_->Reset();
   pulse_animation_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 void BaseTab::StopPulse() {
   if (!pulse_animation_.get())
     return;
 
   pulse_animation_->Stop();  // Do stop so we get notified.
   pulse_animation_.reset(NULL);
 }
 
 bool BaseTab::IsSelected() const {
   return controller() ? controller()->IsTabSelected(this) : true;
 }
 
 bool BaseTab::IsCloseable() const {
   return controller() ? controller()->IsTabCloseable(this) : true;
 }
 
 void BaseTab::OnMouseEntered(const views::MouseEvent& e) {
   if (!hover_animation_.get()) {
-    hover_animation_.reset(new SlideAnimation(this));
+    hover_animation_.reset(new ui::SlideAnimation(this));
     hover_animation_->SetContainer(animation_container_.get());
     hover_animation_->SetSlideDuration(kHoverDurationMs);
   }
-  hover_animation_->SetTweenType(Tween::EASE_OUT);
+  hover_animation_->SetTweenType(ui::Tween::EASE_OUT);
   hover_animation_->Show();
 }
 
 void BaseTab::OnMouseExited(const views::MouseEvent& e) {
-  hover_animation_->SetTweenType(Tween::EASE_IN);
+  hover_animation_->SetTweenType(ui::Tween::EASE_IN);
   hover_animation_->Hide();
 }
 
 bool BaseTab::OnMousePressed(const views::MouseEvent& event) {
   if (!controller())
     return false;
 
   if (event.IsOnlyLeftMouseButton()) {
     // Store whether or not we were selected just now... we only want to be
     // able to drag foreground tabs, so we don't start dragging the tab if
@@ skipping 157 matching lines @@
         TabContents::GetDefaultTitle();
   } else {
     Browser::FormatTitleForDisplay(&title);
   }
 
   canvas->DrawStringInt(UTF16ToWideHack(title), *font_, title_color,
                         title_bounds().x(), title_bounds().y(),
                         title_bounds().width(), title_bounds().height());
 }
 
-void BaseTab::AnimationProgressed(const Animation* animation) {
+void BaseTab::AnimationProgressed(const ui::Animation* animation) {
   SchedulePaint();
 }
 
-void BaseTab::AnimationCanceled(const Animation* animation) {
+void BaseTab::AnimationCanceled(const ui::Animation* animation) {
   SchedulePaint();
 }
 
-void BaseTab::AnimationEnded(const Animation* animation) {
+void BaseTab::AnimationEnded(const ui::Animation* animation) {
   SchedulePaint();
 }
 
 void BaseTab::ButtonPressed(views::Button* sender, const views::Event& event) {
   DCHECK(sender == close_button_);
   controller()->CloseTab(this);
 }
 
 void BaseTab::ShowContextMenu(views::View* source,
                               const gfx::Point& p,
@@ skipping 35 matching lines @@
 // static
 void BaseTab::InitResources() {
   static bool initialized = false;
   if (!initialized) {
     initialized = true;
     font_ = new gfx::Font(
         ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont));
     font_height_ = font_->GetHeight();
   }
 }