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

chrome/browser/ui/views/status_bubble_views.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/status_bubble_views.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRect.h"
-#include "ui/base/animation/animation_delegate.h"
-#include "ui/base/animation/linear_animation.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
+#include "ui/gfx/animation/animation_delegate.h"
+#include "ui/gfx/animation/linear_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/scrollbar/native_scroll_bar.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
@@ skipping 32 matching lines @@
 static const int kFramerate = 25;
 
 // How long each expansion step should take.
 static const int kMinExpansionStepDurationMS = 20;
 static const int kMaxExpansionStepDurationMS = 150;
 
 // View -----------------------------------------------------------------------
 // StatusView manages the display of the bubble, applying text changes and
 // fading in or out the bubble as required.
 class StatusBubbleViews::StatusView : public views::Label,
-                                      public ui::LinearAnimation,
-                                      public ui::AnimationDelegate {
+                                      public gfx::LinearAnimation,
+                                      public gfx::AnimationDelegate {
  public:
   StatusView(StatusBubble* status_bubble,
              views::Widget* popup,
              ui::ThemeProvider* theme_provider)
-      : ui::LinearAnimation(kFramerate, this),
+      : gfx::LinearAnimation(kFramerate, this),
         stage_(BUBBLE_HIDDEN),
         style_(STYLE_STANDARD),
         timer_factory_(this),
         status_bubble_(status_bubble),
         popup_(popup),
         opacity_start_(0),
         opacity_end_(0),
         theme_service_(theme_provider) {
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     SetFont(rb.GetFont(ui::ResourceBundle::BaseFont));
@@ skipping 213 matching lines @@
   } else if (stage_ == BUBBLE_SHOWING_TIMER) {
     // We hadn't yet begun showing anything when we received a new request
     // for something to show, so we start from scratch.
     ResetTimer();
   }
 }
 
 // Animation functions.
 double StatusBubbleViews::StatusView::GetCurrentOpacity() {
   return opacity_start_ + (opacity_end_ - opacity_start_) *
-         ui::LinearAnimation::GetCurrentValue();
+         gfx::LinearAnimation::GetCurrentValue();
 }
 
 void StatusBubbleViews::StatusView::SetOpacity(double opacity) {
   popup_->SetOpacity(static_cast<unsigned char>(opacity * 255));
 }
 
 void StatusBubbleViews::StatusView::AnimateToState(double state) {
   SetOpacity(GetCurrentOpacity());
 }
 
 void StatusBubbleViews::StatusView::AnimationEnded(
-    const ui::Animation* animation) {
+    const gfx::Animation* animation) {
   SetOpacity(opacity_end_);
 
   if (stage_ == BUBBLE_HIDING_FADE) {
     stage_ = BUBBLE_HIDDEN;
     popup_->Hide();
   } else if (stage_ == BUBBLE_SHOWING_FADE) {
     stage_ = BUBBLE_SHOWN;
   }
 }
 
@@ skipping 118 matching lines @@
                         body_bounds.x(),
                         body_bounds.y(),
                         body_bounds.width(),
                         body_bounds.height());
 }
 
 // StatusViewExpander ---------------------------------------------------------
 // Manages the expansion and contraction of the status bubble as it accommodates
 // URLs too long to fit in the standard bubble. Changes are passed through the
 // StatusView to paint.
-class StatusBubbleViews::StatusViewExpander : public ui::LinearAnimation,
-                                              public ui::AnimationDelegate {
+class StatusBubbleViews::StatusViewExpander : public gfx::LinearAnimation,
+                                              public gfx::AnimationDelegate {
  public:
   StatusViewExpander(StatusBubbleViews* status_bubble,
                      StatusView* status_view)
-      : ui::LinearAnimation(kFramerate, this),
+      : gfx::LinearAnimation(kFramerate, this),
         status_bubble_(status_bubble),
         status_view_(status_view),
         expansion_start_(0),
         expansion_end_(0) {
   }
 
   // Manage the expansion of the bubble.
   void StartExpansion(const string16& expanded_text,
                       int current_width,
                       int expansion_end);
 
   // Set width of fully expanded bubble.
   void SetExpandedWidth(int expanded_width);
 
  private:
   // Animation functions.
   int GetCurrentBubbleWidth();
   void SetBubbleWidth(int width);
   virtual void AnimateToState(double state) OVERRIDE;
-  virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE;
+  virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
 
   // Manager that owns us.
   StatusBubbleViews* status_bubble_;
 
   // Change the bounds and text of this view.
   StatusView* status_view_;
 
   // Text elided (if needed) to fit maximum status bar width.
   string16 expanded_text_;
 
   // Widths at expansion start and end.
   int expansion_start_;
   int expansion_end_;
 };
 
 void StatusBubbleViews::StatusViewExpander::AnimateToState(double state) {
   SetBubbleWidth(GetCurrentBubbleWidth());
 }
 
 void StatusBubbleViews::StatusViewExpander::AnimationEnded(
-    const ui::Animation* animation) {
+    const gfx::Animation* animation) {
   SetBubbleWidth(expansion_end_);
   status_view_->SetText(expanded_text_, false);
 }
 
 void StatusBubbleViews::StatusViewExpander::StartExpansion(
     const string16& expanded_text,
     int expansion_start,
     int expansion_end) {
   expanded_text_ = expanded_text;
   expansion_start_ = expansion_start;
   expansion_end_ = expansion_end;
   int min_duration = std::max(kMinExpansionStepDurationMS,
       static_cast<int>(kMaxExpansionStepDurationMS *
           (expansion_end - expansion_start) / 100.0));
   SetDuration(std::min(kMaxExpansionStepDurationMS, min_duration));
   Start();
 }
 
 int StatusBubbleViews::StatusViewExpander::GetCurrentBubbleWidth() {
   return static_cast<int>(expansion_start_ +
       (expansion_end_ - expansion_start_) *
-          ui::LinearAnimation::GetCurrentValue());
+          gfx::LinearAnimation::GetCurrentValue());
 }
 
 void StatusBubbleViews::StatusViewExpander::SetBubbleWidth(int width) {
   status_bubble_->SetBubbleWidth(width);
   status_view_->SchedulePaint();
 }
 
 // StatusBubble ---------------------------------------------------------------
 
 const int StatusBubbleViews::kShadowThickness = 1;
@@ skipping 300 matching lines @@
 void StatusBubbleViews::SetBubbleWidth(int width) {
   size_.set_width(width);
   SetBounds(original_position_.x(), original_position_.y(),
             size_.width(), size_.height());
 }
 
 void StatusBubbleViews::CancelExpandTimer() {
   if (expand_timer_factory_.HasWeakPtrs())
     expand_timer_factory_.InvalidateWeakPtrs();
 }