WIP - allow vector icons to specify motion.

chrome/browser/ui/views/toolbar/app_menu_button.cc

 // Copyright 2013 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/toolbar/app_menu_button.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/ui/toolbar/app_menu_model.h"
 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
 #include "chrome/browser/ui/views/toolbar/app_menu.h"
 #include "chrome/browser/ui/views/toolbar/app_menu_animation.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_button.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/theme_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
+#include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/menu/menu_listener.h"
 #include "ui/views/metrics.h"
 
 namespace {
 const float kIconSize = 16;
+
+class VectorIconAnimator {
+ public:
+  explicit VectorIconAnimator(const gfx::VectorIcon& icon)
+      : icon_(icon), duration_(gfx::GetDurationOfAnimation(icon)) {}
+  ~VectorIconAnimator() {}
+
+  void Start(const base::Closure& animation_callback) {
+    start_time_ = base::TimeTicks::Now();
+    timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(17), this,
+                 &VectorIconAnimator::TimerFired);
+    callback_ = animation_callback;
+  }
+
+  base::TimeDelta GetElapsedTime() {
+    return base::TimeTicks::Now() - start_time_;
+  }
+
+  void PaintIcon(gfx::Canvas* canvas,
+                 SkColor color,
+                 const gfx::Point& position) {
+    if (timer_.IsRunning()) {
+      gfx::ScopedCanvas scoped(canvas);
+      canvas->Translate(position.OffsetFromOrigin());
+      base::TimeDelta elapsed = base::TimeTicks::Now() - start_time_;
+      gfx::PaintVectorIcon(canvas, icon_, color, &elapsed);
+    } else {
+      canvas->DrawImageInt(gfx::CreateVectorIcon(icon_, color), position.x(),
+                           position.y());
+    }
+  }
+
+ private:
+  void TimerFired() {
+    if (duration_ > base::TimeTicks::Now() - start_time_)
+      timer_.Stop();
+
+    callback_.Run();
+  }
+
+  const gfx::VectorIcon& icon_;
+  base::Closure callback_;
+  base::TimeTicks start_time_;
+  base::RepeatingTimer timer_;
+  const base::TimeDelta duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorIconAnimator);
+};
+
 }  // namespace
 
 // static
 bool AppMenuButton::g_open_app_immediately_for_testing = false;
 
 AppMenuButton::AppMenuButton(ToolbarView* toolbar_view)
     : views::MenuButton(base::string16(), toolbar_view, false),
       severity_(AppMenuIconController::Severity::NONE),
       type_(AppMenuIconController::IconType::NONE),
       toolbar_view_(toolbar_view),
@@ skipping 74 matching lines @@
   menu_listeners_.RemoveObserver(listener);
 }
 
 gfx::Size AppMenuButton::GetPreferredSize() const {
   gfx::Rect rect(gfx::Size(kIconSize, kIconSize));
   rect.Inset(gfx::Insets(-ToolbarButton::kInteriorPadding));
   return rect.size();
 }
 
 void AppMenuButton::Layout() {
-  if (animation_) {
+  if (animator_) {
     ink_drop_container()->SetBoundsRect(GetLocalBounds());
     image()->SetBoundsRect(GetLocalBounds());
     return;
   }
 
   views::MenuButton::Layout();
 }
 
 void AppMenuButton::OnPaint(gfx::Canvas* canvas) {
-  if (!animation_) {
+  if (!animator_) {
     views::MenuButton::OnPaint(canvas);
     return;
   }
 
-  gfx::Rect bounds = GetLocalBounds();
-  bounds.Inset(gfx::Insets(ToolbarButton::kInteriorPadding));
-  animation_->PaintAppMenu(canvas, bounds);
+  animator_->PaintIcon(canvas, SK_ColorRED,
+                       gfx::Vector2d(ToolbarButton::kInteriorPadding,
+                                     ToolbarButton::kInteriorPadding));
 }
 
 void AppMenuButton::TabInsertedAt(TabStripModel* tab_strip_model,
                                   content::WebContents* contents,
                                   int index,
                                   bool foreground) {
   AnimateIconIfPossible();
 }
 
 void AppMenuButton::UpdateIcon(bool should_animate) {
@@ skipping 13 matching lines @@
       severity_color = native_theme->GetSystemColor(
           ui::NativeTheme::kColorId_AlertSeverityMedium);
       break;
     case AppMenuIconController::Severity::HIGH:
       severity_color = native_theme->GetSystemColor(
           ui::NativeTheme::kColorId_AlertSeverityHigh);
       break;
   }
 
   if (should_use_new_icon_) {
-    if (!animation_)
-      animation_ = base::MakeUnique<AppMenuAnimation>(this, toolbar_icon_color);
+    if (!animator_)
+      animator_.reset(new VectorIconAnimator(kBrowserToolsAnimatedIcon));
 
-    animation_->set_target_color(severity_color);
+    // animation_->set_target_color(severity_color);
     if (should_animate)
       AnimateIconIfPossible();
-
     return;
   }
 
   const gfx::VectorIcon* icon_id = nullptr;
   switch (type_) {
     case AppMenuIconController::IconType::NONE:
       icon_id = &kBrowserToolsIcon;
       DCHECK_EQ(AppMenuIconController::Severity::NONE, severity_);
       break;
     case AppMenuIconController::IconType::UPGRADE_NOTIFICATION:
       icon_id = &kBrowserToolsUpdateIcon;
       break;
     case AppMenuIconController::IconType::GLOBAL_ERROR:
     case AppMenuIconController::IconType::INCOMPATIBILITY_WARNING:
       icon_id = &kBrowserToolsErrorIcon;
       break;
   }
 
   SetImage(views::Button::STATE_NORMAL,
            gfx::CreateVectorIcon(*icon_id, severity_color));
 }
 
 void AppMenuButton::SetTrailingMargin(int margin) {
   margin_trailing_ = margin;
   UpdateThemedBorder();
   InvalidateLayout();
 }
 
 void AppMenuButton::AnimateIconIfPossible() {
-  if (!animation_ || !should_use_new_icon_ ||
+  if (/*!animation_ ||*/ !should_use_new_icon_ ||
       severity_ == AppMenuIconController::Severity::NONE) {
     return;
   }
 
-  animation_->StartAnimation();
+  //  animation_->StartAnimation();
+  animation_start_time_ = base::TimeTicks::Now();
+  animation_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(17),
+                         static_cast<views::View*>(this),
+                         &views::View::SchedulePaint);
 }
 
 void AppMenuButton::AppMenuAnimationStarted() {
   SetPaintToLayer();
   layer()->SetFillsBoundsOpaquely(false);
 }
 
 void AppMenuButton::AppMenuAnimationEnded() {
   DestroyLayer();
 }
@@ skipping 55 matching lines @@
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void AppMenuButton::OnDragExited() {
   weak_factory_.InvalidateWeakPtrs();
 }
 
 int AppMenuButton::OnPerformDrop(const ui::DropTargetEvent& event) {
   return ui::DragDropTypes::DRAG_MOVE;
 }