replace OVERRIDE and FINAL with override and final in chrome/browser/ui/[t-v]*

chrome/browser/ui/views/menu_model_adapter_test.cc

 // Copyright (c) 2012 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 "base/callback.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chrome/test/base/view_event_test_base.h"
 #include "ui/base/models/menu_model.h"
@@ skipping 23 matching lines @@
 class CommonMenuModel : public ui::MenuModel {
  public:
   CommonMenuModel() {
   }
 
   virtual ~CommonMenuModel() {
   }
 
  protected:
   // ui::MenuModel implementation.
-  virtual bool HasIcons() const OVERRIDE {
+  virtual bool HasIcons() const override {
     return false;
   }
 
-  virtual bool IsItemDynamicAt(int index) const OVERRIDE {
+  virtual bool IsItemDynamicAt(int index) const override {
     return false;
   }
 
   virtual bool GetAcceleratorAt(int index,
-                                ui::Accelerator* accelerator) const OVERRIDE {
+                                ui::Accelerator* accelerator) const override {
     return false;
   }
 
-  virtual ui::MenuSeparatorType GetSeparatorTypeAt(int index) const OVERRIDE {
+  virtual ui::MenuSeparatorType GetSeparatorTypeAt(int index) const override {
     return ui::NORMAL_SEPARATOR;
   }
 
-  virtual bool IsItemCheckedAt(int index) const OVERRIDE {
+  virtual bool IsItemCheckedAt(int index) const override {
     return false;
   }
 
-  virtual int GetGroupIdAt(int index) const OVERRIDE {
+  virtual int GetGroupIdAt(int index) const override {
     return 0;
   }
 
-  virtual bool GetIconAt(int index, gfx::Image* icon) OVERRIDE {
+  virtual bool GetIconAt(int index, gfx::Image* icon) override {
     return false;
   }
 
   virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt(
-      int index) const OVERRIDE {
+      int index) const override {
     return NULL;
   }
 
-  virtual bool IsEnabledAt(int index) const OVERRIDE {
+  virtual bool IsEnabledAt(int index) const override {
     return true;
   }
 
-  virtual ui::MenuModel* GetSubmenuModelAt(int index) const OVERRIDE {
+  virtual ui::MenuModel* GetSubmenuModelAt(int index) const override {
     return NULL;
   }
 
-  virtual void HighlightChangedTo(int index) OVERRIDE {
+  virtual void HighlightChangedTo(int index) override {
   }
 
-  virtual void ActivatedAt(int index) OVERRIDE {
+  virtual void ActivatedAt(int index) override {
   }
 
-  virtual void SetMenuModelDelegate(ui::MenuModelDelegate* delegate) OVERRIDE {
+  virtual void SetMenuModelDelegate(ui::MenuModelDelegate* delegate) override {
   }
 
-  virtual ui::MenuModelDelegate* GetMenuModelDelegate() const OVERRIDE {
+  virtual ui::MenuModelDelegate* GetMenuModelDelegate() const override {
     return NULL;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CommonMenuModel);
 };
 
 class SubMenuModel : public CommonMenuModel {
  public:
   SubMenuModel()
       : showing_(false) {
   }
 
   virtual ~SubMenuModel() {
   }
 
   bool showing() const {
     return showing_;
   }
 
  private:
   // ui::MenuModel implementation.
-  virtual int GetItemCount() const OVERRIDE {
+  virtual int GetItemCount() const override {
     return 1;
   }
 
-  virtual ItemType GetTypeAt(int index) const OVERRIDE {
+  virtual ItemType GetTypeAt(int index) const override {
     return TYPE_COMMAND;
   }
 
-  virtual int GetCommandIdAt(int index) const OVERRIDE {
+  virtual int GetCommandIdAt(int index) const override {
     return index + kSubMenuBaseId;
   }
 
-  virtual base::string16 GetLabelAt(int index) const OVERRIDE {
+  virtual base::string16 GetLabelAt(int index) const override {
     return base::ASCIIToUTF16("Item");
   }
 
-  virtual void MenuWillShow() OVERRIDE {
+  virtual void MenuWillShow() override {
     showing_ = true;
   }
 
   // Called when the menu has been closed.
-  virtual void MenuClosed() OVERRIDE {
+  virtual void MenuClosed() override {
     showing_ = false;
   }
 
   bool showing_;
 
   DISALLOW_COPY_AND_ASSIGN(SubMenuModel);
 };
 
 class TopMenuModel : public CommonMenuModel {
  public:
   TopMenuModel() {
   }
 
   virtual ~TopMenuModel() {
   }
 
   bool IsSubmenuShowing() {
     return sub_menu_model_.showing();
   }
 
  private:
   // ui::MenuModel implementation.
-  virtual int GetItemCount() const OVERRIDE {
+  virtual int GetItemCount() const override {
     return 1;
   }
 
-  virtual ItemType GetTypeAt(int index) const OVERRIDE {
+  virtual ItemType GetTypeAt(int index) const override {
     return TYPE_SUBMENU;
   }
 
-  virtual int GetCommandIdAt(int index) const OVERRIDE {
+  virtual int GetCommandIdAt(int index) const override {
     return index + kTopMenuBaseId;
   }
 
-  virtual base::string16 GetLabelAt(int index) const OVERRIDE {
+  virtual base::string16 GetLabelAt(int index) const override {
     return base::ASCIIToUTF16("submenu");
   }
 
-  virtual MenuModel* GetSubmenuModelAt(int index) const OVERRIDE {
+  virtual MenuModel* GetSubmenuModelAt(int index) const override {
     return &sub_menu_model_;
   }
 
   mutable SubMenuModel sub_menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(TopMenuModel);
 };
 
 }  // namespace
 
 class MenuModelAdapterTest : public ViewEventTestBase,
                              public views::MenuButtonListener {
  public:
   MenuModelAdapterTest()
       : ViewEventTestBase(),
         button_(NULL),
         menu_model_adapter_(&top_menu_model_),
         menu_(NULL) {
   }
 
   virtual ~MenuModelAdapterTest() {
   }
 
   // ViewEventTestBase implementation.
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     button_ = new views::MenuButton(
         NULL, base::ASCIIToUTF16("Menu Adapter Test"), this, true);
 
     menu_ = menu_model_adapter_.CreateMenu();
     menu_runner_.reset(
         new views::MenuRunner(menu_, views::MenuRunner::HAS_MNEMONICS));
 
     ViewEventTestBase::SetUp();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     menu_runner_.reset(NULL);
     menu_ = NULL;
     ViewEventTestBase::TearDown();
   }
 
-  virtual views::View* CreateContentsView() OVERRIDE {
+  virtual views::View* CreateContentsView() override {
     return button_;
   }
 
-  virtual gfx::Size GetPreferredSize() const OVERRIDE {
+  virtual gfx::Size GetPreferredSize() const override {
     return button_->GetPreferredSize();
   }
 
   // views::MenuButtonListener implementation.
   virtual void OnMenuButtonClicked(views::View* source,
-                                   const gfx::Point& point) OVERRIDE {
+                                   const gfx::Point& point) override {
     gfx::Point screen_location;
     views::View::ConvertPointToScreen(source, &screen_location);
     gfx::Rect bounds(screen_location, source->size());
     ignore_result(menu_runner_->RunMenuAt(source->GetWidget(),
                                           button_,
                                           bounds,
                                           views::MENU_ANCHOR_TOPLEFT,
                                           ui::MENU_SOURCE_NONE));
   }
 
   // ViewEventTestBase implementation
-  virtual void DoTestOnMessageLoop() OVERRIDE {
+  virtual void DoTestOnMessageLoop() override {
     Click(button_, CreateEventTask(this, &MenuModelAdapterTest::Step1));
   }
 
   // Open the submenu.
   void Step1() {
     views::SubmenuView* topmenu = menu_->GetSubmenu();
     ASSERT_TRUE(topmenu);
     ASSERT_TRUE(topmenu->IsShowing());
     ASSERT_FALSE(top_menu_model_.IsSubmenuShowing());
 
@@ skipping 49 matching lines @@
   }
 
   views::MenuButton* button_;
   TopMenuModel top_menu_model_;
   views::MenuModelAdapter menu_model_adapter_;
   views::MenuItemView* menu_;
   scoped_ptr<views::MenuRunner> menu_runner_;
 };
 
 VIEW_TEST(MenuModelAdapterTest, RebuildMenu)