Standardize usage of virtual/override/final specifiers.

The Google C++ style guide states:

  Explicitly annotate overrides of virtual functions or virtual
  destructors with an override or (less frequently) final specifier.
  Older (pre-C++11) code will use the virtual keyword as an inferior
  alternative annotation. For clarity, use exactly one of override,
  final, or virtual when declaring an override.

To better conform to these guidelines, the following constructs have
been rewritten:

- if a base class has a virtual destructor, then:
    virtual ~Foo();                   ->  ~Foo() override;
- virtual void Foo() override;        ->  void Foo() override;
- virtual void Foo() override final;  ->  void Foo() final;

This patch was automatically generated. The clang plugin can generate
fixit hints, which are suggested edits when it is 100% sure it knows how
to fix a problem. The hints from the clang plugin were applied to the
source tree using the tool in https://codereview.chromium.org/598073004.

BUG=417463
R=derat@chromium.org

Review URL: https://codereview.chromium.org/685543003

Cr-Commit-Position: refs/heads/master@{#301523}

ash/display/cursor_window_controller.cc

@@ -26,37 +26,35 @@ namespace ash {
 class CursorWindowDelegate : public aura::WindowDelegate {
  public:
   CursorWindowDelegate() : is_cursor_compositing_enabled_(false) {}
-  virtual ~CursorWindowDelegate() {}
+  ~CursorWindowDelegate() override {}
 
   // aura::WindowDelegate overrides:
-  virtual gfx::Size GetMinimumSize() const override { return size_; }
-  virtual gfx::Size GetMaximumSize() const override { return size_; }
-  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) override {}
-  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) override {
+  gfx::Size GetMinimumSize() const override { return size_; }
+  gfx::Size GetMaximumSize() const override { return size_; }
+  void OnBoundsChanged(const gfx::Rect& old_bounds,
+                       const gfx::Rect& new_bounds) override {}
+  gfx::NativeCursor GetCursor(const gfx::Point& point) override {
     return gfx::kNullCursor;
   }
-  virtual int GetNonClientComponent(
-      const gfx::Point& point) const override {
+  int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
-  virtual bool ShouldDescendIntoChildForEventHandling(
+  bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) override {
     return false;
   }
-  virtual bool CanFocus() override { return false; }
-  virtual void OnCaptureLost() override {}
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  bool CanFocus() override { return false; }
+  void OnCaptureLost() override {}
+  void OnPaint(gfx::Canvas* canvas) override {
     canvas->DrawImageInt(cursor_image_, 0, 0);
   }
-  virtual void OnDeviceScaleFactorChanged(
-      float device_scale_factor) override {}
-  virtual void OnWindowDestroying(aura::Window* window) override {}
-  virtual void OnWindowDestroyed(aura::Window* window) override {}
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {}
-  virtual bool HasHitTestMask() const override { return false; }
-  virtual void GetHitTestMask(gfx::Path* mask) const override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  void OnWindowDestroying(aura::Window* window) override {}
+  void OnWindowDestroyed(aura::Window* window) override {}
+  void OnWindowTargetVisibilityChanged(bool visible) override {}
+  bool HasHitTestMask() const override { return false; }
+  void GetHitTestMask(gfx::Path* mask) const override {}
 
   // Sets cursor compositing mode on/off.
   void SetCursorCompositingEnabled(bool enabled) {

ash/display/display_controller.h

@@ -72,7 +72,7 @@ class ASH_EXPORT DisplayController : public gfx::DisplayObserver,
   };
 
   DisplayController();
-  virtual ~DisplayController();
+  ~DisplayController() override;
 
   void Start();
   void Shutdown();
@@ -144,20 +144,19 @@ class ASH_EXPORT DisplayController : public gfx::DisplayObserver,
   bool UpdateWorkAreaOfDisplayNearestWindow(const aura::Window* window,
                                             const gfx::Insets& insets);
   // gfx::DisplayObserver overrides:
-  virtual void OnDisplayAdded(const gfx::Display& display) override;
-  virtual void OnDisplayRemoved(const gfx::Display& display) override;
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) override;
+  void OnDisplayAdded(const gfx::Display& display) override;
+  void OnDisplayRemoved(const gfx::Display& display) override;
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t metrics) override;
 
   // aura::WindowTreeHostObserver overrides:
-  virtual void OnHostResized(const aura::WindowTreeHost* host) override;
+  void OnHostResized(const aura::WindowTreeHost* host) override;
 
   // aura::DisplayManager::Delegate overrides:
-  virtual void CreateOrUpdateNonDesktopDisplay(const DisplayInfo& info)
-      override;
-  virtual void CloseNonDesktopDisplay() override;
-  virtual void PreDisplayConfigurationChange(bool clear_focus) override;
-  virtual void PostDisplayConfigurationChange() override;
+  void CreateOrUpdateNonDesktopDisplay(const DisplayInfo& info) override;
+  void CloseNonDesktopDisplay() override;
+  void PreDisplayConfigurationChange(bool clear_focus) override;
+  void PostDisplayConfigurationChange() override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, BoundsUpdated);

ash/display/display_controller_unittest.cc

@@ -80,7 +80,7 @@ class TestObserver : public DisplayController::Observer,
         AddObserver(this);
   }
 
-  virtual ~TestObserver() {
+  ~TestObserver() override {
     Shell::GetInstance()->display_controller()->RemoveObserver(this);
     Shell::GetScreen()->RemoveObserver(this);
     aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())->
@@ -90,16 +90,12 @@ class TestObserver : public DisplayController::Observer,
   }
 
   // Overridden from DisplayController::Observer
-  virtual void OnDisplayConfigurationChanging() override {
-    ++changing_count_;
-  }
-  virtual void OnDisplayConfigurationChanged() override {
-    ++changed_count_;
-  }
+  void OnDisplayConfigurationChanging() override { ++changing_count_; }
+  void OnDisplayConfigurationChanged() override { ++changed_count_; }
 
   // Overrideen from gfx::DisplayObserver
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) override {
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t metrics) override {
     changed_display_id_ = display.id();
     if (metrics & DISPLAY_METRIC_BOUNDS)
       ++bounds_changed_count_;
@@ -108,26 +104,22 @@ class TestObserver : public DisplayController::Observer,
     if (metrics & DISPLAY_METRIC_WORK_AREA)
       ++workarea_changed_count_;
   }
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
-  }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
-  }
+  void OnDisplayAdded(const gfx::Display& new_display) override {}
+  void OnDisplayRemoved(const gfx::Display& old_display) override {}
 
   // Overridden from aura::client::FocusChangeObserver
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     focus_changed_count_++;
   }
 
   // Overridden from aura::client::ActivationChangeObserver
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override {
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override {
     activation_changed_count_++;
   }
-  virtual void OnAttemptToReactivateWindow(
-      aura::Window* request_active,
-      aura::Window* actual_active) override {
-  }
+  void OnAttemptToReactivateWindow(aura::Window* request_active,
+                                   aura::Window* actual_active) override {}
 
   int CountAndReset() {
     EXPECT_EQ(changing_count_, changed_count_);
@@ -204,9 +196,9 @@ void SetDefaultDisplayLayout(DisplayLayout::Position position) {
 class DisplayControllerShutdownTest : public test::AshTestBase {
  public:
   DisplayControllerShutdownTest() {}
-  virtual ~DisplayControllerShutdownTest() {}
+  ~DisplayControllerShutdownTest() override {}
 
-  virtual void TearDown() override {
+  void TearDown() override {
     test::AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
@@ -225,15 +217,15 @@ class StartupHelper : public test::TestShellDelegate,
                       public DisplayController::Observer {
  public:
   StartupHelper() : displays_initialized_(false) {}
-  virtual ~StartupHelper() {}
+  ~StartupHelper() override {}
 
   // ash::ShellSelegate:
-  virtual void PreInit() override {
+  void PreInit() override {
     Shell::GetInstance()->display_controller()->AddObserver(this);
   }
 
   // ash::DisplayController::Observer:
-  virtual void OnDisplaysInitialized() override {
+  void OnDisplaysInitialized() override {
     DCHECK(!displays_initialized_);
     displays_initialized_ = true;
   }
@@ -251,14 +243,14 @@ class StartupHelper : public test::TestShellDelegate,
 class DisplayControllerStartupTest : public test::AshTestBase {
  public:
   DisplayControllerStartupTest() : startup_helper_(new StartupHelper) {}
-  virtual ~DisplayControllerStartupTest() {}
+  ~DisplayControllerStartupTest() override {}
 
   // ash::test::AshTestBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     ash_test_helper()->set_test_shell_delegate(startup_helper_);
     test::AshTestBase::SetUp();
   }
-  virtual void TearDown() override {
+  void TearDown() override {
     Shell::GetInstance()->display_controller()->RemoveObserver(startup_helper_);
     test::AshTestBase::TearDown();
   }
@@ -280,9 +272,9 @@ class TestEventHandler : public ui::EventHandler {
                        scroll_y_offset_(0.0),
                        scroll_x_offset_ordinal_(0.0),
                        scroll_y_offset_ordinal_(0.0) {}
-  virtual ~TestEventHandler() {}
+  ~TestEventHandler() override {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->flags() & ui::EF_IS_SYNTHESIZED &&
         event->type() != ui::ET_MOUSE_EXITED &&
         event->type() != ui::ET_MOUSE_ENTERED) {
@@ -294,7 +286,7 @@ class TestEventHandler : public ui::EventHandler {
     event->StopPropagation();
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.
@@ -305,7 +297,7 @@ class TestEventHandler : public ui::EventHandler {
     event->StopPropagation();
   }
 
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
+  void OnScrollEvent(ui::ScrollEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.

ash/display/display_manager_unittest.cc

@@ -50,14 +50,14 @@ class DisplayManagerTest : public test::AshTestBase,
       : removed_count_(0U),
         root_window_destroyed_(false) {
   }
-  virtual ~DisplayManagerTest() {}
+  ~DisplayManagerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     Shell::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
-  virtual void TearDown() override {
+  void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     Shell::GetScreen()->RemoveObserver(this);
     AshTestBase::TearDown();
@@ -102,19 +102,18 @@ class DisplayManagerTest : public test::AshTestBase,
   }
 
   // aura::DisplayObserver overrides:
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t) override {
+  void OnDisplayMetricsChanged(const gfx::Display& display, uint32_t) override {
     changed_.push_back(display);
   }
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
+  void OnDisplayAdded(const gfx::Display& new_display) override {
     added_.push_back(new_display);
   }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
+  void OnDisplayRemoved(const gfx::Display& old_display) override {
     ++removed_count_;
   }
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     ASSERT_EQ(Shell::GetPrimaryRootWindow(), window);
     root_window_destroyed_ = true;
   }
@@ -1182,17 +1181,17 @@ TEST_F(DisplayManagerTest, MAYBE_UpdateMouseCursorAfterRotateZoom) {
 class TestDisplayObserver : public gfx::DisplayObserver {
  public:
   TestDisplayObserver() : changed_(false) {}
-  virtual ~TestDisplayObserver() {}
+  ~TestDisplayObserver() override {}
 
   // gfx::DisplayObserver overrides:
-  virtual void OnDisplayMetricsChanged(const gfx::Display&,uint32_t) override {}
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
+  void OnDisplayMetricsChanged(const gfx::Display&, uint32_t) override {}
+  void OnDisplayAdded(const gfx::Display& new_display) override {
     // Mirror window should already be delete before restoring
     // the external display.
     EXPECT_FALSE(test_api.GetHost());
     changed_ = true;
   }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
+  void OnDisplayRemoved(const gfx::Display& old_display) override {
     // Mirror window should not be created until the external display
     // is removed.
     EXPECT_FALSE(test_api.GetHost());
@@ -1417,9 +1416,9 @@ class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
-  virtual ~ScreenShutdownTest() {}
+  ~ScreenShutdownTest() override {}
 
-  virtual void TearDown() override {
+  void TearDown() override {
     gfx::Screen* orig_screen =
         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
     AshTestBase::TearDown();

ash/display/event_transformation_handler.h

@@ -23,14 +23,14 @@ class ASH_EXPORT EventTransformationHandler : public ui::EventHandler {
   };
 
   EventTransformationHandler();
-  virtual ~EventTransformationHandler();
+  ~EventTransformationHandler() override;
 
   void set_transformation_mode(TransformationMode transformation_mode) {
     transformation_mode_ = transformation_mode;
   }
 
   // Overridden from ui::EventHandler.
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
 
  private:
   TransformationMode transformation_mode_;

ash/display/mirror_window_controller.cc

@@ -58,22 +58,18 @@ void DisableInput(XID window) {
 class NoneCaptureClient : public aura::client::CaptureClient {
  public:
   NoneCaptureClient() {}
-  virtual ~NoneCaptureClient() {}
+  ~NoneCaptureClient() override {}
 
  private:
   // Does a capture on the |window|.
-  virtual void SetCapture(aura::Window* window) override {}
+  void SetCapture(aura::Window* window) override {}
 
   // Releases a capture from the |window|.
-  virtual void ReleaseCapture(aura::Window* window) override {}
+  void ReleaseCapture(aura::Window* window) override {}
 
   // Returns the current capture window.
-  virtual aura::Window* GetCaptureWindow() override {
-    return NULL;
-  }
-  virtual aura::Window* GetGlobalCaptureWindow() override {
-    return NULL;
-  }
+  aura::Window* GetCaptureWindow() override { return NULL; }
+  aura::Window* GetGlobalCaptureWindow() override { return NULL; }
 
   DISALLOW_COPY_AND_ASSIGN(NoneCaptureClient);
 };

ash/display/mirror_window_controller.h

@@ -36,7 +36,7 @@ class MirrorWindowTestApi;
 class ASH_EXPORT MirrorWindowController : public aura::WindowTreeHostObserver {
  public:
   MirrorWindowController();
-  virtual ~MirrorWindowController();
+  ~MirrorWindowController() override;
 
   // Updates the root window's bounds using |display_info|.
   // Creates the new root window if one doesn't exist.
@@ -50,7 +50,7 @@ class ASH_EXPORT MirrorWindowController : public aura::WindowTreeHostObserver {
   void Close();
 
   // aura::WindowTreeHostObserver overrides:
-  virtual void OnHostResized(const aura::WindowTreeHost* host) override;
+  void OnHostResized(const aura::WindowTreeHost* host) override;
 
   // Return the root window used to mirror the content. NULL if the
   // display is not mirrored by the compositor path.

ash/display/mirror_window_controller_unittest.cc

@@ -31,18 +31,16 @@ DisplayInfo CreateDisplayInfo(int64 id, const gfx::Rect& bounds) {
 class MirrorOnBootTest : public test::AshTestBase {
  public:
   MirrorOnBootTest() {}
-  virtual ~MirrorOnBootTest() {}
+  ~MirrorOnBootTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kAshHostWindowBounds, "1+1-300x300,1+301-300x300");
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kAshEnableSoftwareMirroring);
     test::AshTestBase::SetUp();
   }
-  virtual void TearDown() override {
-    test::AshTestBase::TearDown();
-  }
+  void TearDown() override { test::AshTestBase::TearDown(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MirrorOnBootTest);

ash/display/mouse_cursor_event_filter.h

@@ -35,7 +35,7 @@ class ASH_EXPORT MouseCursorEventFilter : public ui::EventHandler,
   };
 
   MouseCursorEventFilter();
-  virtual ~MouseCursorEventFilter();
+  ~MouseCursorEventFilter() override;
 
   void set_mouse_warp_mode(MouseWarpMode mouse_warp_mode) {
     mouse_warp_mode_ = mouse_warp_mode;
@@ -47,11 +47,11 @@ class ASH_EXPORT MouseCursorEventFilter : public ui::EventHandler,
   void HideSharedEdgeIndicator();
 
   // DisplayController::Observer:
-  virtual void OnDisplaysInitialized() override;
-  virtual void OnDisplayConfigurationChanged() override;
+  void OnDisplaysInitialized() override;
+  void OnDisplayConfigurationChanged() override;
 
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
 
  private:
   friend class DragWindowResizerTest;

ash/display/mouse_cursor_event_filter_unittest.cc

@@ -19,7 +19,7 @@ namespace ash {
 class MouseCursorEventFilterTest : public test::AshTestBase {
  public:
   MouseCursorEventFilterTest() {}
-  virtual ~MouseCursorEventFilterTest() {}
+  ~MouseCursorEventFilterTest() override {}
 
  protected:
   MouseCursorEventFilter* event_filter() {

ash/display/root_window_transformers.cc

@@ -142,14 +142,11 @@ class AshRootWindowTransformer : public RootWindowTransformer {
   }
 
   // aura::RootWindowTransformer overrides:
-  virtual gfx::Transform GetTransform() const override {
-    return transform_;
-  }
-  virtual gfx::Transform GetInverseTransform() const override {
+  gfx::Transform GetTransform() const override { return transform_; }
+  gfx::Transform GetInverseTransform() const override {
     return invert_transform_;
   }
-  virtual gfx::Rect GetRootWindowBounds(
-      const gfx::Size& host_size) const override {
+  gfx::Rect GetRootWindowBounds(const gfx::Size& host_size) const override {
     gfx::Rect bounds(host_size);
     bounds.Inset(host_insets_);
     bounds = ui::ConvertRectToDIP(root_window_->layer(), bounds);
@@ -168,12 +165,10 @@ class AshRootWindowTransformer : public RootWindowTransformer {
     return gfx::Rect(gfx::ToFlooredSize(new_bounds.size()));
   }
 
-  virtual gfx::Insets GetHostInsets() const override {
-    return host_insets_;
-  }
+  gfx::Insets GetHostInsets() const override { return host_insets_; }
 
  private:
-  virtual ~AshRootWindowTransformer() {}
+  ~AshRootWindowTransformer() override {}
 
   aura::Window* root_window_;
   gfx::Transform transform_;
@@ -238,24 +233,19 @@ class MirrorRootWindowTransformer : public RootWindowTransformer {
   }
 
   // aura::RootWindowTransformer overrides:
-  virtual gfx::Transform GetTransform() const override {
-    return transform_;
-  }
-  virtual gfx::Transform GetInverseTransform() const override {
+  gfx::Transform GetTransform() const override { return transform_; }
+  gfx::Transform GetInverseTransform() const override {
     gfx::Transform invert;
     CHECK(transform_.GetInverse(&invert));
     return invert;
   }
-  virtual gfx::Rect GetRootWindowBounds(
-      const gfx::Size& host_size) const override {
+  gfx::Rect GetRootWindowBounds(const gfx::Size& host_size) const override {
     return root_bounds_;
   }
-  virtual gfx::Insets GetHostInsets() const override {
-    return insets_;
-  }
+  gfx::Insets GetHostInsets() const override { return insets_; }
 
  private:
-  virtual ~MirrorRootWindowTransformer() {}
+  ~MirrorRootWindowTransformer() override {}
 
   gfx::Transform transform_;
   gfx::Rect root_bounds_;

ash/display/root_window_transformers_unittest.cc

@@ -40,9 +40,9 @@ class TestEventHandler : public ui::EventHandler {
                        scroll_y_offset_(0.0),
                        scroll_x_offset_ordinal_(0.0),
                        scroll_y_offset_ordinal_(0.0) {}
-  virtual ~TestEventHandler() {}
+  ~TestEventHandler() override {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->flags() & ui::EF_IS_SYNTHESIZED)
       return;
     aura::Window* target = static_cast<aura::Window*>(event->target());
@@ -51,7 +51,7 @@ class TestEventHandler : public ui::EventHandler {
     event->StopPropagation();
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.
@@ -62,7 +62,7 @@ class TestEventHandler : public ui::EventHandler {
     event->StopPropagation();
   }
 
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
+  void OnScrollEvent(ui::ScrollEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.

ash/display/screen_ash.cc

@@ -71,45 +71,32 @@ class ScreenForShutdown : public gfx::Screen {
   }
 
   // gfx::Screen overrides:
-  virtual gfx::Point GetCursorScreenPoint() override {
-    return gfx::Point();
-  }
-  virtual gfx::NativeWindow GetWindowUnderCursor() override {
-    return NULL;
-  }
-  virtual gfx::NativeWindow GetWindowAtScreenPoint(
-      const gfx::Point& point) override {
+  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
+  gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
+  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
     return NULL;
   }
-  virtual int GetNumDisplays() const override {
-    return display_list_.size();
-  }
-  virtual std::vector<gfx::Display> GetAllDisplays() const override {
+  int GetNumDisplays() const override { return display_list_.size(); }
+  std::vector<gfx::Display> GetAllDisplays() const override {
     return display_list_;
   }
-  virtual gfx::Display GetDisplayNearestWindow(gfx::NativeView view)
-      const override {
+  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
     return primary_display_;
   }
-  virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const override {
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
     return FindDisplayNearestPoint(display_list_, point);
   }
-  virtual gfx::Display GetDisplayMatching(const gfx::Rect& match_rect)
-      const override {
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
     const gfx::Display* matching =
         FindDisplayMatching(display_list_, match_rect);
     // Fallback to the primary display if there is no matching display.
     return matching ? *matching : GetPrimaryDisplay();
   }
-  virtual gfx::Display GetPrimaryDisplay() const override {
-    return primary_display_;
-  }
-  virtual void AddObserver(gfx::DisplayObserver* observer) override {
+  gfx::Display GetPrimaryDisplay() const override { return primary_display_; }
+  void AddObserver(gfx::DisplayObserver* observer) override {
     NOTREACHED() << "Observer should not be added during shutdown";
   }
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) override {
-  }
+  void RemoveObserver(gfx::DisplayObserver* observer) override {}
 
  private:
   const std::vector<gfx::Display> display_list_;

ash/display/screen_ash.h

@@ -25,7 +25,7 @@ class DisplayManager;
 class ASH_EXPORT ScreenAsh : public gfx::Screen {
  public:
   ScreenAsh();
-  virtual ~ScreenAsh();
+  ~ScreenAsh() override;
 
   // Finds the display that contains |point| in screeen coordinates.
   // Returns invalid display if there is no display that can satisfy
@@ -61,21 +61,17 @@ class ASH_EXPORT ScreenAsh : public gfx::Screen {
   static const gfx::Display& GetDisplayForId(int64 display_id);
 
   // gfx::Screen overrides:
-  virtual gfx::Point GetCursorScreenPoint() override;
-  virtual gfx::NativeWindow GetWindowUnderCursor() override;
-  virtual gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point)
-      override;
-  virtual int GetNumDisplays() const override;
-  virtual std::vector<gfx::Display> GetAllDisplays() const override;
-  virtual gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const override;
-  virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const override;
-  virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const override;
-  virtual gfx::Display GetPrimaryDisplay() const override;
-  virtual void AddObserver(gfx::DisplayObserver* observer) override;
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) override;
+  gfx::Point GetCursorScreenPoint() override;
+  gfx::NativeWindow GetWindowUnderCursor() override;
+  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override;
+  int GetNumDisplays() const override;
+  std::vector<gfx::Display> GetAllDisplays() const override;
+  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override;
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override;
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override;
+  gfx::Display GetPrimaryDisplay() const override;
+  void AddObserver(gfx::DisplayObserver* observer) override;
+  void RemoveObserver(gfx::DisplayObserver* observer) override;
 
  private:
   friend class DisplayManager;

ash/display/screen_position_controller.h

@@ -13,18 +13,18 @@ namespace ash {
 class ScreenPositionController : public aura::client::ScreenPositionClient {
  public:
   ScreenPositionController() {}
-  virtual ~ScreenPositionController() {}
+  ~ScreenPositionController() override {}
 
   // aura::client::ScreenPositionClient overrides:
-  virtual void ConvertPointToScreen(const aura::Window* window,
-                                    gfx::Point* point) override;
-  virtual void ConvertPointFromScreen(const aura::Window* window,
-                                      gfx::Point* point) override;
-  virtual void ConvertHostPointToScreen(aura::Window* window,
-                                        gfx::Point* point) override;
-  virtual void SetBounds(aura::Window* window,
-                         const gfx::Rect& bounds,
-                         const gfx::Display& display) override;
+  void ConvertPointToScreen(const aura::Window* window,
+                            gfx::Point* point) override;
+  void ConvertPointFromScreen(const aura::Window* window,
+                              gfx::Point* point) override;
+  void ConvertHostPointToScreen(aura::Window* window,
+                                gfx::Point* point) override;
+  void SetBounds(aura::Window* window,
+                 const gfx::Rect& bounds,
+                 const gfx::Display& display) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenPositionController);

ash/display/screen_position_controller_unittest.cc

@@ -49,9 +49,9 @@ ScreenPositionController* GetScreenPositionController() {
 class ScreenPositionControllerTest : public test::AshTestBase {
  public:
   ScreenPositionControllerTest() {}
-  virtual ~ScreenPositionControllerTest() {}
+  ~ScreenPositionControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     window_.reset(new aura::Window(&window_delegate_));
     window_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
@@ -60,7 +60,7 @@ class ScreenPositionControllerTest : public test::AshTestBase {
     window_->set_id(1);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     window_.reset();
     AshTestBase::TearDown();
   }

ash/display/shared_display_edge_indicator.cc

@@ -26,8 +26,7 @@ class IndicatorView : public views::View {
  public:
   IndicatorView() {
   }
-  virtual ~IndicatorView() {
-  }
+  ~IndicatorView() override {}
 
   void SetColor(SkColor color) {
     color_ = color;
@@ -35,7 +34,7 @@ class IndicatorView : public views::View {
   }
 
   // views::Views overrides:
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     canvas->FillRect(gfx::Rect(bounds().size()), color_);
   }
 

ash/display/shared_display_edge_indicator.h

@@ -28,7 +28,7 @@ namespace ash {
 class ASH_EXPORT SharedDisplayEdgeIndicator : public gfx::AnimationDelegate {
  public:
   SharedDisplayEdgeIndicator();
-  virtual ~SharedDisplayEdgeIndicator();
+  ~SharedDisplayEdgeIndicator() override;
 
   // Shows/Hides the indicator window. The |src_bounds| is for the window on
   // the source display, and the |dst_bounds| is for the window on the other
@@ -37,7 +37,7 @@ class ASH_EXPORT SharedDisplayEdgeIndicator : public gfx::AnimationDelegate {
   void Hide();
 
   // gfx::AnimationDelegate overrides:
-  virtual void AnimationProgressed(const gfx::Animation* animation) override;
+  void AnimationProgressed(const gfx::Animation* animation) override;
 
  private:
   // Used to show the displays' shared edge where a window can be moved across.