Standardize usage of virtual/override/final specifiers.

chrome/browser/ui/views/bookmarks/bookmark_bar_view_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/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 47 matching lines @@
 // Waits for a views::Widget dialog to show up.
 class DialogWaiter : public aura::EnvObserver,
                      public views::WidgetObserver {
  public:
   DialogWaiter()
       : dialog_created_(false),
         dialog_(NULL) {
     aura::Env::GetInstance()->AddObserver(this);
   }
 
-  virtual ~DialogWaiter() {
-    aura::Env::GetInstance()->RemoveObserver(this);
-  }
+  ~DialogWaiter() override { aura::Env::GetInstance()->RemoveObserver(this); }
 
   views::Widget* WaitForDialog() {
     if (dialog_created_)
       return dialog_;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     return dialog_;
   }
 
  private:
   // aura::EnvObserver:
-  virtual void OnWindowInitialized(aura::Window* window) override {
+  void OnWindowInitialized(aura::Window* window) override {
     if (dialog_)
       return;
     views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
     if (!widget || !widget->IsDialogBox())
       return;
     dialog_ = widget;
     dialog_->AddObserver(this);
   }
 
   // views::WidgetObserver:
-  virtual void OnWidgetVisibilityChanged(views::Widget* widget,
-                                         bool visible) override {
+  void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override {
     CHECK_EQ(dialog_, widget);
     if (visible) {
       dialog_created_ = true;
       dialog_->RemoveObserver(this);
       if (!quit_closure_.is_null())
         quit_closure_.Run();
     }
   }
 
   bool dialog_created_;
   views::Widget* dialog_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(DialogWaiter);
 };
 
 // Waits for a dialog to terminate.
 class DialogCloseWaiter : public views::WidgetObserver {
  public:
   explicit DialogCloseWaiter(views::Widget* dialog)
       : dialog_closed_(false) {
     dialog->AddObserver(this);
   }
 
-  virtual ~DialogCloseWaiter() {
+  ~DialogCloseWaiter() override {
     // It is not necessary to remove |this| from the dialog's observer, since
     // the dialog is destroyed before this waiter.
   }
 
   void WaitForDialogClose() {
     if (dialog_closed_)
       return;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 
  private:
   // views::WidgetObserver:
-  virtual void OnWidgetDestroyed(views::Widget* widget) override {
+  void OnWidgetDestroyed(views::Widget* widget) override {
     dialog_closed_ = true;
     if (!quit_closure_.is_null())
       quit_closure_.Run();
   }
 
   bool dialog_closed_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(DialogCloseWaiter);
 };
 
 // Waits for a views::Widget to receive a Tab key.
 class TabKeyWaiter : public ui::EventHandler {
  public:
   explicit TabKeyWaiter(views::Widget* widget)
       : widget_(widget),
         received_tab_(false) {
     widget_->GetNativeView()->AddPreTargetHandler(this);
   }
 
-  virtual ~TabKeyWaiter() {
+  ~TabKeyWaiter() override {
     widget_->GetNativeView()->RemovePreTargetHandler(this);
   }
 
   void WaitForTab() {
     if (received_tab_)
       return;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 
  private:
   // ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override {
+  void OnKeyEvent(ui::KeyEvent* event) override {
     if (event->type() == ui::ET_KEY_RELEASED &&
         event->key_code() == ui::VKEY_TAB) {
       received_tab_ = true;
       if (!quit_closure_.is_null())
         quit_closure_.Run();
     }
   }
 
   views::Widget* widget_;
   bool received_tab_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(TabKeyWaiter);
 };
 
 void MoveMouseAndPress(const gfx::Point& screen_pos,
                        ui_controls::MouseButton button,
                        int state,
                        const base::Closure& closure) {
   ui_controls::SendMouseMove(screen_pos.x(), screen_pos.y());
   ui_controls::SendMouseEventsNotifyWhenDone(button, state, closure);
 }
 
 // PageNavigator implementation that records the URL.
 class TestingPageNavigator : public PageNavigator {
  public:
-  virtual WebContents* OpenURL(const OpenURLParams& params) override {
+  WebContents* OpenURL(const OpenURLParams& params) override {
     url_ = params.url;
     return NULL;
   }
 
   GURL url_;
 };
 
 // TODO(erg): Fix bookmark DND tests on linux_aura. crbug.com/163931
 #if defined(OS_LINUX) && defined(USE_AURA)
 #define MAYBE(x) DISABLED_##x
@@ skipping 33 matching lines @@
 //   the names f1-f100.
 //
 // Subclasses should be sure and invoke super's implementation of SetUp and
 // TearDown.
 class BookmarkBarViewEventTestBase : public ViewEventTestBase {
  public:
   BookmarkBarViewEventTestBase()
       : ViewEventTestBase(),
         model_(NULL) {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     content_client_.reset(new ChromeContentClient);
     content::SetContentClient(content_client_.get());
     browser_content_client_.reset(new chrome::ChromeContentBrowserClient());
     content::SetBrowserClientForTesting(browser_content_client_.get());
 
     views::MenuController::TurnOffMenuSelectionHoldForTest();
     BookmarkBarView::DisableAnimationsForTesting(true);
     SetConstrainedWindowViewsClient(CreateChromeConstrainedWindowViewsClient());
 
     profile_.reset(new TestingProfile());
@@ skipping 29 matching lines @@
     bb_view_pref_.set_width(1000);
     do {
       bb_view_pref_.set_width(bb_view_pref_.width() - 25);
       bb_view_->SetBounds(0, 0, bb_view_pref_.width(), bb_view_pref_.height());
       bb_view_->Layout();
     } while (GetBookmarkButton(6)->visible());
 
     ViewEventTestBase::SetUp();
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     // Destroy everything, then run the message loop to ensure we delete all
     // Tasks and fully shut down.
     browser_->tab_strip_model()->CloseAllTabs();
     bb_view_.reset();
     browser_.reset();
     profile_.reset();
 
     // Run the message loop to ensure we delete allTasks and fully shut down.
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     base::RunLoop run_loop;
     loop->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
 
     ViewEventTestBase::TearDown();
     BookmarkBarView::DisableAnimationsForTesting(false);
     SetConstrainedWindowViewsClient(scoped_ptr<ConstrainedWindowViewsClient>());
 
     browser_content_client_.reset();
     content_client_.reset();
     content::SetContentClient(NULL);
   }
 
  protected:
-  virtual views::View* CreateContentsView() override {
-    return bb_view_.get();
-  }
+  views::View* CreateContentsView() override { return bb_view_.get(); }
 
-  virtual gfx::Size GetPreferredSize() const override { return bb_view_pref_; }
+  gfx::Size GetPreferredSize() const override { return bb_view_pref_; }
 
   views::LabelButton* GetBookmarkButton(int view_index) {
     return bb_view_->GetBookmarkButton(view_index);
   }
 
   // See comment above class description for what this does.
   virtual bool CreateBigMenu() { return false; }
 
   BookmarkModel* model_;
   scoped_ptr<BookmarkBarView> bb_view_;
@@ skipping 37 matching lines @@
   scoped_ptr<chrome::ChromeContentBrowserClient> browser_content_client_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<Browser> browser_;
   scoped_ptr<ScopedTestingLocalState> local_state_;
 };
 
 // Clicks on first menu, makes sure button is depressed. Moves mouse to first
 // child, clicks it and makes sure a navigation occurs.
 class BookmarkBarViewTest1 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest1::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 30 matching lines @@
 
     Done();
   }
 };
 
 VIEW_TEST(BookmarkBarViewTest1, Basic)
 
 // Brings up menu, clicks on empty space and make sure menu hides.
 class BookmarkBarViewTest2 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest2::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 40 matching lines @@
 #else
 #define MAYBE_HideOnDesktopClick HideOnDesktopClick
 #endif
 
 VIEW_TEST(BookmarkBarViewTest2, MAYBE_HideOnDesktopClick)
 
 // Brings up menu. Moves over child to make sure submenu appears, moves over
 // another child and make sure next menu appears.
 class BookmarkBarViewTest3 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::MenuButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest3::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 60 matching lines @@
 class BookmarkContextMenuNotificationObserver
     : public content::NotificationObserver {
  public:
   explicit BookmarkContextMenuNotificationObserver(const base::Closure& task)
       : task_(task) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BOOKMARK_CONTEXT_MENU_SHOWN,
                    content::NotificationService::AllSources());
   }
 
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     base::MessageLoop::current()->PostTask(FROM_HERE, task_);
   }
 
   // Sets the task that is posted when the context menu is shown.
   void set_task(const base::Closure& task) { task_ = task; }
 
  private:
   content::NotificationRegistrar registrar_;
   base::Closure task_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkContextMenuNotificationObserver);
 };
 
 // Tests context menus by way of opening a context menu for a bookmark,
 // then right clicking to get context menu and selecting the first menu item
 // (open).
 class BookmarkBarViewTest4 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest4()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest4::Step3)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest4::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 32 matching lines @@
   }
 
   BookmarkContextMenuNotificationObserver observer_;
 };
 
 VIEW_TEST(BookmarkBarViewTest4, ContextMenus)
 
 // Tests drag and drop within the same menu.
 class BookmarkBarViewTest5 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     url_dragging_ =
         model_->bookmark_bar_node()->GetChild(0)->GetChild(0)->url();
 
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest5::Step2));
   }
