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

chrome/browser/gtk/tabs/tab_strip_gtk.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/gtk/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
-#include "app/animation_delegate.h"
 #include "app/gtk_dnd_util.h"
 #include "app/resource_bundle.h"
-#include "app/slide_animation.h"
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/gtk/custom_button.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/gtk_util.h"
 #include "chrome/browser/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/themes/browser_theme_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "gfx/gtk_util.h"
 #include "gfx/point.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
+#include "ui/base/animation/animation_delegate.h"
+#include "ui/base/animation/slide_animation.h"
 
 namespace {
 
 const int kDefaultAnimationDurationMs = 100;
 const int kResizeLayoutAnimationDurationMs = 166;
 const int kReorderAnimationDurationMs = 166;
 const int kAnimateToBoundsDurationMs = 150;
 const int kMiniTabAnimationDurationMs = 150;
 
 const int kNewTabButtonHOffset = -5;
@@ skipping 53 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TabAnimation
 //
 //  A base class for all TabStrip animations.
 //
-class TabStripGtk::TabAnimation : public AnimationDelegate {
+class TabStripGtk::TabAnimation : public ui::AnimationDelegate {
  public:
   friend class TabStripGtk;
 
   // Possible types of animation.
   enum Type {
     INSERT,
     REMOVE,
     MOVE,
     RESIZE,
     MINI,
     MINI_MOVE
   };
 
   TabAnimation(TabStripGtk* tabstrip, Type type)
       : tabstrip_(tabstrip),
         animation_(this),
         start_selected_width_(0),
         start_unselected_width_(0),
         end_selected_width_(0),
         end_unselected_width_(0),
         layout_on_completion_(false),
         type_(type) {
   }
   virtual ~TabAnimation() {}
 
   Type type() const { return type_; }
 
   void Start() {
     animation_.SetSlideDuration(GetDuration());
-    animation_.SetTweenType(Tween::EASE_OUT);
+    animation_.SetTweenType(ui::Tween::EASE_OUT);
     if (!animation_.IsShowing()) {
       animation_.Reset();
       animation_.Show();
     }
   }
 
   void Stop() {
     animation_.Stop();
   }
 
@@ skipping 18 matching lines @@
 
     if (animation) {
       double specified_tab_width = animation->GetWidthForTab(index);
       if (specified_tab_width != -1)
         tab_width = specified_tab_width;
     }
 
     return tab_width;
   }
 
-  // Overridden from AnimationDelegate:
-  virtual void AnimationProgressed(const Animation* animation) {
+  // Overridden from ui::AnimationDelegate:
+  virtual void AnimationProgressed(const ui::Animation* animation) {
     tabstrip_->AnimationLayout(end_unselected_width_);
   }
 
-  virtual void AnimationEnded(const Animation* animation) {
+  virtual void AnimationEnded(const ui::Animation* animation) {
     tabstrip_->FinishAnimation(this, layout_on_completion_);
     // This object is destroyed now, so we can't do anything else after this.
   }
 
-  virtual void AnimationCanceled(const Animation* animation) {
+  virtual void AnimationCanceled(const ui::Animation* animation) {
     AnimationEnded(animation);
   }
 
   // Returns the gap before the tab at the specified index. Subclass if during
   // an animation you need to insert a gap before a tab.
   virtual double GetGapWidth(int index) {
     return 0;
   }
 
  protected:
@@ skipping 27 matching lines @@
       start_unselected_width_ -= minimum_tab_width / start_tab_count;
     }
 
     tabstrip_->GenerateIdealBounds();
     tabstrip_->GetDesiredTabWidths(end_tab_count, end_mini_count,
                                    &end_unselected_width_,
                                    &end_selected_width_);
   }
 
   TabStripGtk* tabstrip_;
-  SlideAnimation animation_;
+  ui::SlideAnimation animation_;
 
   double start_selected_width_;
   double start_unselected_width_;
   double end_selected_width_;
   double end_unselected_width_;
 
  private:
   // True if a complete re-layout is required upon completion of the animation.
   // Subclasses set this if they don't perform a complete layout
   // themselves and canceling the animation may leave the strip in an
@@ skipping 133 matching lines @@
     // the start of the animation.
     if (tab->IsSelected()) {
       double delta = end_selected_width_ - start_selected_width_;
       return start_selected_width_ + (delta * animation_.GetCurrentValue());
     }
 
     double delta = end_unselected_width_ - start_unselected_width_;
     return start_unselected_width_ + (delta * animation_.GetCurrentValue());
   }
 
-  virtual void AnimationEnded(const Animation* animation) {
+  virtual void AnimationEnded(const ui::Animation* animation) {
     tabstrip_->RemoveTabAt(index_);
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
  private:
   int index_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveTabAnimation);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Handles the movement of a Tab from one position to another.
 class MoveTabAnimation : public TabStripGtk::TabAnimation {
  public:
   MoveTabAnimation(TabStripGtk* tabstrip, int tab_a_index, int tab_b_index)
       : TabAnimation(tabstrip, MOVE),
         start_tab_a_bounds_(tabstrip_->GetIdealBounds(tab_b_index)),
         start_tab_b_bounds_(tabstrip_->GetIdealBounds(tab_a_index)) {
     tab_a_ = tabstrip_->GetTabAt(tab_a_index);
     tab_b_ = tabstrip_->GetTabAt(tab_b_index);
 
     // Since we don't do a full TabStrip re-layout, we need to force a full
     // layout upon completion since we're not guaranteed to be in a good state
     // if for example the animation is canceled.
     set_layout_on_completion(true);
   }
   virtual ~MoveTabAnimation() {}
 
-  // Overridden from AnimationDelegate:
-  virtual void AnimationProgressed(const Animation* animation) {
+  // Overridden from ui::AnimationDelegate:
+  virtual void AnimationProgressed(const ui::Animation* animation) {
     // Position Tab A
     double distance = start_tab_b_bounds_.x() - start_tab_a_bounds_.x();
     double delta = distance * animation_.GetCurrentValue();
     double new_x = start_tab_a_bounds_.x() + delta;
     gfx::Rect bounds(Round(new_x), start_tab_a_bounds_.y(), tab_a_->width(),
         tab_a_->height());
     tabstrip_->SetTabBounds(tab_a_, bounds);
 
     // Position Tab B
     distance = start_tab_a_bounds_.x() - start_tab_b_bounds_.x();
@@ skipping 29 matching lines @@
   explicit ResizeLayoutAnimation(TabStripGtk* tabstrip)
       : TabAnimation(tabstrip, RESIZE) {
     int tab_count = tabstrip->GetTabCount();
     int mini_tab_count = tabstrip->GetMiniTabCount();
     GenerateStartAndEndWidths(tab_count, tab_count, mini_tab_count,
                               mini_tab_count);
     InitStartState();
   }
   virtual ~ResizeLayoutAnimation() {}
 
-  // Overridden from AnimationDelegate:
-  virtual void AnimationEnded(const Animation* animation) {
+  // Overridden from ui::AnimationDelegate:
+  virtual void AnimationEnded(const ui::Animation* animation) {
     tabstrip_->needs_resize_layout_ = false;
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
  protected:
   // Overridden from TabStripGtk::TabAnimation:
   virtual int GetDuration() const {
     return kResizeLayoutAnimationDurationMs;
   }
 
@@ skipping 112 matching lines @@
     if (tabstrip->GetTabAt(to_index)->mini())
       start_mini_count--;
     else
       start_mini_count++;
     GenerateStartAndEndWidths(tab_count, tab_count, start_mini_count,
                               end_mini_count);
     target_bounds_ = tabstrip->GetIdealBounds(to_index);
     tab_->set_animating_mini_change(true);
   }
 
-  // Overridden from AnimationDelegate:
-  virtual void AnimationProgressed(const Animation* animation) {
+  // Overridden from ui::AnimationDelegate:
+  virtual void AnimationProgressed(const ui::Animation* animation) {
     // Do the normal layout.
     TabAnimation::AnimationProgressed(animation);
 
     // Then special case the position of the tab being moved.
     int x = animation_.CurrentValueBetween(start_bounds_.x(),
                                            target_bounds_.x());
     int width = animation_.CurrentValueBetween(start_bounds_.width(),
                                                target_bounds_.width());
     gfx::Rect tab_bounds(x, start_bounds_.y(), width,
                          start_bounds_.height());
     tabstrip_->SetTabBounds(tab_, tab_bounds);
   }
 
-  virtual void AnimationEnded(const Animation* animation) {
+  virtual void AnimationEnded(const ui::Animation* animation) {
     tabstrip_->needs_resize_layout_ = false;
     TabStripGtk::TabAnimation::AnimationEnded(animation);
   }
 
   virtual double GetGapWidth(int index) {
     if (to_index_ < from_index_) {
       // The tab was made mini.
       if (index == to_index_) {
         double current_size =
             animation_.CurrentValueBetween(0, target_bounds_.width());
@@ skipping 1421 matching lines @@
 
   // Let the middle mouse button initiate clicks as well.
   gtk_util::SetButtonTriggersNavigation(button->widget());
   g_signal_connect(button->widget(), "clicked",
                    G_CALLBACK(OnNewTabClickedThunk), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }