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

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 69 matching lines @@
 
 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 {
+                       const content::NotificationDetails& details) override {
     DCHECK_EQ(chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE, type);
     base::MessageLoopForUI::current()->Quit();
     delete this;
   }
 
  private:
   virtual ~QuitDraggingObserver() {}
 
   content::NotificationRegistrar registrar_;
 
@@ skipping 114 matching lines @@
 #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() {}
 
   // EventGeneratorDelegateAura overrides:
   virtual aura::WindowTreeHost* GetHostAt(
-      const gfx::Point& point) const OVERRIDE {
+      const gfx::Point& point) const override {
     return root_window_->GetHost();
   }
 
   virtual aura::client::ScreenPositionClient* GetScreenPositionClient(
-      const aura::Window* window) const OVERRIDE {
+      const aura::Window* window) const override {
     return aura::client::GetScreenPositionClient(root_window_);
   }
 
  private:
   aura::Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenEventGeneratorDelegate);
 };
 
 #endif
@@ skipping 12 matching lines @@
       BrowserFrame* browser_frame,
       BrowserView* browser_view)
       : DesktopBrowserFrameAura(browser_frame, browser_view),
         release_capture_(false) {}
   virtual ~TestDesktopBrowserFrameAura() {}
 
   void ReleaseCaptureOnNextClear() {
     release_capture_ = true;
   }
 
-  virtual void ClearNativeFocus() OVERRIDE {
+  virtual 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() {}
 
   virtual NativeBrowserFrame* Create(
       BrowserFrame* browser_frame,
-      BrowserView* browser_view) OVERRIDE {
+      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 {
+  virtual 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 1063 matching lines @@
 }
 
 // Subclass of DetachToBrowserTabDragControllerTest that
 // creates multiple displays.
 class DetachToBrowserInSeparateDisplayTabDragControllerTest
     : public DetachToBrowserTabDragControllerTest {
  public:
   DetachToBrowserInSeparateDisplayTabDragControllerTest() {}
   virtual ~DetachToBrowserInSeparateDisplayTabDragControllerTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     DetachToBrowserTabDragControllerTest::SetUpCommandLine(command_line);
     // Make screens sufficiently wide to host 2 browsers side by side.
     command_line->AppendSwitchASCII("ash-host-window-bounds",
                                     "0+0-600x600,601+0-600x600");
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       DetachToBrowserInSeparateDisplayTabDragControllerTest);
 };
@@ skipping 357 matching lines @@
 }
 
 // Subclass of DetachToBrowserTabDragControllerTest that
 // creates multiple displays with different device scale factors.
 class DifferentDeviceScaleFactorDisplayTabDragControllerTest
     : public DetachToBrowserTabDragControllerTest {
  public:
   DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
   virtual ~DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     DetachToBrowserTabDragControllerTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII("ash-host-window-bounds",
                                     "400x400,0+400-800x800*2");
   }
 
   float GetCursorDeviceScaleFactor() const {
     ash::test::CursorManagerTestApi cursor_test_api(
         ash::Shell::GetInstance()->cursor_manager());
     return cursor_test_api.GetCurrentCursor().device_scale_factor();
   }
@@ skipping 78 matching lines @@
   QuitWhenNotDragging();
 }
 
 namespace {
 
 class DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest
     : public TabDragControllerTest {
  public:
   DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     TabDragControllerTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII("ash-host-window-bounds",
                                     "0+0-250x250,251+0-250x250");
   }
 
   bool Press(const gfx::Point& position) {
     return ui_test_utils::SendMouseMoveSync(position) &&
         ui_test_utils::SendMouseEventsSync(ui_controls::LEFT,
                                            ui_controls::DOWN);
   }
@@ skipping 277 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