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/676403006

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

ash/wm/overview/scoped_transform_overview_window.cc

@@ -36,8 +36,7 @@ class WindowSelectorAnimationSettings
     SetTweenType(gfx::Tween::FAST_OUT_SLOW_IN);
   }
 
-  virtual ~WindowSelectorAnimationSettings() {
-  }
+  ~WindowSelectorAnimationSettings() override {}
 };
 
 void SetTransformOnWindow(aura::Window* window,

ash/wm/overview/scoped_window_copy.cc

@@ -90,15 +90,12 @@ class CleanupWidgetAfterAnimationObserver : public ui::LayerAnimationObserver {
   void TakeOwnershipOfWidget();
 
   // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) override;
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) override;
-  virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) override;
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override;
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override;
+  void OnLayerAnimationScheduled(ui::LayerAnimationSequence* sequence) override;
 
  private:
-  virtual ~CleanupWidgetAfterAnimationObserver();
+  ~CleanupWidgetAfterAnimationObserver() override;
 
   // If the necessary conditions have been satisfied to destruct this
   // class, deletes itself and cleans up the widget and layer.

ash/wm/overview/transparent_activate_window_button.cc

@@ -22,7 +22,7 @@ class TransparentButton : public views::CustomButton {
   explicit TransparentButton(views::ButtonListener* listener)
       : CustomButton(listener) {
   }
-  virtual ~TransparentButton() {}
+  ~TransparentButton() override {}
 
   // views::CustomButton:
   void OnGestureEvent(ui::GestureEvent* event) override {
@@ -42,9 +42,7 @@ class TransparentButton : public views::CustomButton {
     event->StopPropagation();
   }
 
-  virtual const char* GetClassName() const override {
-    return kTransparentButtonName;
-  }
+  const char* GetClassName() const override { return kTransparentButtonName; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransparentButton);

ash/wm/overview/transparent_activate_window_button.h

@@ -15,7 +15,7 @@ namespace ash {
 class TransparentActivateWindowButton : public views::ButtonListener {
  public:
   explicit TransparentActivateWindowButton(aura::Window* activate_window);
-  virtual ~TransparentActivateWindowButton();
+  ~TransparentActivateWindowButton() override;
 
   // Sets the bounds of the transparent window.
   void SetBounds(const gfx::Rect& bounds);
@@ -25,8 +25,7 @@ class TransparentActivateWindowButton : public views::ButtonListener {
   void SendFocusAlert() const;
 
   // views::ButtonListener:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override;
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
  private:
   // The transparent window event handler widget itself.

ash/wm/overview/window_grid.cc

@@ -38,10 +38,10 @@ class CleanupWidgetAfterAnimationObserver
  public:
   explicit CleanupWidgetAfterAnimationObserver(
       scoped_ptr<views::Widget> widget);
-  virtual ~CleanupWidgetAfterAnimationObserver();
+  ~CleanupWidgetAfterAnimationObserver() override;
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() override;
+  void OnImplicitAnimationsCompleted() override;
 
  private:
   scoped_ptr<views::Widget> widget_;

ash/wm/overview/window_grid.h

@@ -49,7 +49,7 @@ class ASH_EXPORT WindowGrid : public aura::WindowObserver {
   WindowGrid(aura::Window* root_window,
              const std::vector<aura::Window*>& window_list,
              WindowSelector* window_selector);
-  virtual ~WindowGrid();
+  ~WindowGrid() override;
 
   // Prepares the windows in this grid for overview. This will restore all
   // minimized windows and ensure they are visible.
@@ -93,11 +93,11 @@ class ASH_EXPORT WindowGrid : public aura::WindowObserver {
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowDestroying(aura::Window* window) override;
   // TODO(flackr): Handle window bounds changed in WindowSelectorItem.
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
 
  private:
   friend class WindowSelectorTest;

ash/wm/overview/window_selector.cc

@@ -119,9 +119,9 @@ class RoundedContainerView : public views::View {
         background_(background) {
   }
 
-  virtual ~RoundedContainerView() {}
+  ~RoundedContainerView() override {}
 
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     views::View::OnPaint(canvas);
 
     SkScalar radius = SkIntToScalar(corner_radius_);

ash/wm/overview/window_selector.h

@@ -68,7 +68,7 @@ class ASH_EXPORT WindowSelector
 
   WindowSelector(const WindowList& windows,
                  WindowSelectorDelegate* delegate);
-  virtual ~WindowSelector();
+  ~WindowSelector() override;
 
   // Cancels window selection.
   void CancelSelection();
@@ -77,27 +77,26 @@ class ASH_EXPORT WindowSelector
   void OnGridEmpty(WindowGrid* grid);
 
   // gfx::DisplayObserver:
-  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::WindowObserver:
-  virtual void OnWindowAdded(aura::Window* new_window) override;
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowAdded(aura::Window* new_window) override;
+  void OnWindowDestroying(aura::Window* window) override;
 
   // aura::client::ActivationChangeObserver:
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override;
-  virtual void OnAttemptToReactivateWindow(
-      aura::Window* request_active,
-      aura::Window* actual_active) override;
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override;
+  void OnAttemptToReactivateWindow(aura::Window* request_active,
+                                   aura::Window* actual_active) override;
 
   // views::TextfieldController:
-  virtual void ContentsChanged(views::Textfield* sender,
-                               const base::string16& new_contents) override;
-  virtual bool HandleKeyEvent(views::Textfield* sender,
-                              const ui::KeyEvent& key_event) override;
+  void ContentsChanged(views::Textfield* sender,
+                       const base::string16& new_contents) override;
+  bool HandleKeyEvent(views::Textfield* sender,
+                      const ui::KeyEvent& key_event) override;
 
  private:
   friend class WindowSelectorTest;

ash/wm/overview/window_selector_controller.h

@@ -30,7 +30,7 @@ class ASH_EXPORT WindowSelectorController
     : public WindowSelectorDelegate {
  public:
   WindowSelectorController();
-  virtual ~WindowSelectorController();
+  ~WindowSelectorController() override;
 
   // Returns true if selecting windows in an overview is enabled. This is false
   // at certain times, such as when the lock screen is visible.
@@ -45,7 +45,7 @@ class ASH_EXPORT WindowSelectorController
   bool IsSelecting();
 
   // WindowSelectorDelegate:
-  virtual void OnSelectionEnded() override;
+  void OnSelectionEnded() override;
 
  private:
   friend class WindowSelectorTest;

ash/wm/overview/window_selector_item.h

@@ -30,7 +30,7 @@ class WindowSelectorItem : public views::ButtonListener,
                            public aura::WindowObserver {
  public:
   WindowSelectorItem();
-  virtual ~WindowSelectorItem();
+  ~WindowSelectorItem() override;
 
   // The time for the close buttons and labels to fade in when initially shown
   // on entering overview mode.
@@ -88,11 +88,10 @@ class WindowSelectorItem : public views::ButtonListener,
   const gfx::Rect& target_bounds() const { return target_bounds_; }
 
   // views::ButtonListener:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override;
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
   // aura::WindowObserver:
-  virtual void OnWindowTitleChanged(aura::Window* window) override;
+  void OnWindowTitleChanged(aura::Window* window) override;
 
  protected:
   // Sets the bounds of this selector's items to |target_bounds| in

ash/wm/overview/window_selector_panels.cc

@@ -27,15 +27,14 @@ namespace {
 class ScopedTransformPanelWindow : public ScopedTransformOverviewWindow {
  public:
   explicit ScopedTransformPanelWindow(aura::Window* window);
-  virtual ~ScopedTransformPanelWindow();
+  ~ScopedTransformPanelWindow() override;
 
   // ScopedTransformOverviewWindow overrides:
-  virtual void PrepareForOverview() override;
+  void PrepareForOverview() override;
 
-  virtual void SetTransform(
-      aura::Window* root_window,
-      const gfx::Transform& transform,
-      bool animate) override;
+  void SetTransform(aura::Window* root_window,
+                    const gfx::Transform& transform,
+                    bool animate) override;
 
  private:
   // Returns the panel window bounds after the transformation.

ash/wm/overview/window_selector_panels.h

@@ -21,25 +21,25 @@ class ScopedTransformOverviewWindow;
 class WindowSelectorPanels : public WindowSelectorItem {
  public:
   explicit WindowSelectorPanels(aura::Window* panels_root_window);
-  virtual ~WindowSelectorPanels();
+  ~WindowSelectorPanels() override;
 
   // Adds |window| to the selector item. This window should be an attached
   // panel window.
   void AddWindow(aura::Window* window);
 
   // WindowSelectorItem:
-  virtual aura::Window* GetRootWindow() override;
-  virtual bool HasSelectableWindow(const aura::Window* window) override;
-  virtual bool Contains(const aura::Window* target) override;
-  virtual void RestoreWindowOnExit(aura::Window* window) override;
-  virtual aura::Window* SelectionWindow() override;
-  virtual void RemoveWindow(const aura::Window* window) override;
-  virtual bool empty() const override;
-  virtual void PrepareForOverview() override;
-  virtual void SetItemBounds(aura::Window* root_window,
-                             const gfx::Rect& target_bounds,
-                             bool animate) override;
-  virtual void SetOpacity(float opacity) override;
+  aura::Window* GetRootWindow() override;
+  bool HasSelectableWindow(const aura::Window* window) override;
+  bool Contains(const aura::Window* target) override;
+  void RestoreWindowOnExit(aura::Window* window) override;
+  aura::Window* SelectionWindow() override;
+  void RemoveWindow(const aura::Window* window) override;
+  bool empty() const override;
+  void PrepareForOverview() override;
+  void SetItemBounds(aura::Window* root_window,
+                     const gfx::Rect& target_bounds,
+                     bool animate) override;
+  void SetOpacity(float opacity) override;
 
  private:
   typedef ScopedVector<ScopedTransformOverviewWindow> WindowList;

ash/wm/overview/window_selector_unittest.cc

@@ -56,9 +56,7 @@ namespace {
 class NonActivatableActivationDelegate
     : public aura::client::ActivationDelegate {
  public:
-  virtual bool ShouldActivate() const override {
-    return false;
-  }
+  bool ShouldActivate() const override { return false; }
 };
 
 void CancelDrag(DragDropController* controller, bool* canceled) {
@@ -73,9 +71,9 @@ void CancelDrag(DragDropController* controller, bool* canceled) {
 class WindowSelectorTest : public test::AshTestBase {
  public:
   WindowSelectorTest() {}
-  virtual ~WindowSelectorTest() {}
+  ~WindowSelectorTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 

ash/wm/overview/window_selector_window.h

@@ -25,21 +25,21 @@ namespace ash {
 class WindowSelectorWindow : public WindowSelectorItem {
  public:
   explicit WindowSelectorWindow(aura::Window* window);
-  virtual ~WindowSelectorWindow();
+  ~WindowSelectorWindow() override;
 
   // WindowSelectorItem:
-  virtual aura::Window* GetRootWindow() override;
-  virtual bool HasSelectableWindow(const aura::Window* window) override;
-  virtual bool Contains(const aura::Window* target) override;
-  virtual void RestoreWindowOnExit(aura::Window* window) override;
-  virtual aura::Window* SelectionWindow() override;
-  virtual void RemoveWindow(const aura::Window* window) override;
-  virtual bool empty() const override;
-  virtual void PrepareForOverview() override;
-  virtual void SetItemBounds(aura::Window* root_window,
-                             const gfx::Rect& target_bounds,
-                             bool animate) override;
-  virtual void SetOpacity(float opacity) override;
+  aura::Window* GetRootWindow() override;
+  bool HasSelectableWindow(const aura::Window* window) override;
+  bool Contains(const aura::Window* target) override;
+  void RestoreWindowOnExit(aura::Window* window) override;
+  aura::Window* SelectionWindow() override;
+  void RemoveWindow(const aura::Window* window) override;
+  bool empty() const override;
+  void PrepareForOverview() override;
+  void SetItemBounds(aura::Window* root_window,
+                     const gfx::Rect& target_bounds,
+                     bool animate) override;
+  void SetOpacity(float opacity) override;
 
  private:
   // The window with a scoped transform represented by this selector item.