Standardize usage of virtual/override/final specifiers.

chrome/browser/ui/views/toolbar/wrench_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/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 88 matching lines @@
       command_id <= WrenchMenuModel::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) { }
 
   // Overridden from ImageButton.
-  virtual gfx::Size GetPreferredSize() const override {
+  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;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
@@ skipping 21 matching lines @@
     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.
-  virtual void Paint(gfx::Canvas* canvas, View* view) const override {
+  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) {
       canvas->FillRect(gfx::Rect(0, 0, 1, h),
@@ skipping 89 matching lines @@
 
   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)
       : LabelButton(listener, text), in_menu_background_(NULL) {}
-  virtual ~InMenuButton() {}
+  ~InMenuButton() override {}
 
   void Init(InMenuButtonBackground::ButtonType type) {
     SetFocusable(true);
     set_request_focus_on_press(false);
     SetHorizontalAlignment(gfx::ALIGN_CENTER);
 
     in_menu_background_ = new InMenuButtonBackground(type);
     set_background(in_menu_background_);
 
     OnNativeThemeChanged(NULL);
   }
 
   void SetOtherButtons(const InMenuButton* left, const InMenuButton* right) {
     in_menu_background_->SetOtherButtons(left, right);
   }
 
   // views::LabelButton
-  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
+  void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
     const MenuConfig& menu_config = MenuConfig::instance(theme);
     SetBorder(views::Border::CreateEmptyBorder(
         0, kHorizontalPadding, 0, kHorizontalPadding));
     SetFontList(menu_config.font_list);
 
     if (theme) {
       SetTextColor(
           views::Button::STATE_DISABLED,
           theme->GetSystemColor(
               ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor));
@@ skipping 22 matching lines @@
 class WrenchMenuView : public views::View,
                        public views::ButtonListener,
                        public WrenchMenuObserver {
  public:
   WrenchMenuView(WrenchMenu* menu, MenuModel* menu_model)
       : menu_(menu),
         menu_model_(menu_model) {
     menu_->AddObserver(this);
   }
 
-  virtual ~WrenchMenuView() {
+  ~WrenchMenuView() override {
     if (menu_)
       menu_->RemoveObserver(this);
   }
 
   // Overridden from views::View.
-  virtual void SchedulePaintInRect(const gfx::Rect& r) override {
+  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,
       InMenuButtonBackground::ButtonType type,
@@ skipping 18 matching lines @@
     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 WrenchMenuObserver:
-  virtual void WrenchMenuDestroyed() override {
+  void WrenchMenuDestroyed() override {
     menu_->RemoveObserver(this);
     menu_ = NULL;
     menu_model_ = NULL;
   }
 
  protected:
   WrenchMenu* menu() { return menu_; }
   MenuModel* menu_model() { return menu_model_; }
 
  private:
   // Hosting WrenchMenu.
   // WARNING: this may be NULL during shutdown.
   WrenchMenu* menu_;
 
   // The menu model containing the increment/decrement/reset items.
   // WARNING: this may be NULL during shutdown.
   MenuModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
 
 // Generate the button image for hover state.
 class HoveredImageSource : public gfx::ImageSkiaSource {
  public:
   HoveredImageSource(const gfx::ImageSkia& image, SkColor color)
       : image_(image),
         color_(color) {
   }
-  virtual ~HoveredImageSource() {}
+  ~HoveredImageSource() override {}
 
-  virtual gfx::ImageSkiaRep GetImageForScale(float scale) override {
+  gfx::ImageSkiaRep GetImageForScale(float scale) override {
     const gfx::ImageSkiaRep& rep = image_.GetRepresentation(scale);
     SkBitmap bitmap = rep.sk_bitmap();
     SkBitmap white;
     white.allocN32Pixels(bitmap.width(), bitmap.height());
     white.eraseARGB(0, 0, 0, 0);
     bitmap.lockPixels();
     for (int y = 0; y < bitmap.height(); ++y) {
       uint32* image_row = bitmap.getAddr32(0, y);
       uint32* dst_row = white.getAddr32(0, y);
       for (int x = 0; x < bitmap.width(); ++x) {
@@ skipping 28 matching lines @@
     InMenuButton* cut = CreateAndConfigureButton(
         IDS_CUT, InMenuButtonBackground::LEFT_BUTTON, cut_index);
     InMenuButton* copy = CreateAndConfigureButton(
         IDS_COPY, InMenuButtonBackground::CENTER_BUTTON, copy_index);
     InMenuButton* paste = CreateAndConfigureButton(
         IDS_PASTE, InMenuButtonBackground::CENTER_BUTTON, paste_index);
     copy->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
-  virtual gfx::Size GetPreferredSize() const override {
+  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);
   }
 
-  virtual void Layout() override {
+  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.
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override {
+  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());
     return width;
@@ skipping 73 matching lines @@
     fullscreen_button_->SetAccessibleName(
         GetAccessibleNameForWrenchMenuItem(
             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();
   }
 
-  virtual ~ZoomView() {}
+  ~ZoomView() override {}
 
   // Overridden from View.
-  virtual gfx::Size GetPreferredSize() const override {
+  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(button_width + zoom_label_width_ + button_width +
                      fullscreen_width, 0);
   }
 
-  virtual void Layout() override {
+  void Layout() override {
     int x = 0;
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     gfx::Rect bounds(0, 0, button_width, height());
 
     decrement_button_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(zoom_label_width_);
     zoom_label_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(button_width);
     increment_button_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
                      kFullscreenPadding);
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
-  virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
+  void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
     WrenchMenuView::OnNativeThemeChanged(theme);
 
     const MenuConfig& menu_config = MenuConfig::instance(theme);
     zoom_label_->SetBorder(views::Border::CreateEmptyBorder(
         0, kZoomLabelHorizontalPadding, 0, kZoomLabelHorizontalPadding));
     zoom_label_->SetFontList(menu_config.font_list);
     zoom_label_width_ = MaxWidthForZoomLabel();
 
     if (theme) {
       zoom_label_->SetEnabledColor(theme->GetSystemColor(
           ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor));
       gfx::ImageSkia* full_screen_image =
           ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
               IDR_FULLSCREEN_MENU_BUTTON);
       SkColor fg_color = theme->GetSystemColor(
           ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor);
       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.
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override {
+  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());
     }
   }
 
   // Overridden from WrenchMenuObserver.
-  virtual void WrenchMenuDestroyed() override {
-    WrenchMenuView::WrenchMenuDestroyed();
-  }
+  void WrenchMenuDestroyed() override { WrenchMenuView::WrenchMenuDestroyed(); }
 
  private:
   void OnZoomLevelChanged(const HostZoomMap::ZoomLevelChange& change) {
     UpdateZoomControls();
   }
 
   void UpdateZoomControls() {
     WebContents* selected_tab =
         menu()->browser_->tab_strip_model()->GetActiveWebContents();
     int zoom = 100;
@@ skipping 67 matching lines @@
  public:
   RecentTabsMenuModelDelegate(WrenchMenu* wrench_menu,
                               ui::MenuModel* model,
                               views::MenuItemView* menu_item)
       : wrench_menu_(wrench_menu),
         model_(model),
         menu_item_(menu_item) {
     model_->SetMenuModelDelegate(this);
   }
 
-  virtual ~RecentTabsMenuModelDelegate() {
+  ~RecentTabsMenuModelDelegate() override {
     model_->SetMenuModelDelegate(NULL);
   }
 
   const gfx::FontList* GetLabelFontListAt(int index) const {
     return model_->GetLabelFontListAt(index);
   }
 
   bool GetShouldUseDisabledEmphasizedForegroundColor(int index) const {
     // The items for which we get a font list, should be shown in the bolded
     // color.
     return GetLabelFontListAt(index) ? true : false;
   }
 
   // ui::MenuModelDelegate implementation:
 
-  virtual void OnIconChanged(int index) override {
+  void OnIconChanged(int index) override {
     int command_id = model_->GetCommandIdAt(index);
     views::MenuItemView* item = menu_item_->GetMenuItemByID(command_id);
     DCHECK(item);
     gfx::Image icon;
     model_->GetIconAt(index, &icon);
     item->SetIcon(*icon.ToImageSkia());
   }
 
-  virtual void OnMenuStructureChanged() override {
+  void OnMenuStructureChanged() override {
     if (menu_item_->HasSubmenu()) {
       // Remove all menu items from submenu.
       views::SubmenuView* submenu = menu_item_->GetSubmenu();
       while (submenu->child_count() > 0)
         menu_item_->RemoveMenuItemAt(submenu->child_count() - 1);
 
       // Remove all elements in |WrenchMenu::command_id_to_entry_| that map to
       // |model_|.
       WrenchMenu::CommandIDToEntry::iterator iter =
           wrench_menu_->command_id_to_entry_.begin();
@@ skipping 481 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_WRENCH_MENU);
 }
 
 int WrenchMenu::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;
 }