@@ skipping 52 matching lines @@
 };
 
 #if !defined(OS_WIN)  // flaky http://crbug.com/400578
 VIEW_TEST(BookmarkBarViewTest5, MAYBE(DND))
 #endif
 
 // Tests holding mouse down on overflow button, dragging such that menu pops up
 // then selecting an item.
 class BookmarkBarViewTest6 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Press the mouse button on the overflow button. Don't release it though.
     views::LabelButton* button = bb_view_->overflow_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN, CreateEventTask(this, &BookmarkBarViewTest6::Step2));
   }
 
  private:
   void Step2() {
     // Menu should be showing.
     views::MenuItemView* menu = bb_view_->GetMenu();
@@ skipping 16 matching lines @@
   }
 
   GURL url_dragging_;
 };
 
 VIEW_TEST(BookmarkBarViewTest6, OpenMenuOnClickAndHold)
 
 // Tests drag and drop to different menu.
 class BookmarkBarViewTest7 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     url_dragging_ =
         model_->bookmark_bar_node()->GetChild(0)->GetChild(0)->url();
 
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest7::Step2));
   }
@@ skipping 79 matching lines @@
 // This test passes locally (on aero and non-aero) but fails on the trybots and
 // buildbot.
 // http://crbug.com/154081
 VIEW_TEST(BookmarkBarViewTest7, MAYBE(DNDToDifferentMenu))
 #endif
 
 // Drags from one menu to next so that original menu closes, then back to
 // original menu.
 class BookmarkBarViewTest8 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     url_dragging_ =
         model_->bookmark_bar_node()->GetChild(0)->GetChild(0)->url();
 
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest8::Step2));
   }
@@ skipping 87 matching lines @@
 #if !defined(OS_WIN)
 // This test passes locally (on aero and non-aero) but fails on the trybots and
 // buildbot.
 // http://crbug.com/154081
 VIEW_TEST(BookmarkBarViewTest8, MAYBE(DNDBackToOriginatingMenu))
 #endif
 
 // Moves the mouse over the scroll button and makes sure we get scrolling.
 class BookmarkBarViewTest9 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual bool CreateBigMenu() override { return true; }
+  bool CreateBigMenu() override { return true; }
 
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest9::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 48 matching lines @@
 
   int start_y_;
   views::MenuItemView* first_menu_;
 };
 
 VIEW_TEST(BookmarkBarViewTest9, ScrollButtonScrolls)
 
 // Tests up/down/left/enter key messages.
 class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest10::Step2));
     base::MessageLoop::current()->RunUntilIdle();
   }
 
  private:
@@ skipping 100 matching lines @@
 // context menu, close context menu (via escape), then click else where. This
 // effectively verifies we maintain mouse capture after the context menu is
 // hidden.
 class BookmarkBarViewTest11 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest11()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest11::Step3)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest11::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 59 matching lines @@
   DISABLED_CloseMenuAfterClosingContextMenu
 #else
 #define MAYBE_CloseMenuAfterClosingContextMenu CloseMenuAfterClosingContextMenu
 #endif
 
 VIEW_TEST(BookmarkBarViewTest11, MAYBE_CloseMenuAfterClosingContextMenu)
 
 // Tests showing a modal dialog from a context menu.
 class BookmarkBarViewTest12 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Open up the other folder.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest12::Step2));
     chrome::num_bookmark_urls_before_prompting = 1;
   }
 
-  virtual ~BookmarkBarViewTest12() {
+  ~BookmarkBarViewTest12() override {
     chrome::num_bookmark_urls_before_prompting = 15;
   }
 
  private:
   void Step2() {
     // Menu should be showing.
     views::MenuItemView* menu = bb_view_->GetMenu();
     ASSERT_TRUE(menu != NULL);
     ASSERT_TRUE(menu->GetSubmenu()->IsShowing());
 
@@ skipping 72 matching lines @@
 
 // Tests clicking on the separator of a context menu (this is for coverage of
 // bug 17862).
 class BookmarkBarViewTest13 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest13()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest13::Step3)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest13::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 63 matching lines @@
 
 // Makes sure right clicking on a folder on the bookmark bar doesn't result in
 // both a context menu and showing the menu.
 class BookmarkBarViewTest14 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest14()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest14::Step2)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // right mouse button.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::RIGHT,
         ui_controls::DOWN | ui_controls::UP, base::Closure());
     // Step2 will be invoked by BookmarkContextMenuNotificationObserver.
   }
 
  private:
 
@@ skipping 26 matching lines @@
 
 // Makes sure deleting from the context menu keeps the bookmark menu showing.
 class BookmarkBarViewTest15 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest15()
       : deleted_menu_id_(0),
         observer_(CreateEventTask(this, &BookmarkBarViewTest15::Step3)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Show the other bookmarks.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest15::Step2));
   }
 
  private:
   void Step2() {
     // Menu should be showing.
@@ skipping 50 matching lines @@
 
   int deleted_menu_id_;
   BookmarkContextMenuNotificationObserver observer_;
 };
 
 VIEW_TEST(BookmarkBarViewTest15, MenuStaysVisibleAfterDelete)
 
 // Tests that we don't crash or get stuck if the parent of a menu is closed.
 class BookmarkBarViewTest16 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the first folder on the bookmark bar and press the
     // mouse.
     views::LabelButton* button = GetBookmarkButton(0);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest16::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 26 matching lines @@
 
 // Makes sure right clicking on an item while a context menu is already showing
 // doesn't crash and works.
 class BookmarkBarViewTest17 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest17()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest17::Step3)) {
   }
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the other folder on the bookmark bar and press the
     // left mouse button.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest17::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 68 matching lines @@
 #define MAYBE_ContextMenus3 ContextMenus3
 #endif
 
 VIEW_TEST(BookmarkBarViewTest17, MAYBE_ContextMenus3)
 
 // Verifies sibling menus works. Clicks on the 'other bookmarks' folder, then
 // moves the mouse over the first item on the bookmark bar and makes sure the
 // menu appears.
 class BookmarkBarViewTest18 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the other folder on the bookmark bar and press the
     // left mouse button.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest18::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 36 matching lines @@
 #define MAYBE_BookmarkBarViewTest18_SiblingMenu \
   BookmarkBarViewTest18_SiblingMenu
 #endif
 
 VIEW_TEST(BookmarkBarViewTest18, MAYBE_BookmarkBarViewTest18_SiblingMenu)
 
 // Verifies mousing over an already open sibling menu doesn't prematurely cancel
 // the menu.
 class BookmarkBarViewTest19 : public BookmarkBarViewEventTestBase {
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Move the mouse to the other folder on the bookmark bar and press the
     // left mouse button.
     views::LabelButton* button = bb_view_->other_bookmarked_button();
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest19::Step2));
   }
 
  private:
   void Step2() {
@@ skipping 57 matching lines @@
 VIEW_TEST(BookmarkBarViewTest19, BookmarkBarViewTest19_SiblingMenu)
 
 // Verify that when clicking a mouse button outside a context menu,
 // the context menu is dismissed *and* the underlying view receives
 // the the mouse event (due to event reposting).
 class BookmarkBarViewTest20 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest20() : test_view_(new TestViewForMenuExit) {}
 
  protected:
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     // Add |test_view_| next to |bb_view_|.
     views::View* parent = bb_view_->parent();
     views::View* container_view = new ContainerViewForMenuExit;
     container_view->AddChildView(bb_view_.get());
     container_view->AddChildView(test_view_);
     parent->AddChildView(container_view);
     parent->Layout();
 
     ASSERT_EQ(test_view_->press_count(), 0);
 
@@ skipping 35 matching lines @@
     ASSERT_EQ(test_view_->press_count(), 2);
     ASSERT_TRUE(bb_view_->GetMenu() == NULL);
     Done();
   }
 
   class ContainerViewForMenuExit : public views::View {
    public:
     ContainerViewForMenuExit() {
     }
 
-    virtual void Layout() override {
+    void Layout() override {
       DCHECK_EQ(2, child_count());
       views::View* bb_view = child_at(0);
       views::View* test_view = child_at(1);
       const int width = bb_view->width();
       const int height = bb_view->height();
       bb_view->SetBounds(0,0, width - 22, height);
       test_view->SetBounds(width - 20, 0, 20, height);
     }
 
    private:
 
     DISALLOW_COPY_AND_ASSIGN(ContainerViewForMenuExit);
   };
 
   class TestViewForMenuExit : public views::View {
    public:
     TestViewForMenuExit() : press_count_(0) {
     }
-    virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+    bool OnMousePressed(const ui::MouseEvent& event) override {
       ++press_count_;
       return true;
     }
     int press_count() const { return press_count_; }
 
    private:
     int press_count_;
 
     DISALLOW_COPY_AND_ASSIGN(TestViewForMenuExit);
   };
@@ skipping 14 matching lines @@
 // The opened context menu should behave as it is from the folder button.
 class BookmarkBarViewTest21 : public BookmarkBarViewEventTestBase {
  public:
   BookmarkBarViewTest21()
       : observer_(CreateEventTask(this, &BookmarkBarViewTest21::Step3)) {
   }
 
  protected:
   // Move the mouse to the empty folder on the bookmark bar and press the
   // left mouse button.
-  virtual void DoTestOnMessageLoop() override {
+  void DoTestOnMessageLoop() override {
     views::LabelButton* button = GetBookmarkButton(5);
     ui_test_utils::MoveMouseToCenterAndPress(button, ui_controls::LEFT,
         ui_controls::DOWN | ui_controls::UP,
         CreateEventTask(this, &BookmarkBarViewTest21::Step2));
   }
 
  private:
   // Confirm that a menu for empty folder shows and right click the menu.
   void Step2() {
     // Menu should be showing.
@@ skipping 40 matching lines @@
     EXPECT_TRUE(bb_view_->GetContextMenu() == NULL);
     EXPECT_TRUE(bb_view_->GetMenu() == NULL);
 
     Done();
   }
 
   BookmarkContextMenuNotificationObserver observer_;
 };
 
 VIEW_TEST(BookmarkBarViewTest21, ContextMenusForEmptyFolder)