Enables hot-tracking for overflow extension buttons in the app menu

chrome/browser/ui/views/toolbar/app_menu.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.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 28 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/feature_switch.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_button.h"
@@ skipping 69 matching lines @@
 // Combination border/background for the buttons contained in the menu. The
 // painting of the border/background is done here as LabelButton does not always
 // paint the border.
 class InMenuButtonBackground : public views::Background {
  public:
   enum ButtonType {
     LEFT_BUTTON,
     CENTER_BUTTON,
     RIGHT_BUTTON,
     SINGLE_BUTTON,
+    ROUNDED_BUTTON,

[Peter Kasting, 2016/02/24 02:04:48]

Nit: These probably deserve comments, as it's not immediately clear how e.g.
SINGLE_BUTTON and ROUNDED_BUTTON differ, or why four of these seem to talk about
positioning but the one new one seems to talk instead about shape.

[varkha, 2016/02/24 05:52:09]

Done.

   };
 
   explicit InMenuButtonBackground(ButtonType type)
       : type_(type), left_button_(NULL), right_button_(NULL) {}
 
   // Used when the type is CENTER_BUTTON to determine if the left/right edge
   // needs to be rendered selected.
   void SetOtherButtons(const CustomButton* left_button,
                        const CustomButton* right_button) {
     if (base::i18n::IsRTL()) {
       left_button_ = right_button;
       right_button_ = left_button;
     } else {
       left_button_ = left_button;
       right_button_ = right_button;
     }
   }
 
   // Overridden from views::Background.
   void Paint(gfx::Canvas* canvas, View* view) const override {
     CustomButton* button = CustomButton::AsCustomButton(view);
     views::Button::ButtonState state =
         button ? button->state() : views::Button::STATE_NORMAL;
     int h = view->height();
 
     // Normal buttons get a border drawn on the right side and the rest gets
-    // filled in. The left button however does not get a line to combine
-    // buttons.
-    if (type_ != RIGHT_BUTTON) {
+    // filled in. The left or rounded buttons however do not get a line to
+    // combine buttons.
+    gfx::Rect bounds(view->GetLocalBounds());
+    if (type_ != RIGHT_BUTTON && type_ != ROUNDED_BUTTON) {
       canvas->FillRect(gfx::Rect(0, 0, 1, h),
                        BorderColor(view, views::Button::STATE_NORMAL));
+      bounds.Inset(gfx::Insets(0, 1, 0, 0));
     }
 
-    gfx::Rect bounds(view->GetLocalBounds());
     bounds.set_x(view->GetMirroredXForRect(bounds));
     DrawBackground(canvas, view, bounds, state);
   }
 
  private:
   static SkColor BorderColor(View* view, views::Button::ButtonState state) {
     ui::NativeTheme* theme = view->GetNativeTheme();
     switch (state) {
       case views::Button::STATE_HOVERED:
         return theme->GetSystemColor(
@@ skipping 24 matching lines @@
             ui::NativeTheme::kColorId_MenuBackgroundColor);
     }
   }
 
   void DrawBackground(gfx::Canvas* canvas,
                       const views::View* view,
                       const gfx::Rect& bounds,
                       views::Button::ButtonState state) const {
     if (state == views::Button::STATE_HOVERED ||
         state == views::Button::STATE_PRESSED) {
+      ui::NativeTheme::ExtraParams params;
+      if (type_ == ROUNDED_BUTTON) {
+        // Consistent with a hover corner radius (kInkDropSmallCornerRadius).
+        const int kBackgroundCornerRadius = 2;
+        params.menu_item.corner_radius = kBackgroundCornerRadius;
+      }
       view->GetNativeTheme()->Paint(canvas->sk_canvas(),
                                     ui::NativeTheme::kMenuItemBackground,
-                                    ui::NativeTheme::kHovered,
-                                    bounds,
-                                    ui::NativeTheme::ExtraParams());
+                                    ui::NativeTheme::kHovered, bounds, params);
     }
   }
 
   ButtonType TypeAdjustedForRTL() const {
     if (!base::i18n::IsRTL())
       return type_;
 
     switch (type_) {
       case LEFT_BUTTON:   return RIGHT_BUTTON;
       case RIGHT_BUTTON:  return LEFT_BUTTON;
@@ skipping 899 matching lines @@
       item->SetMargins(top_margin, bottom_margin);
     }
 
     if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU)
       PopulateMenu(item, model->GetSubmenuModelAt(i));
 
     switch (model->GetCommandIdAt(i)) {
       case IDC_EXTENSIONS_OVERFLOW_MENU: {
         scoped_ptr<ExtensionToolbarMenuView> extension_toolbar(
             new ExtensionToolbarMenuView(browser_, this));
+        if (!extension_toolbar->ShouldShow()) {
+          item->SetVisible(false);
+          extension_toolbar_ = nullptr;
+          break;
+        }
+        if (ui::MaterialDesignController::IsModeMaterial()) {
+          for (int i = 0; i < extension_toolbar->contents()->child_count();
+               ++i) {
+            View* action_view = extension_toolbar->contents()->child_at(i);
+            action_view->set_background(new InMenuButtonBackground(
+                InMenuButtonBackground::ROUNDED_BUTTON));
+          }
+        }
         extension_toolbar_ = extension_toolbar.get();
-        if (extension_toolbar->ShouldShow())
-          item->AddChildView(extension_toolbar.release());
-        else
-          item->SetVisible(false);
+        item->AddChildView(extension_toolbar.release());
         break;
       }
 
       case IDC_EDIT_MENU: {
         ui::ButtonMenuItemModel* submodel = model->GetButtonMenuItemAt(i);
         DCHECK_EQ(IDC_CUT, submodel->GetCommandIdAt(0));
         DCHECK_EQ(IDC_COPY, submodel->GetCommandIdAt(1));
         DCHECK_EQ(IDC_PASTE, submodel->GetCommandIdAt(2));
         item->SetTitle(l10n_util::GetStringUTF16(IDS_EDIT2));
         item->AddChildView(new CutCopyPasteView(this, submodel, 0, 1, 2));
@@ skipping 111 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_WRENCH_MENU);
 }
 
 int AppMenu::ModelIndexFromCommandId(int command_id) const {
   CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   DCHECK(ix != command_id_to_entry_.end());
   return ix->second.second;
 }