[Views] App Menu Icon Update

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 29 matching lines @@
 }  // 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),
+      should_use_new_icon_(false),
       margin_trailing_(0),
       weak_factory_(this) {
   SetInkDropMode(InkDropMode::ON);
   SetFocusPainter(nullptr);
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kAppMenuIcon)) {
-    std::string flag =
-        command_line->GetSwitchValueASCII(switches::kAppMenuIcon);
-    if (flag == switches::kAppMenuIconPersistentClosedState) {
-      Browser* browser = toolbar_view_->browser();
-      browser->tab_strip_model()->AddObserver(this);
-      animation_ = base::MakeUnique<AppMenuAnimation>(this, true);
-    } else if (flag == switches::kAppMenuIconPersistentOpenedState) {
-      animation_ = base::MakeUnique<AppMenuAnimation>(this, false);
-    }
+  if (command_line->HasSwitch(switches::kEnableNewAppMenuIcon)) {
+    toolbar_view_->browser()->tab_strip_model()->AddObserver(this);
+    should_use_new_icon_ = true;
   }
 }
 
 AppMenuButton::~AppMenuButton() {}
 
 void AppMenuButton::SetSeverity(AppMenuIconController::IconType type,
                                 AppMenuIconController::Severity severity,
                                 bool animate) {
   type_ = type;
   severity_ = severity;
@@ skipping 26 matching lines @@
   menu_->RunMenu(this);
 
   if (!for_drop) {
     // Record the time-to-action for the menu. We don't record in the case of a
     // drag-and-drop command because menus opened for drag-and-drop don't block
     // the message loop.
     UMA_HISTOGRAM_TIMES("Toolbar.AppMenuTimeToAction",
                         base::TimeTicks::Now() - menu_open_time);
   }
 
-  if (animation_ && severity_ != AppMenuIconController::Severity::NONE)
-    animation_->StartAnimation();
+  AnimateIconIfPossible();
 }
 
 void AppMenuButton::CloseMenu() {
   if (menu_)
     menu_->CloseMenu();
   menu_.reset();
 }
 
 bool AppMenuButton::IsMenuShowing() const {
   return menu_ && menu_->IsShowing();
@@ skipping 31 matching lines @@
 
   gfx::Rect bounds = GetLocalBounds();
   bounds.Inset(gfx::Insets(ToolbarButton::kInteriorPadding));
   animation_->PaintAppMenu(canvas, bounds);
 }
 
 void AppMenuButton::TabInsertedAt(TabStripModel* tab_strip_model,
                                   content::WebContents* contents,
                                   int index,
                                   bool foreground) {
-  if (severity_ != AppMenuIconController::Severity::NONE)
-    animation_->StartAnimation();
+  AnimateIconIfPossible();
 }
 
 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 (animation_) {
-    animation_->SetIconColors(toolbar_icon_color, severity_color);
+  if (should_use_new_icon_) {
+    if (!animation_)
+      animation_ = base::MakeUnique<AppMenuAnimation>(this, toolbar_icon_color);
+
+    animation_->set_target_color(severity_color);
     if (should_animate)
-      animation_->StartAnimation();
+      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_ ||
+      severity_ == AppMenuIconController::Severity::NONE) {
+    return;
+  }
+
+  animation_->StartAnimation();
+}
+
 void AppMenuButton::AppMenuAnimationStarted() {
   SetPaintToLayer();
   layer()->SetFillsBoundsOpaquely(false);
 }
 
 void AppMenuButton::AppMenuAnimationEnded() {
   DestroyLayer();
 }
 
 const char* AppMenuButton::GetClassName() const {
@@ skipping 53 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;
 }