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=varkha@chromium.org

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

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

ash/wm/workspace/multi_window_resize_controller.cc

@@ -71,32 +71,29 @@ class MultiWindowResizeController::ResizeView : public views::View {
   }
 
   // views::View overrides:
-  virtual gfx::Size GetPreferredSize() const override {
+  gfx::Size GetPreferredSize() const override {
     return gfx::Size(image_->width(), image_->height());
   }
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     canvas->DrawImageInt(*image_, 0, 0);
   }
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+  bool OnMousePressed(const ui::MouseEvent& event) override {
     gfx::Point location(event.location());
     views::View::ConvertPointToScreen(this, &location);
     controller_->StartResize(location);
     return true;
   }
-  virtual bool OnMouseDragged(const ui::MouseEvent& event) override {
+  bool OnMouseDragged(const ui::MouseEvent& event) override {
     gfx::Point location(event.location());
     views::View::ConvertPointToScreen(this, &location);
     controller_->Resize(location, event.flags());
     return true;
   }
-  virtual void OnMouseReleased(const ui::MouseEvent& event) override {
+  void OnMouseReleased(const ui::MouseEvent& event) override {
     controller_->CompleteResize();
   }
-  virtual void OnMouseCaptureLost() override {
-    controller_->CancelResize();
-  }
-  virtual gfx::NativeCursor GetCursor(
-      const ui::MouseEvent& event) override {
+  void OnMouseCaptureLost() override { controller_->CancelResize(); }
+  gfx::NativeCursor GetCursor(const ui::MouseEvent& event) override {
     int component = (direction_ == LEFT_RIGHT) ? HTRIGHT : HTBOTTOM;
     return ::wm::CompoundEventFilter::CursorForWindowComponent(
         component);
@@ -118,8 +115,8 @@ class MultiWindowResizeController::ResizeMouseWatcherHost :
   ResizeMouseWatcherHost(MultiWindowResizeController* host) : host_(host) {}
 
   // MouseWatcherHost overrides:
-  virtual bool Contains(const gfx::Point& point_in_screen,
-                        MouseEventType type) override {
+  bool Contains(const gfx::Point& point_in_screen,
+                MouseEventType type) override {
     return host_->IsOverWindows(point_in_screen);
   }
 

ash/wm/workspace/multi_window_resize_controller.h

@@ -40,7 +40,7 @@ class ASH_EXPORT MultiWindowResizeController :
     public views::MouseWatcherListener, public aura::WindowObserver {
  public:
   MultiWindowResizeController();
-  virtual ~MultiWindowResizeController();
+  ~MultiWindowResizeController() override;
 
   // If necessary, shows the resize widget. |window| is the window the mouse
   // is over, |component| the edge and |point| the location of the mouse.
@@ -50,10 +50,10 @@ class ASH_EXPORT MultiWindowResizeController :
   void Hide();
 
   // MouseWatcherListenre overrides:
-  virtual void MouseMovedOutOfHost() override;
+  void MouseMovedOutOfHost() override;
 
   // WindowObserver overrides:
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowDestroying(aura::Window* window) override;
 
  private:
   friend class MultiWindowResizeControllerTest;

ash/wm/workspace/multi_window_resize_controller_unittest.cc

@@ -23,9 +23,9 @@ namespace ash {
 class MultiWindowResizeControllerTest : public test::AshTestBase {
  public:
   MultiWindowResizeControllerTest() : resize_controller_(NULL) {}
-  virtual ~MultiWindowResizeControllerTest() {}
+  ~MultiWindowResizeControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     WorkspaceController* wc =
         test::ShellTestApi(Shell::GetInstance()).workspace_controller();

ash/wm/workspace/workspace_event_handler.h

@@ -18,11 +18,11 @@ class WindowState;
 class WorkspaceEventHandler : public ui::EventHandler {
  public:
   WorkspaceEventHandler();
-  virtual ~WorkspaceEventHandler();
+  ~WorkspaceEventHandler() override;
 
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override;
-  virtual void OnGestureEvent(ui::GestureEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
 
  private:
   friend class WorkspaceEventHandlerTestHelper;

ash/wm/workspace/workspace_event_handler_unittest.cc

@@ -32,7 +32,7 @@ namespace ash {
 class WorkspaceEventHandlerTest : public test::AshTestBase {
  public:
   WorkspaceEventHandlerTest() {}
-  virtual ~WorkspaceEventHandlerTest() {}
+  ~WorkspaceEventHandlerTest() override {}
 
  protected:
   aura::Window* CreateTestWindow(aura::WindowDelegate* delegate,
@@ -58,9 +58,7 @@ class WindowPropertyObserver : public aura::WindowObserver {
     window->AddObserver(this);
   }
 
-  virtual ~WindowPropertyObserver() {
-    window_->RemoveObserver(this);
-  }
+  ~WindowPropertyObserver() override { window_->RemoveObserver(this); }
 
   bool DidPropertyChange(const void* property) const {
     return std::find(properties_changed_.begin(),
@@ -69,9 +67,9 @@ class WindowPropertyObserver : public aura::WindowObserver {
   }
 
  private:
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) override {
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override {
     properties_changed_.push_back(key);
   }
 

ash/wm/workspace/workspace_layout_manager.h

@@ -48,7 +48,7 @@ class ASH_EXPORT WorkspaceLayoutManager
       public wm::WindowStateObserver {
  public:
   explicit WorkspaceLayoutManager(aura::Window* window);
-  virtual ~WorkspaceLayoutManager();
+  ~WorkspaceLayoutManager() override;
 
   void SetShelf(ShelfLayoutManager* shelf);
 
@@ -59,41 +59,40 @@ class ASH_EXPORT WorkspaceLayoutManager
       scoped_ptr<WorkspaceLayoutManagerDelegate> delegate);
 
   // Overridden from aura::LayoutManager:
-  virtual void OnWindowResized() override {}
-  virtual void OnWindowAddedToLayout(aura::Window* child) override;
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override;
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override;
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visibile) override;
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) override;
+  void OnWindowResized() override {}
+  void OnWindowAddedToLayout(aura::Window* child) override;
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override;
+  void OnWindowRemovedFromLayout(aura::Window* child) override;
+  void OnChildWindowVisibilityChanged(aura::Window* child,
+                                      bool visibile) override;
+  void SetChildBounds(aura::Window* child,
+                      const gfx::Rect& requested_bounds) override;
 
   // ash::ShellObserver overrides:
-  virtual void OnDisplayWorkAreaInsetsChanged() override;
+  void OnDisplayWorkAreaInsetsChanged() override;
 
   // Overriden from WindowObserver:
-  virtual void OnWindowHierarchyChanged(
+  void OnWindowHierarchyChanged(
       const WindowObserver::HierarchyChangeParams& params) override;
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) override;
-  virtual void OnWindowStackingChanged(aura::Window* window) override;
-  virtual void OnWindowDestroying(aura::Window* window) override;
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override;
+  void OnWindowStackingChanged(aura::Window* window) override;
+  void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
 
   // aura::client::ActivationChangeObserver overrides:
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override;
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override;
 
   // keyboard::KeyboardControllerObserver overrides:
-  virtual void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override;
+  void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override;
 
   // WindowStateObserver overrides:
-  virtual void OnPostWindowStateTypeChange(
-      wm::WindowState* window_state,
-      wm::WindowStateType old_type) override;
+  void OnPostWindowStateTypeChange(wm::WindowState* window_state,
+                                   wm::WindowStateType old_type) override;
 
  private:
   typedef std::set<aura::Window*> WindowSet;

ash/wm/workspace/workspace_layout_manager_unittest.cc

@@ -46,12 +46,11 @@ class MaximizeDelegateView : public views::WidgetDelegateView {
   explicit MaximizeDelegateView(const gfx::Rect& initial_bounds)
       : initial_bounds_(initial_bounds) {
   }
-  virtual ~MaximizeDelegateView() {}
+  ~MaximizeDelegateView() override {}
 
-  virtual bool GetSavedWindowPlacement(
-      const views::Widget* widget,
-      gfx::Rect* bounds,
-      ui::WindowShowState* show_state) const override {
+  bool GetSavedWindowPlacement(const views::Widget* widget,
+                               gfx::Rect* bounds,
+                               ui::WindowShowState* show_state) const override {
     *bounds = initial_bounds_;
     *show_state = ui::SHOW_STATE_MAXIMIZED;
     return true;
@@ -70,12 +69,12 @@ class TestShellObserver : public ShellObserver {
     Shell::GetInstance()->AddShellObserver(this);
   }
 
-  virtual ~TestShellObserver() {
+  ~TestShellObserver() override {
     Shell::GetInstance()->RemoveShellObserver(this);
   }
 
-  virtual void OnFullscreenStateChanged(bool is_fullscreen,
-                                        aura::Window* root_window) override {
+  void OnFullscreenStateChanged(bool is_fullscreen,
+                                aura::Window* root_window) override {
     call_count_++;
     is_fullscreen_ = is_fullscreen;
   }
@@ -313,9 +312,9 @@ class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
 
   void set_window(aura::Window* window) { window_ = window; }
 
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) override {
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override {
     if (!window_)
       return;
 
@@ -529,7 +528,7 @@ namespace {
 class WorkspaceLayoutManagerSoloTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerSoloTest() {}
-  virtual ~WorkspaceLayoutManagerSoloTest() {}
+  ~WorkspaceLayoutManagerSoloTest() override {}
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
@@ -574,12 +573,12 @@ class FocusDelegate : public aura::test::TestWindowDelegate {
       : window_(NULL),
         show_state_(ui::SHOW_STATE_END) {
   }
-  virtual ~FocusDelegate() {}
+  ~FocusDelegate() override {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
   // aura::test::TestWindowDelegate overrides:
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
+  void OnWindowTargetVisibilityChanged(bool visible) override {
     if (window_) {
       if (visible)
         window_->Focus();
@@ -788,9 +787,9 @@ namespace {
 class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerBackdropTest() {}
-  virtual ~WorkspaceLayoutManagerBackdropTest() {}
+  ~WorkspaceLayoutManagerBackdropTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     default_container_ = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
@@ -976,9 +975,9 @@ TEST_F(WorkspaceLayoutManagerBackdropTest, ShelfVisibilityChangesBounds) {
 class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerKeyboardTest() {}
-  virtual ~WorkspaceLayoutManagerKeyboardTest() {}
+  ~WorkspaceLayoutManagerKeyboardTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     aura::Window* default_container = Shell::GetContainer(
@@ -1048,11 +1047,9 @@ class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase {
 class FakeTextInputClient : public ui::DummyTextInputClient {
  public:
   explicit FakeTextInputClient(gfx::NativeWindow window) : window_(window) {}
-  virtual ~FakeTextInputClient() {}
+  ~FakeTextInputClient() override {}
 
-  virtual gfx::NativeWindow GetAttachedWindow() const override {
-    return window_;
-  }
+  gfx::NativeWindow GetAttachedWindow() const override { return window_; }
 
  private:
   gfx::NativeWindow window_;

ash/wm/workspace/workspace_window_resizer.h

@@ -49,17 +49,16 @@ class ASH_EXPORT WorkspaceWindowResizer : public WindowResizer {
   // to move or resize beyond that edge.
   static const int kStickyDistancePixels;
 
-  virtual ~WorkspaceWindowResizer();
+  ~WorkspaceWindowResizer() override;
 
   static WorkspaceWindowResizer* Create(
       wm::WindowState* window_state,
       const std::vector<aura::Window*>& attached_windows);
 
   // WindowResizer:
-  virtual void Drag(const gfx::Point& location_in_parent,
-                    int event_flags) override;
-  virtual void CompleteDrag() override;
-  virtual void RevertDrag() override;
+  void Drag(const gfx::Point& location_in_parent, int event_flags) override;
+  void CompleteDrag() override;
+  void RevertDrag() override;
 
  private:
   WorkspaceWindowResizer(wm::WindowState* window_state,