Add VectorIconButton functionality to ImageButton.

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 93 matching lines @@
 
 // Returns true if |command_id| identifies a recent tabs menu item.
 bool IsRecentTabsCommand(int command_id) {
   return command_id >= AppMenuModel::kMinRecentTabsCommandId &&
          command_id <= AppMenuModel::kMaxRecentTabsCommandId;
 }
 
 // Subclass of ImageButton whose preferred size includes the size of the border.
 class FullscreenButton : public ImageButton {
  public:
-  explicit FullscreenButton(views::ButtonListener* listener)
-      : ImageButton(listener) { }
+  explicit FullscreenButton(views::ImageButtonDelegate* listener)
+      : ImageButton(listener) {}
 
-  // Overridden from ImageButton.
+  // views::ImageButton:
   gfx::Size GetPreferredSize() const override {
     gfx::Size pref = ImageButton::GetPreferredSize();
     if (border()) {
       gfx::Insets insets = border()->GetInsets();
       pref.Enlarge(insets.width(), insets.height());
     }
     return pref;
   }
 
   void GetAccessibleNodeData(ui::AXNodeData* node_data) override {
@@ skipping 16 matching lines @@
 
     // A rectangular button with a border drawn along the leading (left) side.
     LEADING_BORDER,
 
     // A button with no drawn border and a rounded background.
     ROUNDED_BUTTON,
   };
 
   explicit InMenuButtonBackground(ButtonType type) : type_(type) {}
 
-  // Overridden from views::Background.
+  // 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();
 
     // Draw leading border if desired.
     gfx::Rect bounds(view->GetLocalBounds());
     if (type_ == LEADING_BORDER) {
       // We need to flip the canvas for RTL iff the button is not auto-flipping
@@ skipping 79 matching lines @@
                         menu_accelerator.modifiers()).GetShortcutText();
   }
 
   return MenuItemView::GetAccessibleNameForMenuItem(
       accessible_name, accelerator_text);
 }
 
 // A button that lives inside a menu item.
 class InMenuButton : public LabelButton {
  public:
-  InMenuButton(views::ButtonListener* listener, const base::string16& text)
+  InMenuButton(views::ImageButtonDelegate* listener, const base::string16& text)
       : LabelButton(listener, text), in_menu_background_(NULL) {}
   ~InMenuButton() override {}
 
   void Init(InMenuButtonBackground::ButtonType type) {
     // An InMenuButton should always be focusable regardless of the platform.
     // Hence we don't use SetFocusForPlatform().
     SetFocusBehavior(FocusBehavior::ALWAYS);
     SetHorizontalAlignment(gfx::ALIGN_CENTER);
 
     in_menu_background_ = new InMenuButtonBackground(type);
@@ skipping 31 matching lines @@
   }
 
  private:
   InMenuButtonBackground* in_menu_background_;
 
   DISALLOW_COPY_AND_ASSIGN(InMenuButton);
 };
 
 // AppMenuView is a view that can contain label buttons.
 class AppMenuView : public views::View,
-                    public views::ButtonListener,
+                    public views::ImageButtonDelegate,
                     public AppMenuObserver {
  public:
   AppMenuView(AppMenu* menu, ButtonMenuItemModel* menu_model)
       : menu_(menu),
         menu_model_(menu_model) {
     menu_->AddObserver(this);
   }
 
   ~AppMenuView() override {
     if (menu_)
       menu_->RemoveObserver(this);
   }
 
-  // Overridden from views::View.
+  // views::View:
   void SchedulePaintInRect(const gfx::Rect& r) override {
     // Normally when the mouse enters/exits a button the buttons invokes
     // SchedulePaint. As part of the button border (InMenuButtonBackground) is
     // rendered by the button to the left/right of it SchedulePaint on the the
     // button may not be enough, so this forces a paint all.
     View::SchedulePaintInRect(gfx::Rect(size()));
   }
 
   InMenuButton* CreateAndConfigureButton(
       int string_id,
@@ skipping 18 matching lines @@
     button->set_tag(index);
     button->SetEnabled(menu_model_->IsEnabledAt(index));
 
     AddChildView(button);
     // all buttons on menu should must be a custom button in order for
     // the keyboard nativigation work.
     DCHECK(CustomButton::AsCustomButton(button));
     return button;
   }
 
-  // Overridden from AppMenuObserver:
+  // AppMenuObserver:
   void AppMenuDestroyed() override {
     menu_->RemoveObserver(this);
     menu_ = NULL;
     menu_model_ = NULL;
   }
 
  protected:
   AppMenu* menu() { return menu_; }
   const AppMenu* menu() const { return menu_; }
   ButtonMenuItemModel* menu_model() { return menu_model_; }
@@ skipping 59 matching lines @@
                    int paste_index)
       : AppMenuView(menu, menu_model) {
     CreateAndConfigureButton(IDS_CUT, InMenuButtonBackground::LEADING_BORDER,
                              cut_index);
     CreateAndConfigureButton(IDS_COPY, InMenuButtonBackground::LEADING_BORDER,
                              copy_index);
     CreateAndConfigureButton(IDS_PASTE, InMenuButtonBackground::LEADING_BORDER,
                              paste_index);
   }
 
-  // Overridden from View.
+  // views::View:
   gfx::Size GetPreferredSize() const override {
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview.
     return gfx::Size(GetMaxChildViewPreferredWidth() * child_count(), 0);
   }
 
   void Layout() override {
     // All buttons are given the same width.
     int width = GetMaxChildViewPreferredWidth();
     for (int i = 0; i < child_count(); ++i)
       child_at(i)->SetBounds(i * width, 0, width, height());
   }
 
-  // Overridden from ButtonListener.
+  // views::ImageButtonDelegate:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     menu()->CancelAndEvaluate(menu_model(), sender->tag());
   }
 
  private:
   // Returns the max preferred width of all the children.
   int GetMaxChildViewPreferredWidth() const {
     int width = 0;
     for (int i = 0; i < child_count(); ++i)
       width = std::max(width, child_at(i)->GetPreferredSize().width());
@@ skipping 70 matching lines @@
         menu_model, fullscreen_index, IDS_ACCNAME_FULLSCREEN));
     AddChildView(fullscreen_button_);
 
     // Need to set a font list for the zoom label width calculations.
     OnNativeThemeChanged(NULL);
     UpdateZoomControls();
   }
 
   ~ZoomView() override {}
 
-  // Overridden from View.
+  // views::View:
   gfx::Size GetPreferredSize() const override {
     // The increment/decrement button are forced to the same width.
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     int fullscreen_width =
         fullscreen_button_->GetPreferredSize().width() + kFullscreenPadding;
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview. Note that we have overridden the height when
     // constructing the menu.
     return gfx::Size(
@@ skipping 45 matching lines @@
       gfx::ImageSkia hovered_fullscreen_image(
           new HoveredImageSource(*full_screen_image, fg_color),
       full_screen_image->size());
       fullscreen_button_->SetImage(
           ImageButton::STATE_HOVERED, &hovered_fullscreen_image);
       fullscreen_button_->SetImage(
           ImageButton::STATE_PRESSED, &hovered_fullscreen_image);
     }
   }
 
-  // Overridden from ButtonListener.
+  // views::ImageButtonDelegate:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     if (sender->tag() == fullscreen_index_) {
       menu()->CancelAndEvaluate(menu_model(), sender->tag());
     } else {
       // Zoom buttons don't close the menu.
       menu_model()->ActivatedAt(sender->tag());
     }
   }
 
  private:
@@ skipping 615 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_APP_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;
 }