ui/base/animation -> ui/gfx/animation

chrome/browser/ui/views/tabs/tab.cc

 // Copyright (c) 2012 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/ui/views/tabs/tab.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_resources.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "chrome/browser/ui/views/theme_image_mapper.h"
 #include "chrome/browser/ui/views/touch_uma/touch_uma.h"
 #include "chrome/common/chrome_switches.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/accessibility/accessible_view_state.h"
-#include "ui/base/animation/animation_container.h"
-#include "ui/base/animation/multi_animation.h"
-#include "ui/base/animation/slide_animation.h"
-#include "ui/base/animation/throb_animation.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
+#include "ui/gfx/animation/animation_container.h"
+#include "ui/gfx/animation/multi_animation.h"
+#include "ui/gfx/animation/slide_animation.h"
+#include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
@@ skipping 261 matching lines @@
   return chrome::GetHostDesktopTypeForNativeView(
       widget ? widget->GetNativeView() : NULL);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
-class Tab::FaviconCrashAnimation : public ui::LinearAnimation,
-                                   public ui::AnimationDelegate {
+class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
+                                   public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
-      : ui::LinearAnimation(1000, 25, this),
+      : gfx::LinearAnimation(1000, 25, this),
         target_(target) {
   }
   virtual ~FaviconCrashAnimation() {}
 
-  // ui::Animation overrides:
+  // gfx::Animation overrides:
   virtual void AnimateToState(double state) OVERRIDE {
     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))));
     }
   }
 
-  // ui::AnimationDelegate overrides:
-  virtual void AnimationCanceled(const ui::Animation* animation) OVERRIDE {
+  // gfx::AnimationDelegate overrides:
+  virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE {
     target_->SetFaviconHidingOffset(0);
   }
 
  private:
   Tab* target_;
 
   DISALLOW_COPY_AND_ASSIGN(FaviconCrashAnimation);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 139 matching lines @@
   AddChildView(close_button_);
 
   set_context_menu_controller(this);
 
   tab_audio_indicator_.reset(new TabAudioIndicator(this));
 }
 
 Tab::~Tab() {
 }
 
-void Tab::set_animation_container(ui::AnimationContainer* container) {
+void Tab::set_animation_container(gfx::AnimationContainer* container) {
   animation_container_ = container;
   hover_controller_.SetAnimationContainer(container);
   tab_audio_indicator_->SetAnimationContainer(container);
 }
 
 bool Tab::IsActive() const {
   return controller() ? controller()->IsActiveTab(this) : true;
 }
 
 bool Tab::IsSelected() const {
@@ skipping 58 matching lines @@
     // need to advance the animation frame.
     return;
   }
 
   TabRendererData::NetworkState old_state = data_.network_state;
   data_.network_state = state;
   AdvanceLoadingAnimation(old_state, state);
 }
 
 void Tab::StartPulse() {
-  ui::ThrobAnimation* animation = new ui::ThrobAnimation(this);
+  gfx::ThrobAnimation* animation = new gfx::ThrobAnimation(this);
   animation->SetSlideDuration(kPulseDurationMs);
   if (animation_container_.get())
     animation->SetContainer(animation_container_.get());
   animation->StartThrobbing(std::numeric_limits<int>::max());
   tab_animation_.reset(animation);
 }
 
 void Tab::StopPulse() {
   if (!tab_animation_.get())
     return;
   tab_animation_->Stop();
   tab_animation_.reset(NULL);
 }
 
 void Tab::StartMiniTabTitleAnimation() {
   // We can only do this animation if the tab is mini because we will
   // upcast tab_animation back to MultiAnimation when we draw.
   if (!data().mini)
     return;
   if (!tab_animation_.get()) {
-    ui::MultiAnimation::Parts parts;
+    gfx::MultiAnimation::Parts parts;
     parts.push_back(
-        ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration1MS,
-                                 ui::Tween::EASE_OUT));
+        gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration1MS,
+                                 gfx::Tween::EASE_OUT));
     parts.push_back(
-        ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration2MS,
-                                 ui::Tween::ZERO));
+        gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration2MS,
+                                 gfx::Tween::ZERO));
     parts.push_back(
-        ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration3MS,
-                                 ui::Tween::EASE_IN));
+        gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration3MS,
+                                 gfx::Tween::EASE_IN));
     parts[0].start_time_ms = kMiniTitleChangeAnimationStart1MS;
     parts[0].end_time_ms = kMiniTitleChangeAnimationEnd1MS;
     parts[2].start_time_ms = kMiniTitleChangeAnimationStart3MS;
     parts[2].end_time_ms = kMiniTitleChangeAnimationEnd3MS;
     base::TimeDelta timeout =
         base::TimeDelta::FromMilliseconds(kMiniTitleChangeAnimationIntervalMS);
-    ui::MultiAnimation* animation = new ui::MultiAnimation(parts, timeout);
+    gfx::MultiAnimation* animation = new gfx::MultiAnimation(parts, timeout);
     if (animation_container_.get())
       animation->SetContainer(animation_container_.get());
     animation->set_delegate(this);
     tab_animation_.reset(animation);
   }
   tab_animation_->Start();
 }
 
 void Tab::StopMiniTabTitleAnimation() {
   if (!tab_animation_.get())
@@ skipping 55 matching lines @@
 void Tab::ScheduleAudioIndicatorPaint() {
   // No need to schedule a paint if another animation is active. The other
   // animation will do its own scheduling.
   if (!icon_animation_)
     ScheduleIconPaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, AnimationDelegate overrides:
 
-void Tab::AnimationProgressed(const ui::Animation* animation) {
+void Tab::AnimationProgressed(const gfx::Animation* animation) {
   // Ignore if the pulse animation is being performed on active tab because
   // it repaints the same image. See |Tab::PaintTabBackground()|.
   if (animation == tab_animation_.get() && IsActive())
     return;
   SchedulePaint();
 }
 
-void Tab::AnimationCanceled(const ui::Animation* animation) {
+void Tab::AnimationCanceled(const gfx::Animation* animation) {
   SchedulePaint();
 }
 
-void Tab::AnimationEnded(const ui::Animation* animation) {
+void Tab::AnimationEnded(const gfx::Animation* animation) {
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::ButtonListener overrides:
 
 void Tab::ButtonPressed(views::Button* sender, const ui::Event& event) {
   const CloseTabSource source =
       (event.type() == ui::ET_MOUSE_RELEASED &&
        (event.flags() & ui::EF_FROM_TOUCH) == 0) ? CLOSE_TAB_FROM_MOUSE :
@@ skipping 446 matching lines @@
   }
 }
 
 void Tab::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsActive()) {
     PaintActiveTabBackground(canvas);
   } else {
     if (tab_animation_.get() &&
         tab_animation_->is_animating() &&
         data().mini) {
-      ui::MultiAnimation* animation =
-          static_cast<ui::MultiAnimation*>(tab_animation_.get());
+      gfx::MultiAnimation* animation =
+          static_cast<gfx::MultiAnimation*>(tab_animation_.get());
       PaintInactiveTabBackgroundWithTitleChange(canvas, animation);
     } else {
       PaintInactiveTabBackground(canvas);
     }
 
     double throb_value = GetThrobValue();
     if (throb_value > 0) {
       canvas->SaveLayerAlpha(static_cast<int>(throb_value * 0xff),
                              GetLocalBounds());
       PaintActiveTabBackground(canvas);
       canvas->Restore();
     }
   }
 }
 
 void Tab::PaintInactiveTabBackgroundWithTitleChange(
     gfx::Canvas* canvas,
-    ui::MultiAnimation* animation) {
+    gfx::MultiAnimation* animation) {
   // Render the inactive tab background. We'll use this for clipping.
   gfx::Canvas background_canvas(size(), canvas->scale_factor(), false);
   PaintInactiveTabBackground(&background_canvas);
 
   gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
 
   // Draw a radial gradient to hover_canvas.
   gfx::Canvas hover_canvas(size(), canvas->scale_factor(), false);
   int radius = kMiniTitleChangeGradientRadius;
   int x0 = width() + radius - kMiniTitleChangeInitialXOffset;
@@ skipping 507 matching lines @@
   icon_animation_->Stop();
   icon_animation_.reset();
 }
 
 void Tab::StartCrashAnimation() {
   icon_animation_.reset(new FaviconCrashAnimation(this));
   icon_animation_->Start();
 }
 
 void Tab::StartRecordingAnimation() {
-  ui::ThrobAnimation* animation = new ui::ThrobAnimation(this);
-  animation->SetTweenType(ui::Tween::EASE_IN_OUT);
+  gfx::ThrobAnimation* animation = new gfx::ThrobAnimation(this);
+  animation->SetTweenType(gfx::Tween::EASE_IN_OUT);
   animation->SetThrobDuration(kRecordingDurationMs);
   animation->StartThrobbing(-1);
   icon_animation_.reset(animation);
 }
 
 bool Tab::IsPerformingCrashAnimation() const {
   return icon_animation_.get() && data_.IsCrashed();
 }
 
 void Tab::ScheduleIconPaint() {
@@ skipping 102 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }