Use animated vector icon for app menu notification animation.

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"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "cc/paint/paint_flags.h"
 #include "chrome/app/vector_icons/vector_icons.h"
 #include "chrome/browser/themes/theme_properties.h"
+#include "chrome/browser/themes/theme_service.h"
+#include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/browser/ui/toolbar/app_menu_animation.h"
 #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/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"
@@ skipping 95 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 (new_icon_) {
+    new_icon_->SetBoundsRect(GetContentsBounds());
     ink_drop_container()->SetBoundsRect(GetLocalBounds());
     image()->SetBoundsRect(GetLocalBounds());
     return;
   }
 
   views::MenuButton::Layout();
 }
 
-void AppMenuButton::OnPaint(gfx::Canvas* canvas) {
-  if (!animation_) {
-    views::MenuButton::OnPaint(canvas);
-    return;
-  }
-
-  gfx::Rect bounds = GetLocalBounds();
-  bounds.Inset(gfx::Insets(ToolbarButton::kInteriorPadding));
-  animation_->PaintAppMenu(canvas, bounds);
+void AppMenuButton::OnThemeChanged() {
+  UpdateIcon(false);
 }
 
 void AppMenuButton::TabInsertedAt(TabStripModel* tab_strip_model,
                                   content::WebContents* contents,
                                   int index,
                                   bool foreground) {
   AnimateIconIfPossible();
 }
 
-void AppMenuButton::AppMenuAnimationStarted() {
-  SetPaintToLayer();
-  layer()->SetFillsBoundsOpaquely(false);
-}
-
-void AppMenuButton::AppMenuAnimationEnded() {
-  DestroyLayer();
-}
-
-void AppMenuButton::InvalidateIcon() {
-  SchedulePaint();
-}
-
 void AppMenuButton::UpdateIcon(bool should_animate) {
   SkColor severity_color = gfx::kPlaceholderColor;
   SkColor toolbar_icon_color =
       GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR_BUTTON_ICON);
   const ui::NativeTheme* native_theme = GetNativeTheme();
   switch (severity_) {
     case AppMenuIconController::Severity::NONE:
       severity_color = toolbar_icon_color;
       break;
     case AppMenuIconController::Severity::LOW:
       severity_color = native_theme->GetSystemColor(
           ui::NativeTheme::kColorId_AlertSeverityLow);
       break;
     case AppMenuIconController::Severity::MEDIUM:
       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 (!new_icon_) {
+      new_icon_ = new views::AnimatedIconView(kBrowserToolsAnimatedIcon);
+      new_icon_->set_can_process_events_within_subtree(false);
+      AddChildView(new_icon_);
+    }
 
-    animation_->set_target_color(severity_color);
+    // Only show a special color for severity when using the classic Chrome
+    // theme. Otherwise, we can't be sure that it contrasts with the toolbar
+    // background.

[Peter Kasting, 2017/05/31 02:08:28]

What about just always running the severity_color and the toolbar background
color through GetReadableColor()?  Seems like that would work, and avoid the
need for a conditional here.

(I assume the severity color is never near luma 0.5.)

[Evan Stade, 2017/05/31 17:08:16]

I can experiment with that as a follow up, but even if it does work consistently
in terms of getting a contrasting color, I'm not sure it would create a color
that makes sense in the same way that red means "severe".

[Peter Kasting, 2017/05/31 17:24:31]

If you put in red, you always get red out.  That's why GetReadableColor() only
mucks with luma: so it doesn't change the "meaning" of the color.

+    new_icon_->set_color(
+        ThemeServiceFactory::GetForProfile(toolbar_view_->browser()->profile())
+                ->UsingDefaultTheme()
+            ? severity_color
+            : toolbar_icon_color);
+
     if (should_animate)
       AnimateIconIfPossible();
 
     return;
   }
 
   const gfx::VectorIcon* icon_id = nullptr;
   switch (type_) {
     case AppMenuIconController::IconType::NONE:
       icon_id = &kBrowserToolsIcon;
@@ skipping 12 matching lines @@
            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 (!new_icon_ || !should_use_new_icon_ ||
       severity_ == AppMenuIconController::Severity::NONE) {
     return;
   }
 
-  animation_->StartAnimation();
+  new_icon_->Animate(views::AnimatedIconView::END);

[sadrul, 2017/05/30 17:06:51]

Who calls Animate(START)?

[Peter Kasting, 2017/05/31 02:08:28]

I assume no one, since this means "animate to the end state" and I don't think
there's a need anywhere to reverse-animate to the start state.

 }
 
 const char* AppMenuButton::GetClassName() const {
   return "AppMenuButton";
 }
 
 std::unique_ptr<views::LabelButtonBorder> AppMenuButton::CreateDefaultBorder()
     const {
   std::unique_ptr<views::LabelButtonBorder> border =
       MenuButton::CreateDefaultBorder();
@@ skipping 46 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;
 }