Standardize usage of virtual/override/final specifiers.

ash/shelf/shelf_widget.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 "ash/shelf/shelf_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
@@ skipping 40 matching lines @@
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
                    public views::WidgetDelegate,
                    ash::BackgroundAnimatorDelegate {
  public:
   // If |disable_dimming_animations_for_test| is set, all alpha animations will
   // be performed instantly.
   DimmerView(ash::ShelfWidget* shelf_widget,
              bool disable_dimming_animations_for_test);
-  virtual ~DimmerView();
+  ~DimmerView() override;
 
   // Called by |DimmerEventFilter| when the mouse |hovered| state changes.
   void SetHovered(bool hovered);
 
   // Force the dimmer to be undimmed.
   void ForceUndimming(bool force);
 
   // views::WidgetDelegate overrides:
-  virtual views::Widget* GetWidget() override {
-    return View::GetWidget();
-  }
-  virtual const views::Widget* GetWidget() const override {
-    return View::GetWidget();
-  }
+  views::Widget* GetWidget() override { return View::GetWidget(); }
+  const views::Widget* GetWidget() const override { return View::GetWidget(); }
 
   // ash::BackgroundAnimatorDelegate overrides:
-  virtual void UpdateBackground(int alpha) override {
+  void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaint();
   }
 
   // views::View overrides:
-  virtual void OnPaintBackground(gfx::Canvas* canvas) override;
+  void OnPaintBackground(gfx::Canvas* canvas) override;
 
   // A function to test the current alpha used.
   int get_dimming_alpha_for_test() { return alpha_; }
 
  private:
   // This class monitors mouse events to see if it is on top of the shelf.
   class DimmerEventFilter : public ui::EventHandler {
    public:
     explicit DimmerEventFilter(DimmerView* owner);
-    virtual ~DimmerEventFilter();
+    ~DimmerEventFilter() override;
 
     // Overridden from ui::EventHandler:
-    virtual void OnMouseEvent(ui::MouseEvent* event) override;
-    virtual void OnTouchEvent(ui::TouchEvent* event) override;
+    void OnMouseEvent(ui::MouseEvent* event) override;
+    void OnTouchEvent(ui::TouchEvent* event) override;
 
    private:
     // The owning class.
     DimmerView* owner_;
 
     // TRUE if the mouse is inside the shelf.
     bool mouse_inside_;
 
     // TRUE if a touch event is inside the shelf.
     bool touch_inside_;
@@ skipping 134 matching lines @@
                             public ash::ShelfLayoutManagerObserver {
  public:
   ShelfWindowTargeter(aura::Window* container,
                       ShelfLayoutManager* shelf)
       : wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
         shelf_(shelf) {
     WillChangeVisibilityState(shelf_->visibility_state());
     shelf_->AddObserver(this);
   }
 
-  virtual ~ShelfWindowTargeter() {
+  ~ShelfWindowTargeter() override {
     // |shelf_| may have been destroyed by this time.
     if (shelf_)
       shelf_->RemoveObserver(this);
   }
 
  private:
   gfx::Insets GetInsetsForAlignment(int distance,
                                     ash::ShelfAlignment alignment) {
     switch (alignment) {
       case ash::SHELF_ALIGNMENT_BOTTOM:
         return gfx::Insets(distance, 0, 0, 0);
       case ash::SHELF_ALIGNMENT_LEFT:
         return gfx::Insets(0, 0, 0, distance);
       case ash::SHELF_ALIGNMENT_RIGHT:
         return gfx::Insets(0, distance, 0, 0);
       case ash::SHELF_ALIGNMENT_TOP:
         return gfx::Insets(0, 0, distance, 0);
     }
     NOTREACHED();
     return gfx::Insets();
   }
 
   // ash::ShelfLayoutManagerObserver:
-  virtual void WillDeleteShelf() override {
-    shelf_ = NULL;
-  }
+  void WillDeleteShelf() override { shelf_ = NULL; }
 
-  virtual void WillChangeVisibilityState(
-      ash::ShelfVisibilityState new_state) override {
+  void WillChangeVisibilityState(ash::ShelfVisibilityState new_state) override {
     gfx::Insets mouse_insets;
     gfx::Insets touch_insets;
     if (new_state == ash::SHELF_VISIBLE) {
       // Let clicks at the very top of the shelf through so windows can be
       // resized with the bottom-right corner and bottom edge.
       mouse_insets = GetInsetsForAlignment(
           ShelfLayoutManager::kWorkspaceAreaVisibleInset,
           shelf_->GetAlignment());
     } else if (new_state == ash::SHELF_AUTO_HIDE) {
       // Extend the touch hit target out a bit to allow users to drag shelf out
@@ skipping 17 matching lines @@
 namespace ash {
 
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
                                   public BackgroundAnimatorDelegate,
                                   public aura::WindowObserver {
  public:
   explicit DelegateView(ShelfWidget* shelf);
-  virtual ~DelegateView();
+  ~DelegateView() override;
 
   void set_focus_cycler(FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
   FocusCycler* focus_cycler() { return focus_cycler_; }
 
   ui::Layer* opaque_background() { return &opaque_background_; }
   ui::Layer* opaque_foreground() { return &opaque_foreground_; }
 
   // Set if the shelf area is dimmed (eg when a window is maximized).
   void SetDimmed(bool dimmed);
   bool GetDimmed() const;
 
   void SetParentLayer(ui::Layer* layer);
 
   // views::View overrides:
-  virtual void OnPaintBackground(gfx::Canvas* canvas) override;
+  void OnPaintBackground(gfx::Canvas* canvas) override;
 
   // views::WidgetDelegateView overrides:
-  virtual views::Widget* GetWidget() override {
-    return View::GetWidget();
-  }
-  virtual const views::Widget* GetWidget() const override {
-    return View::GetWidget();
-  }
+  views::Widget* GetWidget() override { return View::GetWidget(); }
+  const views::Widget* GetWidget() const override { return View::GetWidget(); }
 
-  virtual bool CanActivate() const override;
-  virtual void Layout() override;
-  virtual void ReorderChildLayers(ui::Layer* parent_layer) override;
+  bool CanActivate() const override;
+  void Layout() override;
+  void ReorderChildLayers(ui::Layer* parent_layer) override;
   // This will be called when the parent local bounds change.
-  virtual void OnBoundsChanged(const gfx::Rect& old_bounds) override;
+  void OnBoundsChanged(const gfx::Rect& old_bounds) override;
 
   // aura::WindowObserver overrides:
   // This will be called when the shelf itself changes its absolute position.
   // Since the |dimmer_| panel needs to be placed in screen coordinates it needs
   // to be repositioned. The difference to the OnBoundsChanged call above is
   // that this gets also triggered when the shelf only moves.
-  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;
 
   // BackgroundAnimatorDelegate overrides:
-  virtual void UpdateBackground(int alpha) override;
+  void UpdateBackground(int alpha) override;
 
   // Force the shelf to be presented in an undimmed state.
   void ForceUndimming(bool force);
 
   // A function to test the current alpha used by the dimming bar. If there is
   // no dimmer active, the function will return -1.
   int GetDimmingAlphaForTest();
 
   // A function to test the bounds of the dimming bar. Returns gfx::Rect() if
   // the dimmer is inactive.
@@ skipping 465 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash