Standardize usage of virtual/override/final specifiers.

chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.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 "chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.h"
 
 #include <algorithm>
 
 #include "ash/wm/window_state.h"
 #include "base/bind.h"
@@ skipping 51 matching lines @@
 
 namespace {
 
 const char kTabDragControllerInteractiveUITestUserDataKey[] =
     "TabDragControllerInteractiveUITestUserData";
 
 class TabDragControllerInteractiveUITestUserData
     : public base::SupportsUserData::Data {
  public:
   explicit TabDragControllerInteractiveUITestUserData(int id) : id_(id) {}
-  virtual ~TabDragControllerInteractiveUITestUserData() {}
+  ~TabDragControllerInteractiveUITestUserData() override {}
   int id() { return id_; }
 
  private:
   int id_;
 };
 
 }  // namespace
 
 class QuitDraggingObserver : public content::NotificationObserver {
  public:
   QuitDraggingObserver() {
     registrar_.Add(this, chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
                    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 {
     DCHECK_EQ(chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE, type);
     base::MessageLoopForUI::current()->Quit();
     delete this;
   }
 
  private:
-  virtual ~QuitDraggingObserver() {}
+  ~QuitDraggingObserver() override {}
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(QuitDraggingObserver);
 };
 
 gfx::Point GetCenterInScreenCoordinates(const views::View* view) {
   gfx::Point center(view->width() / 2, view->height() / 2);
   views::View::ConvertPointToScreen(view, &center);
   return center;
@@ skipping 103 matching lines @@
 }
 
 }  // namespace
 
 #if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
 class ScreenEventGeneratorDelegate
     : public aura::test::EventGeneratorDelegateAura {
  public:
   explicit ScreenEventGeneratorDelegate(aura::Window* root_window)
       : root_window_(root_window) {}
-  virtual ~ScreenEventGeneratorDelegate() {}
+  ~ScreenEventGeneratorDelegate() override {}
 
   // EventGeneratorDelegateAura overrides:
-  virtual aura::WindowTreeHost* GetHostAt(
-      const gfx::Point& point) const override {
+  aura::WindowTreeHost* GetHostAt(const gfx::Point& point) const override {
     return root_window_->GetHost();
   }
 
-  virtual aura::client::ScreenPositionClient* GetScreenPositionClient(
+  aura::client::ScreenPositionClient* GetScreenPositionClient(
       const aura::Window* window) const override {
     return aura::client::GetScreenPositionClient(root_window_);
   }
 
  private:
   aura::Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenEventGeneratorDelegate);
 };
 
 #endif
 
 #if !defined(OS_CHROMEOS)
 
 // Following classes verify a crash scenario. Specifically on Windows when focus
 // changes it can trigger capture being lost. This was causing a crash in tab
 // dragging as it wasn't set up to handle this scenario. These classes
 // synthesize this scenario.
 
 // Allows making ClearNativeFocus() invoke ReleaseCapture().
 class TestDesktopBrowserFrameAura : public DesktopBrowserFrameAura {
  public:
   TestDesktopBrowserFrameAura(
       BrowserFrame* browser_frame,
       BrowserView* browser_view)
       : DesktopBrowserFrameAura(browser_frame, browser_view),
         release_capture_(false) {}
-  virtual ~TestDesktopBrowserFrameAura() {}
+  ~TestDesktopBrowserFrameAura() override {}
 
   void ReleaseCaptureOnNextClear() {
     release_capture_ = true;
   }
 
-  virtual void ClearNativeFocus() override {
+  void ClearNativeFocus() override {
     views::DesktopNativeWidgetAura::ClearNativeFocus();
     if (release_capture_) {
       release_capture_ = false;
       GetWidget()->ReleaseCapture();
     }
   }
 
  private:
   // If true ReleaseCapture() is invoked in ClearNativeFocus().
   bool release_capture_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDesktopBrowserFrameAura);
 };
 
 // Factory for creating a TestDesktopBrowserFrameAura.
 class TestNativeBrowserFrameFactory : public NativeBrowserFrameFactory {
  public:
   TestNativeBrowserFrameFactory() {}
-  virtual ~TestNativeBrowserFrameFactory() {}
+  ~TestNativeBrowserFrameFactory() override {}
 
-  virtual NativeBrowserFrame* Create(
-      BrowserFrame* browser_frame,
-      BrowserView* browser_view) override {
+  NativeBrowserFrame* Create(BrowserFrame* browser_frame,
+                             BrowserView* browser_view) override {
     return new TestDesktopBrowserFrameAura(browser_frame, browser_view);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestNativeBrowserFrameFactory);
 };
 
 class TabDragCaptureLostTest : public TabDragControllerTest {
  public:
   TabDragCaptureLostTest() {
@@ skipping 54 matching lines @@
 }
 
 #endif
 
 class DetachToBrowserTabDragControllerTest
     : public TabDragControllerTest,
       public ::testing::WithParamInterface<const char*> {
  public:
   DetachToBrowserTabDragControllerTest() {}
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
 #if defined(OS_CHROMEOS)
     event_generator_.reset(
         new ui::test::EventGenerator(ash::Shell::GetPrimaryRootWindow()));
 #endif
   }
 
   InputSource input_source() const {
     return strstr(GetParam(), "mouse") ?
         INPUT_SOURCE_MOUSE : INPUT_SOURCE_TOUCH;
   }
@@ skipping 1838 matching lines @@
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTestTouch,
                         ::testing::Values("touch"));
 #elif defined(USE_ASH)
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse"));
 #endif