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

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

67 files changed, 402 insertions, 477 deletions

diff --git a/ash/accelerators/accelerator_controller.h b/ash/accelerators/accelerator_controller.h
index b0baa9c..9a7c579 100644
--- a/ash/accelerators/accelerator_controller.h
+++ b/ash/accelerators/accelerator_controller.h
@@ -36,7 +36,7 @@ class VolumeControlDelegate;
 class ASH_EXPORT AcceleratorController : public ui::AcceleratorTarget {
  public:
   AcceleratorController();
-  virtual ~AcceleratorController();
+  ~AcceleratorController() override;
 
   // A list of possible ways in which an accelerator should be restricted before
   // processing. Any target registered with this controller should respect
@@ -96,8 +96,8 @@ class ASH_EXPORT AcceleratorController : public ui::AcceleratorTarget {
   AcceleratorProcessingRestriction GetCurrentAcceleratorRestriction();
 
   // Overridden from ui::AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
-  virtual bool CanHandleAccelerators() const override;
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
+  bool CanHandleAccelerators() const override;
 
   void SetBrightnessControlDelegate(
       scoped_ptr<BrightnessControlDelegate> brightness_control_delegate);
diff --git a/ash/accelerators/accelerator_controller_unittest.cc b/ash/accelerators/accelerator_controller_unittest.cc
index 338c15f..e6b0227 100644
--- a/ash/accelerators/accelerator_controller_unittest.cc
+++ b/ash/accelerators/accelerator_controller_unittest.cc
@@ -51,7 +51,7 @@ namespace {
 class TestTarget : public ui::AcceleratorTarget {
  public:
   TestTarget() : accelerator_pressed_count_(0), accelerator_repeat_count_(0) {}
-  virtual ~TestTarget() {}
+  ~TestTarget() override {}
 
   int accelerator_pressed_count() const {
     return accelerator_pressed_count_;
@@ -65,8 +65,8 @@ class TestTarget : public ui::AcceleratorTarget {
   }
 
   // Overridden from ui::AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
-  virtual bool CanHandleAccelerators() const override;
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
+  bool CanHandleAccelerators() const override;
 
  private:
   int accelerator_pressed_count_;
@@ -90,21 +90,20 @@ class DummyBrightnessControlDelegate : public BrightnessControlDelegate {
         handle_brightness_down_count_(0),
         handle_brightness_up_count_(0) {
   }
-  virtual ~DummyBrightnessControlDelegate() {}
+  ~DummyBrightnessControlDelegate() override {}
 
-  virtual bool HandleBrightnessDown(
-      const ui::Accelerator& accelerator) override {
+  bool HandleBrightnessDown(const ui::Accelerator& accelerator) override {
     ++handle_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleBrightnessUp(const ui::Accelerator& accelerator) override {
+  bool HandleBrightnessUp(const ui::Accelerator& accelerator) override {
     ++handle_brightness_up_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual void SetBrightnessPercent(double percent, bool gradual) override {}
-  virtual void GetBrightnessPercent(
+  void SetBrightnessPercent(double percent, bool gradual) override {}
+  void GetBrightnessPercent(
       const base::Callback<void(double)>& callback) override {
     callback.Run(100.0);
   }
@@ -136,17 +135,15 @@ class DummyImeControlDelegate : public ImeControlDelegate {
         handle_previous_ime_count_(0),
         handle_switch_ime_count_(0) {
   }
-  virtual ~DummyImeControlDelegate() {}
+  ~DummyImeControlDelegate() override {}
 
-  virtual void HandleNextIme() override {
-    ++handle_next_ime_count_;
-  }
-  virtual bool HandlePreviousIme(const ui::Accelerator& accelerator) override {
+  void HandleNextIme() override { ++handle_next_ime_count_; }
+  bool HandlePreviousIme(const ui::Accelerator& accelerator) override {
     ++handle_previous_ime_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleSwitchIme(const ui::Accelerator& accelerator) override {
+  bool HandleSwitchIme(const ui::Accelerator& accelerator) override {
     ++handle_switch_ime_count_;
     last_accelerator_ = accelerator;
     return consume_;
@@ -164,7 +161,7 @@ class DummyImeControlDelegate : public ImeControlDelegate {
   const ui::Accelerator& last_accelerator() const {
     return last_accelerator_;
   }
-  virtual ui::Accelerator RemapAccelerator(
+  ui::Accelerator RemapAccelerator(
       const ui::Accelerator& accelerator) override {
     return ui::Accelerator(accelerator);
   }
@@ -187,17 +184,16 @@ class DummyKeyboardBrightnessControlDelegate
         handle_keyboard_brightness_down_count_(0),
         handle_keyboard_brightness_up_count_(0) {
   }
-  virtual ~DummyKeyboardBrightnessControlDelegate() {}
+  ~DummyKeyboardBrightnessControlDelegate() override {}
 
-  virtual bool HandleKeyboardBrightnessDown(
+  bool HandleKeyboardBrightnessDown(
       const ui::Accelerator& accelerator) override {
     ++handle_keyboard_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
 
-  virtual bool HandleKeyboardBrightnessUp(
-      const ui::Accelerator& accelerator) override {
+  bool HandleKeyboardBrightnessUp(const ui::Accelerator& accelerator) override {
     ++handle_keyboard_brightness_up_count_;
     last_accelerator_ = accelerator;
     return consume_;
@@ -241,7 +237,7 @@ bool TestTarget::CanHandleAccelerators() const {
 class AcceleratorControllerTest : public test::AshTestBase {
  public:
   AcceleratorControllerTest() {}
-  virtual ~AcceleratorControllerTest() {}
+  ~AcceleratorControllerTest() override {}
 
  protected:
   void EnableInternalDisplay() {
@@ -1253,10 +1249,10 @@ namespace {
 class PreferredReservedAcceleratorsTest : public test::AshTestBase {
  public:
   PreferredReservedAcceleratorsTest() {}
-  virtual ~PreferredReservedAcceleratorsTest() {}
+  ~PreferredReservedAcceleratorsTest() override {}
 
   // test::AshTestBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     Shell::GetInstance()->lock_state_controller()->
         set_animator_for_test(new test::TestSessionStateAnimator);
diff --git a/ash/accelerators/accelerator_delegate.h b/ash/accelerators/accelerator_delegate.h
index 7027d68..3250a0c 100644
--- a/ash/accelerators/accelerator_delegate.h
+++ b/ash/accelerators/accelerator_delegate.h
@@ -15,12 +15,12 @@ class ASH_EXPORT AcceleratorDelegate
     : NON_EXPORTED_BASE(public wm::AcceleratorDelegate) {
  public:
   AcceleratorDelegate();
-  virtual ~AcceleratorDelegate();
+  ~AcceleratorDelegate() override;
 
   // wm::AcceleratorDelegate:
-  virtual bool ProcessAccelerator(const ui::KeyEvent& event,
-                                  const ui::Accelerator& accelerator,
-                                  KeyType key_type) override;
+  bool ProcessAccelerator(const ui::KeyEvent& event,
+                          const ui::Accelerator& accelerator,
+                          KeyType key_type) override;
 
  private:
   // Returns true if the window should be allowed a chance to handle
diff --git a/ash/accelerators/exit_warning_handler.cc b/ash/accelerators/exit_warning_handler.cc
index 275dc5a..21e4aff 100644
--- a/ash/accelerators/exit_warning_handler.cc
+++ b/ash/accelerators/exit_warning_handler.cc
@@ -68,11 +68,11 @@ class ExitWarningWidgetDelegateView : public views::WidgetDelegateView {
     SetLayoutManager(new views::FillLayout);
   }
 
-  virtual gfx::Size GetPreferredSize() const override {
+  gfx::Size GetPreferredSize() const override {
     return gfx::Size(width_, height_);
   }
 
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(kWindowBackgroundColor);
@@ -80,7 +80,7 @@ class ExitWarningWidgetDelegateView : public views::WidgetDelegateView {
     views::WidgetDelegateView::OnPaint(canvas);
   }
 
-  virtual void GetAccessibleState(ui::AXViewState* state) override {
+  void GetAccessibleState(ui::AXViewState* state) override {
     state->name = accessible_name_;
     state->role = ui::AX_ROLE_ALERT;
   }
diff --git a/ash/accelerators/focus_manager_factory.h b/ash/accelerators/focus_manager_factory.h
index 1f6a1cf..fc14151 100644
--- a/ash/accelerators/focus_manager_factory.h
+++ b/ash/accelerators/focus_manager_factory.h
@@ -17,21 +17,19 @@ namespace ash {
 class AshFocusManagerFactory : public views::FocusManagerFactory {
  public:
   AshFocusManagerFactory();
-  virtual ~AshFocusManagerFactory();
+  ~AshFocusManagerFactory() override;
 
  protected:
   // views::FocusManagerFactory overrides:
-  virtual views::FocusManager* CreateFocusManager(
-      views::Widget* widget,
-      bool desktop_widget) override;
+  views::FocusManager* CreateFocusManager(views::Widget* widget,
+                                          bool desktop_widget) override;
 
  private:
   class Delegate : public views::FocusManagerDelegate {
    public:
     // views::FocusManagerDelegate overrides:
-    virtual bool ProcessAccelerator(
-        const ui::Accelerator& accelerator) override;
-    virtual ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
+    bool ProcessAccelerator(const ui::Accelerator& accelerator) override;
+    ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
         const ui::Accelerator& accelerator) const override;
   };
 
diff --git a/ash/accelerators/key_hold_detector.h b/ash/accelerators/key_hold_detector.h
index 96c89fd..cad7e9f 100644
--- a/ash/accelerators/key_hold_detector.h
+++ b/ash/accelerators/key_hold_detector.h
@@ -39,10 +39,10 @@ class ASH_EXPORT KeyHoldDetector : public ui::EventHandler {
   };
 
   explicit KeyHoldDetector(scoped_ptr<Delegate> delegate);
-  virtual ~KeyHoldDetector();
+  ~KeyHoldDetector() override;
 
   // ui::EventHandler overrides:
-  virtual void OnKeyEvent(ui::KeyEvent* key_event) override;
+  void OnKeyEvent(ui::KeyEvent* key_event) override;
 
  private:
   // A state to keep track of one click and click and hold operation.
diff --git a/ash/accelerators/magnifier_key_scroller.h b/ash/accelerators/magnifier_key_scroller.h
index 1ef78fb..2e16533 100644
--- a/ash/accelerators/magnifier_key_scroller.h
+++ b/ash/accelerators/magnifier_key_scroller.h
@@ -39,13 +39,13 @@ class ASH_EXPORT MagnifierKeyScroller : public KeyHoldDetector::Delegate {
 
  private:
   // KeyHoldDetector overrides:
-  virtual bool ShouldProcessEvent(const ui::KeyEvent* event) const override;
-  virtual bool IsStartEvent(const ui::KeyEvent* event) const override;
-  virtual void OnKeyHold(const ui::KeyEvent* event) override;
-  virtual void OnKeyUnhold(const ui::KeyEvent* event) override;
+  bool ShouldProcessEvent(const ui::KeyEvent* event) const override;
+  bool IsStartEvent(const ui::KeyEvent* event) const override;
+  void OnKeyHold(const ui::KeyEvent* event) override;
+  void OnKeyUnhold(const ui::KeyEvent* event) override;
 
   MagnifierKeyScroller();
-  virtual ~MagnifierKeyScroller();
+  ~MagnifierKeyScroller() override;
 
   DISALLOW_COPY_AND_ASSIGN(MagnifierKeyScroller);
 };
diff --git a/ash/accelerators/magnifier_key_scroller_unittest.cc b/ash/accelerators/magnifier_key_scroller_unittest.cc
index c8670a7..8555369 100644
--- a/ash/accelerators/magnifier_key_scroller_unittest.cc
+++ b/ash/accelerators/magnifier_key_scroller_unittest.cc
@@ -17,10 +17,10 @@ namespace {
 class KeyEventDelegate : public aura::test::TestWindowDelegate {
  public:
   KeyEventDelegate() {}
-  virtual ~KeyEventDelegate() {}
+  ~KeyEventDelegate() override {}
 
   // ui::EventHandler overrides:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override {
+  void OnKeyEvent(ui::KeyEvent* event) override {
     key_event.reset(new ui::KeyEvent(
         event->type(), event->key_code(), event->flags()));
   }
diff --git a/ash/accelerators/nested_accelerator_delegate.h b/ash/accelerators/nested_accelerator_delegate.h
index 5a8dfad..2e9b765 100644
--- a/ash/accelerators/nested_accelerator_delegate.h
+++ b/ash/accelerators/nested_accelerator_delegate.h
@@ -13,11 +13,10 @@ namespace ash {
 class NestedAcceleratorDelegate : public wm::NestedAcceleratorDelegate {
  public:
   NestedAcceleratorDelegate();
-  virtual ~NestedAcceleratorDelegate();
+  ~NestedAcceleratorDelegate() override;
 
   // wm::AcceleratorDispatcher::Delegate
-  virtual Result ProcessAccelerator(
-      const ui::Accelerator& accelerator) override;
+  Result ProcessAccelerator(const ui::Accelerator& accelerator) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NestedAcceleratorDelegate);
diff --git a/ash/accelerators/spoken_feedback_toggler.h b/ash/accelerators/spoken_feedback_toggler.h
index 067a7d1..51bf985 100644
--- a/ash/accelerators/spoken_feedback_toggler.h
+++ b/ash/accelerators/spoken_feedback_toggler.h
@@ -39,13 +39,13 @@ class ASH_EXPORT SpokenFeedbackToggler : public KeyHoldDetector::Delegate {
 
  private:
   // KeyHoldDetector overrides:
-  virtual bool ShouldProcessEvent(const ui::KeyEvent* event) const override;
-  virtual bool IsStartEvent(const ui::KeyEvent* event) const override;
-  virtual void OnKeyHold(const ui::KeyEvent* event) override;
-  virtual void OnKeyUnhold(const ui::KeyEvent* event) override;
+  bool ShouldProcessEvent(const ui::KeyEvent* event) const override;
+  bool IsStartEvent(const ui::KeyEvent* event) const override;
+  void OnKeyHold(const ui::KeyEvent* event) override;
+  void OnKeyUnhold(const ui::KeyEvent* event) override;
 
   SpokenFeedbackToggler();
-  virtual ~SpokenFeedbackToggler();
+  ~SpokenFeedbackToggler() override;
 
   bool toggled_;
 
diff --git a/ash/autoclick/autoclick_controller.cc b/ash/autoclick/autoclick_controller.cc
index d331f70f..c551f65 100644
--- a/ash/autoclick/autoclick_controller.cc
+++ b/ash/autoclick/autoclick_controller.cc
@@ -45,21 +45,21 @@ class AutoclickControllerImpl : public AutoclickController,
                                 public ui::EventHandler {
  public:
   AutoclickControllerImpl();
-  virtual ~AutoclickControllerImpl();
+  ~AutoclickControllerImpl() override;
 
  private:
   // AutoclickController overrides:
-  virtual void SetEnabled(bool enabled) override;
-  virtual bool IsEnabled() const override;
-  virtual void SetAutoclickDelay(int delay_ms) override;
-  virtual int GetAutoclickDelay() const override;
+  void SetEnabled(bool enabled) override;
+  bool IsEnabled() const override;
+  void SetAutoclickDelay(int delay_ms) override;
+  int GetAutoclickDelay() const override;
 
   // ui::EventHandler overrides:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override;
-  virtual void OnKeyEvent(ui::KeyEvent* event) override;
-  virtual void OnTouchEvent(ui::TouchEvent* event) override;
-  virtual void OnGestureEvent(ui::GestureEvent* event) override;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
 
   void InitClickTimer();
 
diff --git a/ash/content_support/gpu_support_impl.h b/ash/content_support/gpu_support_impl.h
index e7b243d..138bb8d 100644
--- a/ash/content_support/gpu_support_impl.h
+++ b/ash/content_support/gpu_support_impl.h
@@ -14,13 +14,13 @@ namespace ash {
 class ASH_WITH_CONTENT_EXPORT GPUSupportImpl : public GPUSupport {
  public:
   GPUSupportImpl();
-  virtual ~GPUSupportImpl();
+  ~GPUSupportImpl() override;
 
  private:
   // Overridden from GPUSupport:
-  virtual bool IsPanelFittingDisabled() const override;
-  virtual void DisableGpuWatchdog() override;
-  virtual void GetGpuProcessHandles(
+  bool IsPanelFittingDisabled() const override;
+  void DisableGpuWatchdog() override;
+  void GetGpuProcessHandles(
       const GetGpuProcessHandlesCallback& callback) const override;
 
   DISALLOW_COPY_AND_ASSIGN(GPUSupportImpl);
diff --git a/ash/default_accessibility_delegate.h b/ash/default_accessibility_delegate.h
index 86115dc..a9604b7 100644
--- a/ash/default_accessibility_delegate.h
+++ b/ash/default_accessibility_delegate.h
@@ -15,32 +15,32 @@ namespace ash {
 class ASH_EXPORT DefaultAccessibilityDelegate : public AccessibilityDelegate {
  public:
   DefaultAccessibilityDelegate();
-  virtual ~DefaultAccessibilityDelegate();
-
-  virtual bool IsSpokenFeedbackEnabled() const override;
-  virtual void ToggleHighContrast() override;
-  virtual bool IsHighContrastEnabled() const override;
-  virtual void SetMagnifierEnabled(bool enabled) override;
-  virtual void SetMagnifierType(MagnifierType type) override;
-  virtual bool IsMagnifierEnabled() const override;
-  virtual MagnifierType GetMagnifierType() const override;
-  virtual void SetLargeCursorEnabled(bool enabled) override;
-  virtual bool IsLargeCursorEnabled() const override;
-  virtual void SetAutoclickEnabled(bool enabled) override;
-  virtual bool IsAutoclickEnabled() const override;
-  virtual void SetVirtualKeyboardEnabled(bool enabled) override;
-  virtual bool IsVirtualKeyboardEnabled() const override;
-  virtual bool ShouldShowAccessibilityMenu() const override;
-  virtual bool IsBrailleDisplayConnected() const override;
-  virtual void SilenceSpokenFeedback() const override;
-  virtual void ToggleSpokenFeedback(
+  ~DefaultAccessibilityDelegate() override;
+
+  bool IsSpokenFeedbackEnabled() const override;
+  void ToggleHighContrast() override;
+  bool IsHighContrastEnabled() const override;
+  void SetMagnifierEnabled(bool enabled) override;
+  void SetMagnifierType(MagnifierType type) override;
+  bool IsMagnifierEnabled() const override;
+  MagnifierType GetMagnifierType() const override;
+  void SetLargeCursorEnabled(bool enabled) override;
+  bool IsLargeCursorEnabled() const override;
+  void SetAutoclickEnabled(bool enabled) override;
+  bool IsAutoclickEnabled() const override;
+  void SetVirtualKeyboardEnabled(bool enabled) override;
+  bool IsVirtualKeyboardEnabled() const override;
+  bool ShouldShowAccessibilityMenu() const override;
+  bool IsBrailleDisplayConnected() const override;
+  void SilenceSpokenFeedback() const override;
+  void ToggleSpokenFeedback(
       AccessibilityNotificationVisibility notify) override;
-  virtual void SaveScreenMagnifierScale(double scale) override;
-  virtual double GetSavedScreenMagnifierScale() override;
-  virtual void TriggerAccessibilityAlert(AccessibilityAlert alert) override;
-  virtual AccessibilityAlert GetLastAccessibilityAlert() override;
-  virtual void PlayEarcon(int sound_key) override;
-  virtual base::TimeDelta PlayShutdownSound() const override;
+  void SaveScreenMagnifierScale(double scale) override;
+  double GetSavedScreenMagnifierScale() override;
+  void TriggerAccessibilityAlert(AccessibilityAlert alert) override;
+  AccessibilityAlert GetLastAccessibilityAlert() override;
+  void PlayEarcon(int sound_key) override;
+  base::TimeDelta PlayShutdownSound() const override;
 
  private:
   bool spoken_feedback_enabled_;
diff --git a/ash/default_user_wallpaper_delegate.h b/ash/default_user_wallpaper_delegate.h
index 42fb1a3..fbbccde 100644
--- a/ash/default_user_wallpaper_delegate.h
+++ b/ash/default_user_wallpaper_delegate.h
@@ -15,20 +15,19 @@ namespace ash {
 class ASH_EXPORT DefaultUserWallpaperDelegate : public UserWallpaperDelegate {
  public:
   DefaultUserWallpaperDelegate() {}
-  virtual ~DefaultUserWallpaperDelegate() {}
+  ~DefaultUserWallpaperDelegate() override {}
 
   // UserWallpaperDelegate overrides:
-  virtual int GetAnimationType() override;
-  virtual int GetAnimationDurationOverride() override;
-  virtual void SetAnimationDurationOverride(
-      int animation_duration_in_ms) override;
-  virtual bool ShouldShowInitialAnimation() override;
-  virtual void UpdateWallpaper(bool clear_cache) override;
-  virtual void InitializeWallpaper() override;
-  virtual void OpenSetWallpaperPage() override;
-  virtual bool CanOpenSetWallpaperPage() override;
-  virtual void OnWallpaperAnimationFinished() override;
-  virtual void OnWallpaperBootAnimationFinished() override;
+  int GetAnimationType() override;
+  int GetAnimationDurationOverride() override;
+  void SetAnimationDurationOverride(int animation_duration_in_ms) override;
+  bool ShouldShowInitialAnimation() override;
+  void UpdateWallpaper(bool clear_cache) override;
+  void InitializeWallpaper() override;
+  void OpenSetWallpaperPage() override;
+  bool CanOpenSetWallpaperPage() override;
+  void OnWallpaperAnimationFinished() override;
+  void OnWallpaperBootAnimationFinished() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultUserWallpaperDelegate);
diff --git a/ash/desktop_background/desktop_background_controller.h b/ash/desktop_background/desktop_background_controller.h
index e9bf639..66752a1 100644
--- a/ash/desktop_background/desktop_background_controller.h
+++ b/ash/desktop_background/desktop_background_controller.h
@@ -58,7 +58,7 @@ class ASH_EXPORT DesktopBackgroundController
   };
 
   DesktopBackgroundController();
-  virtual ~DesktopBackgroundController();
+  ~DesktopBackgroundController() override;
 
   BackgroundMode desktop_background_mode() const {
     return desktop_background_mode_;
@@ -97,10 +97,10 @@ class ASH_EXPORT DesktopBackgroundController
   bool MoveDesktopToUnlockedContainer();
 
   // DisplayController::Observer:
-  virtual void OnDisplayConfigurationChanged() override;
+  void OnDisplayConfigurationChanged() override;
 
   // ShellObserver:
-  virtual void OnRootWindowAdded(aura::Window* root_window) override;
+  void OnRootWindowAdded(aura::Window* root_window) override;
 
   // Returns the maximum size of all displays combined in native
   // resolutions.  Note that this isn't the bounds of the display who
diff --git a/ash/desktop_background/desktop_background_controller_unittest.cc b/ash/desktop_background/desktop_background_controller_unittest.cc
index e504f03..49f7f79 100644
--- a/ash/desktop_background/desktop_background_controller_unittest.cc
+++ b/ash/desktop_background/desktop_background_controller_unittest.cc
@@ -71,9 +71,9 @@ class DesktopBackgroundControllerTest : public test::AshTestBase {
       : controller_(NULL),
         wallpaper_delegate_(NULL) {
   }
-  virtual ~DesktopBackgroundControllerTest() {}
+  ~DesktopBackgroundControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     // Ash shell initialization creates wallpaper. Reset it so we can manually
     // control wallpaper creation and animation in our tests.
diff --git a/ash/desktop_background/desktop_background_view.cc b/ash/desktop_background/desktop_background_view.cc
index 3af8599..c87b4fd 100644
--- a/ash/desktop_background/desktop_background_view.cc
+++ b/ash/desktop_background/desktop_background_view.cc
@@ -49,7 +49,7 @@ class LayerControlView : public views::View {
   }
 
   // Overrides views::View.
-  virtual void Layout() override {
+  void Layout() override {
     gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
         GetWidget()->GetNativeView());
     DisplayManager* display_manager = Shell::GetInstance()->display_manager();
@@ -79,11 +79,11 @@ class LayerControlView : public views::View {
 class PreEventDispatchHandler : public ui::EventHandler {
  public:
   PreEventDispatchHandler() {}
-  virtual ~PreEventDispatchHandler() {}
+  ~PreEventDispatchHandler() override {}
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     CHECK_EQ(ui::EP_PRETARGET, event->phase());
     WindowSelectorController* controller =
         Shell::GetInstance()->window_selector_controller();
@@ -93,7 +93,7 @@ class PreEventDispatchHandler : public ui::EventHandler {
     }
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     CHECK_EQ(ui::EP_PRETARGET, event->phase());
     WindowSelectorController* controller =
         Shell::GetInstance()->window_selector_controller();
diff --git a/ash/desktop_background/desktop_background_view.h b/ash/desktop_background/desktop_background_view.h
index 6a93823..17814d0 100644
--- a/ash/desktop_background/desktop_background_view.h
+++ b/ash/desktop_background/desktop_background_view.h
@@ -18,17 +18,17 @@ class DesktopBackgroundView : public views::View,
                               public views::ContextMenuController {
  public:
   DesktopBackgroundView();
-  virtual ~DesktopBackgroundView();
+  ~DesktopBackgroundView() override;
 
  private:
   // Overridden from views::View:
-  virtual void OnPaint(gfx::Canvas* canvas) override;
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override;
+  void OnPaint(gfx::Canvas* canvas) override;
+  bool OnMousePressed(const ui::MouseEvent& event) override;
 
   // Overridden from views::ContextMenuController:
-  virtual void ShowContextMenuForView(views::View* source,
-                                      const gfx::Point& point,
-                                      ui::MenuSourceType source_type) override;
+  void ShowContextMenuForView(views::View* source,
+                              const gfx::Point& point,
+                              ui::MenuSourceType source_type) override;
   scoped_ptr<PreEventDispatchHandler> pre_dispatch_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopBackgroundView);
diff --git a/ash/desktop_background/desktop_background_widget_controller.cc b/ash/desktop_background/desktop_background_widget_controller.cc
index cd90318..72351c3 100644
--- a/ash/desktop_background/desktop_background_widget_controller.cc
+++ b/ash/desktop_background/desktop_background_widget_controller.cc
@@ -30,7 +30,7 @@ class ShowWallpaperAnimationObserver : public ui::ImplicitAnimationObserver,
     desktop_widget_->AddObserver(this);
   }
 
-  virtual ~ShowWallpaperAnimationObserver() {
+  ~ShowWallpaperAnimationObserver() override {
     StopObservingImplicitAnimations();
     if (desktop_widget_)
       desktop_widget_->RemoveObserver(this);
@@ -38,22 +38,20 @@ class ShowWallpaperAnimationObserver : public ui::ImplicitAnimationObserver,
 
  private:
   // Overridden from ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsScheduled() override {
+  void OnImplicitAnimationsScheduled() override {
     if (is_initial_animation_) {
       root_window_controller_->
           HandleInitialDesktopBackgroundAnimationStarted();
     }
   }
 
-  virtual void OnImplicitAnimationsCompleted() override {
+  void OnImplicitAnimationsCompleted() override {
     root_window_controller_->OnWallpaperAnimationFinished(desktop_widget_);
     delete this;
   }
 
   // Overridden from views::WidgetObserver.
-  virtual void OnWidgetDestroying(views::Widget* widget) override {
-    delete this;
-  }
+  void OnWidgetDestroying(views::Widget* widget) override { delete this; }
 
   RootWindowController* root_window_controller_;
   views::Widget* desktop_widget_;
diff --git a/ash/desktop_background/desktop_background_widget_controller.h b/ash/desktop_background/desktop_background_widget_controller.h
index 0aafe2e..bad030c 100644
--- a/ash/desktop_background/desktop_background_widget_controller.h
+++ b/ash/desktop_background/desktop_background_widget_controller.h
@@ -25,10 +25,10 @@ class ASH_EXPORT DesktopBackgroundWidgetController
   // Create
   explicit DesktopBackgroundWidgetController(views::Widget* widget);
 
-  virtual ~DesktopBackgroundWidgetController();
+  ~DesktopBackgroundWidgetController() override;
 
   // Overridden from views::WidgetObserver.
-  virtual void OnWidgetDestroying(views::Widget* widget) override;
+  void OnWidgetDestroying(views::Widget* widget) override;
 
   // Set bounds of component that draws background.
   void SetBounds(gfx::Rect bounds);
diff --git a/ash/desktop_background/wallpaper_resizer_unittest.cc b/ash/desktop_background/wallpaper_resizer_unittest.cc
index 97bd249..6a06490 100644
--- a/ash/desktop_background/wallpaper_resizer_unittest.cc
+++ b/ash/desktop_background/wallpaper_resizer_unittest.cc
@@ -61,7 +61,7 @@ class WallpaperResizerTest : public testing::Test,
   WallpaperResizerTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   }
-  virtual ~WallpaperResizerTest() {}
+  ~WallpaperResizerTest() override {}
 
   gfx::ImageSkia Resize(const gfx::ImageSkia& image,
                         const gfx::Size& target_size,
@@ -79,9 +79,7 @@ class WallpaperResizerTest : public testing::Test,
     message_loop_.Run();
   }
 
-  virtual void OnWallpaperResized() override {
-    message_loop_.Quit();
-  }
+  void OnWallpaperResized() override { message_loop_.Quit(); }
 
  private:
   base::MessageLoop message_loop_;
diff --git a/ash/extended_desktop_unittest.cc b/ash/extended_desktop_unittest.cc
index 7e88d47..2abea49 100644
--- a/ash/extended_desktop_unittest.cc
+++ b/ash/extended_desktop_unittest.cc
@@ -45,15 +45,11 @@ void SetSecondaryDisplayLayout(DisplayLayout::Position position) {
 class ModalWidgetDelegate : public views::WidgetDelegateView {
  public:
   ModalWidgetDelegate() {}
-  virtual ~ModalWidgetDelegate() {}
+  ~ModalWidgetDelegate() override {}
 
   // Overridden from views::WidgetDelegate:
-  virtual views::View* GetContentsView() override {
-    return this;
-  }
-  virtual ui::ModalType GetModalType() const override {
-    return ui::MODAL_TYPE_SYSTEM;
-  }
+  views::View* GetContentsView() override { return this; }
+  ui::ModalType GetModalType() const override { return ui::MODAL_TYPE_SYSTEM; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ModalWidgetDelegate);
@@ -65,11 +61,11 @@ class MoveWindowByClickEventHandler : public ui::EventHandler {
  public:
   explicit MoveWindowByClickEventHandler(aura::Window* target)
       : target_(target) {}
-  virtual ~MoveWindowByClickEventHandler() {}
+  ~MoveWindowByClickEventHandler() override {}
 
  private:
   // ui::EventHandler overrides:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_RELEASED) {
       aura::Window::Windows root_windows = Shell::GetAllRootWindows();
       DCHECK_LT(1u, root_windows.size());
@@ -87,7 +83,7 @@ class EventLocationRecordingEventHandler : public ui::EventHandler {
   explicit EventLocationRecordingEventHandler() {
     reset();
   }
-  virtual ~EventLocationRecordingEventHandler() {}
+  ~EventLocationRecordingEventHandler() override {}
 
   std::string GetLocationsAndReset() {
     std::string result =
@@ -98,7 +94,7 @@ class EventLocationRecordingEventHandler : public ui::EventHandler {
 
  private:
   // ui::EventHandler overrides:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_MOVED ||
         event->type() == ui::ET_MOUSE_DRAGGED) {
       location_ = event->location();
@@ -120,14 +116,14 @@ class EventLocationRecordingEventHandler : public ui::EventHandler {
 class EventLocationHandler : public ui::EventHandler {
  public:
   EventLocationHandler() {}
-  virtual ~EventLocationHandler() {}
+  ~EventLocationHandler() override {}
 
   const gfx::Point& press_location() const { return press_location_; }
   const gfx::Point& release_location() const { return release_location_; }
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_PRESSED)
       press_location_ = event->location();
     else if (event->type() == ui::ET_MOUSE_RELEASED)
diff --git a/ash/first_run/desktop_cleaner.cc b/ash/first_run/desktop_cleaner.cc
index 6f0dfb1..27c1d07 100644
--- a/ash/first_run/desktop_cleaner.cc
+++ b/ash/first_run/desktop_cleaner.cc
@@ -41,7 +41,7 @@ class ContainerHider : public aura::WindowObserver,
     layer->SetOpacity(0.0);
   }
 
-  virtual ~ContainerHider() {
+  ~ContainerHider() override {
     if (container_was_hidden_ || !container_)
       return;
     if (!WasAnimationCompletedForProperty(ui::LayerAnimationElement::OPACITY)) {
@@ -57,12 +57,10 @@ class ContainerHider : public aura::WindowObserver,
 
  private:
   // Overriden from ui::ImplicitAnimationObserver.
-  virtual void OnImplicitAnimationsCompleted() override {
-    container_->Hide();
-  }
+  void OnImplicitAnimationsCompleted() override { container_->Hide(); }
 
   // Overriden from aura::WindowObserver.
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     DCHECK(window == container_);
     container_ = NULL;
   }
@@ -81,11 +79,11 @@ class NotificationBlocker : public message_center::NotificationBlocker {
     NotifyBlockingStateChanged();
   }
 
-  virtual ~NotificationBlocker() {};
+  ~NotificationBlocker() override {}
 
  private:
   // Overriden from message_center::NotificationBlocker.
-  virtual bool ShouldShowNotificationAsPopup(
+  bool ShouldShowNotificationAsPopup(
       const message_center::NotifierId& notifier_id) const override {
     return false;
   }
diff --git a/ash/first_run/first_run_helper_impl.h b/ash/first_run/first_run_helper_impl.h
index fbee996..5e091f9 100644
--- a/ash/first_run/first_run_helper_impl.h
+++ b/ash/first_run/first_run_helper_impl.h
@@ -18,25 +18,25 @@ class FirstRunHelperImpl : public FirstRunHelper,
                            public OverlayEventFilter::Delegate {
  public:
   FirstRunHelperImpl();
-  virtual ~FirstRunHelperImpl();
+  ~FirstRunHelperImpl() override;
 
   // Overriden from FirstRunHelper.
-  virtual views::Widget* GetOverlayWidget() override;
-  virtual void OpenAppList() override;
-  virtual void CloseAppList() override;
-  virtual gfx::Rect GetLauncherBounds() override;
-  virtual gfx::Rect GetAppListButtonBounds() override;
-  virtual gfx::Rect GetAppListBounds() override;
-  virtual void OpenTrayBubble() override;
-  virtual void CloseTrayBubble() override;
-  virtual bool IsTrayBubbleOpened() override;
-  virtual gfx::Rect GetTrayBubbleBounds() override;
-  virtual gfx::Rect GetHelpButtonBounds() override;
+  views::Widget* GetOverlayWidget() override;
+  void OpenAppList() override;
+  void CloseAppList() override;
+  gfx::Rect GetLauncherBounds() override;
+  gfx::Rect GetAppListButtonBounds() override;
+  gfx::Rect GetAppListBounds() override;
+  void OpenTrayBubble() override;
+  void CloseTrayBubble() override;
+  bool IsTrayBubbleOpened() override;
+  gfx::Rect GetTrayBubbleBounds() override;
+  gfx::Rect GetHelpButtonBounds() override;
 
   // Overriden from OverlayEventFilter::Delegate.
-  virtual void Cancel() override;
-  virtual bool IsCancelingKeyEvent(ui::KeyEvent* event) override;
-  virtual aura::Window* GetWindow() override;
+  void Cancel() override;
+  bool IsCancelingKeyEvent(ui::KeyEvent* event) override;
+  aura::Window* GetWindow() override;
 
  private:
   views::Widget* widget_;
diff --git a/ash/gpu_support_stub.h b/ash/gpu_support_stub.h
index 59e063b..d82c314 100644
--- a/ash/gpu_support_stub.h
+++ b/ash/gpu_support_stub.h
@@ -15,13 +15,13 @@ namespace ash {
 class ASH_EXPORT GPUSupportStub : public GPUSupport {
  public:
   GPUSupportStub();
-  virtual ~GPUSupportStub();
+  ~GPUSupportStub() override;
 
  private:
   // Overridden from GPUSupport:
-  virtual bool IsPanelFittingDisabled() const override;
-  virtual void DisableGpuWatchdog() override;
-  virtual void GetGpuProcessHandles(
+  bool IsPanelFittingDisabled() const override;
+  void DisableGpuWatchdog() override;
+  void GetGpuProcessHandles(
       const GetGpuProcessHandlesCallback& callback) const override;
 
   DISALLOW_COPY_AND_ASSIGN(GPUSupportStub);
diff --git a/ash/high_contrast/high_contrast_controller.h b/ash/high_contrast/high_contrast_controller.h
index 8475217..313aa05 100644
--- a/ash/high_contrast/high_contrast_controller.h
+++ b/ash/high_contrast/high_contrast_controller.h
@@ -18,13 +18,13 @@ namespace ash {
 class ASH_EXPORT HighContrastController : public ShellObserver {
  public:
   HighContrastController();
-  virtual ~HighContrastController();
+  ~HighContrastController() override;
 
   // Set high contrast mode and update all available displays.
   void SetEnabled(bool enabled);
 
   // ShellObserver:
-  virtual void OnRootWindowAdded(aura::Window* root_window) override;
+  void OnRootWindowAdded(aura::Window* root_window) override;
 
  private:
   // Update high contrast mode on the passed display.
diff --git a/ash/host/ash_window_tree_host_x11.h b/ash/host/ash_window_tree_host_x11.h
index 3fc4e2b..b18ac1a 100644
--- a/ash/host/ash_window_tree_host_x11.h
+++ b/ash/host/ash_window_tree_host_x11.h
@@ -21,37 +21,36 @@ class ASH_EXPORT AshWindowTreeHostX11 : public AshWindowTreeHost,
                                         public aura::EnvObserver {
  public:
   explicit AshWindowTreeHostX11(const gfx::Rect& initial_bounds);
-  virtual ~AshWindowTreeHostX11();
+  ~AshWindowTreeHostX11() override;
 
  private:
   // AshWindowTreeHost:
-  virtual void ToggleFullScreen() override;
-  virtual bool ConfineCursorToRootWindow() override;
-  virtual void UnConfineCursor() override;
-  virtual void SetRootWindowTransformer(
+  void ToggleFullScreen() override;
+  bool ConfineCursorToRootWindow() override;
+  void UnConfineCursor() override;
+  void SetRootWindowTransformer(
       scoped_ptr<RootWindowTransformer> transformer) override;
-  virtual gfx::Insets GetHostInsets() const override;
-  virtual aura::WindowTreeHost* AsWindowTreeHost() override;
-  virtual void UpdateDisplayID(int64 id1, int64 id2) override;
-  virtual void PrepareForShutdown() override;
+  gfx::Insets GetHostInsets() const override;
+  aura::WindowTreeHost* AsWindowTreeHost() override;
+  void UpdateDisplayID(int64 id1, int64 id2) override;
+  void PrepareForShutdown() override;
 
   // aura::WindowTreehost:
-  virtual void SetBounds(const gfx::Rect& bounds) override;
-  virtual gfx::Transform GetRootTransform() const override;
-  virtual void SetRootTransform(const gfx::Transform& transform) override;
-  virtual gfx::Transform GetInverseRootTransform() const override;
-  virtual void UpdateRootWindowSize(const gfx::Size& host_size) override;
-  virtual void OnCursorVisibilityChangedNative(bool show) override;
+  void SetBounds(const gfx::Rect& bounds) override;
+  gfx::Transform GetRootTransform() const override;
+  void SetRootTransform(const gfx::Transform& transform) override;
+  gfx::Transform GetInverseRootTransform() const override;
+  void UpdateRootWindowSize(const gfx::Size& host_size) override;
+  void OnCursorVisibilityChangedNative(bool show) override;
 
   // aura::WindowTreeHostX11:
-  virtual void OnConfigureNotify() override;
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override;
-  virtual void TranslateAndDispatchLocatedEvent(ui::LocatedEvent* event)
-      override;
+  void OnConfigureNotify() override;
+  bool CanDispatchEvent(const ui::PlatformEvent& event) override;
+  void TranslateAndDispatchLocatedEvent(ui::LocatedEvent* event) override;
 
   // EnvObserver overrides.
-  virtual void OnWindowInitialized(aura::Window* window) override;
-  virtual void OnHostInitialized(aura::WindowTreeHost* host) override;
+  void OnWindowInitialized(aura::Window* window) override;
+  void OnHostInitialized(aura::WindowTreeHost* host) override;
 
 #if defined(OS_CHROMEOS)
   // Set the CrOS touchpad "tap paused" property. It is used to temporarily
diff --git a/ash/host/ash_window_tree_host_x11_unittest.cc b/ash/host/ash_window_tree_host_x11_unittest.cc
index 14642da..442cbbf 100644
--- a/ash/host/ash_window_tree_host_x11_unittest.cc
+++ b/ash/host/ash_window_tree_host_x11_unittest.cc
@@ -29,10 +29,10 @@ class RootWindowEventHandler : public ui::EventHandler {
         last_touch_location_(0, 0) {
     target_->AddPreTargetHandler(this);
   }
-  virtual ~RootWindowEventHandler() { target_->RemovePreTargetHandler(this); }
+  ~RootWindowEventHandler() override { target_->RemovePreTargetHandler(this); }
 
   // ui::EventHandler:
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     last_touch_id_ = event->touch_id();
     last_touch_type_ = event->type();
     last_touch_location_ = event->location();
@@ -59,7 +59,7 @@ namespace ash {
 
 class AshWindowTreeHostX11Test : public aura::test::AuraTestBase {
  public:
-  virtual void SetUp() override {
+  void SetUp() override {
     aura::test::AuraTestBase::SetUp();
 
 #if defined(OS_CHROMEOS)
@@ -69,7 +69,7 @@ class AshWindowTreeHostX11Test : public aura::test::AuraTestBase {
 #endif
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     aura::test::AuraTestBase::TearDown();
 
 #if defined(OS_CHROMEOS)
diff --git a/ash/host/transformer_helper.cc b/ash/host/transformer_helper.cc
index ce377cf..8659603 100644
--- a/ash/host/transformer_helper.cc
+++ b/ash/host/transformer_helper.cc
@@ -27,27 +27,26 @@ class SimpleRootWindowTransformer : public RootWindowTransformer {
       : root_window_(root_window), transform_(transform) {}
 
   // RootWindowTransformer overrides:
-  virtual gfx::Transform GetTransform() const override { return transform_; }
+  gfx::Transform GetTransform() const override { return transform_; }
 
-  virtual gfx::Transform GetInverseTransform() const override {
+  gfx::Transform GetInverseTransform() const override {
     gfx::Transform invert;
     if (!transform_.GetInverse(&invert))
       return transform_;
     return invert;
   }
 
-  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);
     gfx::RectF new_bounds(ui::ConvertRectToDIP(root_window_->layer(), bounds));
     transform_.TransformRect(&new_bounds);
     return gfx::Rect(gfx::ToFlooredSize(new_bounds.size()));
   }
 
-  virtual gfx::Insets GetHostInsets() const override { return gfx::Insets(); }
+  gfx::Insets GetHostInsets() const override { return gfx::Insets(); }
 
  private:
-  virtual ~SimpleRootWindowTransformer() {}
+  ~SimpleRootWindowTransformer() override {}
 
   const aura::Window* root_window_;
   const gfx::Transform transform_;
diff --git a/ash/ime/candidate_view.cc b/ash/ime/candidate_view.cc
index 0cafbe1..b13cb0a 100644
--- a/ash/ime/candidate_view.cc
+++ b/ash/ime/candidate_view.cc
@@ -26,11 +26,11 @@ class VerticalCandidateLabel : public views::Label {
   VerticalCandidateLabel() {}
 
  private:
-  virtual ~VerticalCandidateLabel() {}
+  ~VerticalCandidateLabel() override {}
 
   // Returns the preferred size, but guarantees that the width has at
   // least kMinCandidateLabelWidth pixels.
-  virtual gfx::Size GetPreferredSize() const override {
+  gfx::Size GetPreferredSize() const override {
     gfx::Size size = Label::GetPreferredSize();
     size.SetToMax(gfx::Size(kMinCandidateLabelWidth, 0));
     size.SetToMin(gfx::Size(kMaxCandidateLabelWidth, size.height()));
diff --git a/ash/ime/candidate_view.h b/ash/ime/candidate_view.h
index f800a40..6b1c650 100644
--- a/ash/ime/candidate_view.h
+++ b/ash/ime/candidate_view.h
@@ -20,7 +20,7 @@ class ASH_EXPORT CandidateView : public views::CustomButton {
  public:
   CandidateView(views::ButtonListener* listener,
                 ui::CandidateWindow::Orientation orientation);
-  virtual ~CandidateView() {}
+  ~CandidateView() override {}
 
   void GetPreferredWidths(int* shortcut_width,
                           int* candidate_width);
@@ -40,12 +40,12 @@ class ASH_EXPORT CandidateView : public views::CustomButton {
   FRIEND_TEST_ALL_PREFIXES(CandidateWindowViewTest, ShortcutSettingTest);
 
   // Overridden from views::CustomButton:
-  virtual void StateChanged() override;
+  void StateChanged() override;
 
   // Overridden from View:
-  virtual bool OnMouseDragged(const ui::MouseEvent& event) override;
-  virtual void Layout() override;
-  virtual gfx::Size GetPreferredSize() const override;
+  bool OnMouseDragged(const ui::MouseEvent& event) override;
+  void Layout() override;
+  gfx::Size GetPreferredSize() const override;
 
   // The orientation of the candidate view.
   ui::CandidateWindow::Orientation orientation_;
diff --git a/ash/ime/candidate_view_unittest.cc b/ash/ime/candidate_view_unittest.cc
index a7396eb..5b6feaa 100644
--- a/ash/ime/candidate_view_unittest.cc
+++ b/ash/ime/candidate_view_unittest.cc
@@ -30,9 +30,9 @@ class CandidateViewTest : public views::ViewsTestBase,
                           public views::ButtonListener {
  public:
   CandidateViewTest() : widget_(NULL), last_pressed_(NULL) {}
-  virtual ~CandidateViewTest() {}
+  ~CandidateViewTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     views::ViewsTestBase::SetUp();
 
     views::Widget::InitParams init_params(CreateParams(
@@ -61,7 +61,7 @@ class CandidateViewTest : public views::ViewsTestBase,
         native_window->GetRootWindow(), native_window));
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     widget_->Close();
 
     views::ViewsTestBase::TearDown();
@@ -100,8 +100,7 @@ class CandidateViewTest : public views::ViewsTestBase,
   ui::test::EventGenerator* event_generator() { return event_generator_.get(); }
 
  private:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override {
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     last_pressed_ = sender;
   }
 
diff --git a/ash/ime/candidate_window_view.cc b/ash/ime/candidate_window_view.cc
index af71647..66b54d5 100644
--- a/ash/ime/candidate_window_view.cc
+++ b/ash/ime/candidate_window_view.cc
@@ -35,14 +35,14 @@ class CandidateWindowBorder : public views::BubbleBorder {
         offset_(0) {
     set_paint_arrow(views::BubbleBorder::PAINT_NONE);
   }
-  virtual ~CandidateWindowBorder() {}
+  ~CandidateWindowBorder() override {}
 
   void set_offset(int offset) { offset_ = offset; }
 
  private:
   // Overridden from views::BubbleBorder:
-  virtual gfx::Rect GetBounds(const gfx::Rect& anchor_rect,
-                              const gfx::Size& content_size) const override {
+  gfx::Rect GetBounds(const gfx::Rect& anchor_rect,
+                      const gfx::Size& content_size) const override {
     gfx::Rect bounds(content_size);
     bounds.set_origin(gfx::Point(
         anchor_rect.x() - offset_,
@@ -62,9 +62,7 @@ class CandidateWindowBorder : public views::BubbleBorder {
     return bounds;
   }
 
-  virtual gfx::Insets GetInsets() const override {
-    return gfx::Insets();
-  }
+  gfx::Insets GetInsets() const override { return gfx::Insets(); }
 
   gfx::NativeView parent_;
   int offset_;
@@ -130,7 +128,7 @@ class InformationTextArea : public views::View {
   }
 
  protected:
-  virtual gfx::Size GetPreferredSize() const override {
+  gfx::Size GetPreferredSize() const override {
     gfx::Size size = views::View::GetPreferredSize();
     size.SetToMax(gfx::Size(min_width_, 0));
     return size;
diff --git a/ash/ime/candidate_window_view.h b/ash/ime/candidate_window_view.h
index 4cbc5b7..99800f8 100644
--- a/ash/ime/candidate_window_view.h
+++ b/ash/ime/candidate_window_view.h
@@ -29,7 +29,7 @@ class ASH_EXPORT CandidateWindowView : public views::BubbleDelegateView,
   };
 
   explicit CandidateWindowView(gfx::NativeView parent);
-  virtual ~CandidateWindowView();
+  ~CandidateWindowView() override;
   views::Widget* InitWidget();
 
   // Adds the given observer. The ownership is not transferred.
@@ -74,8 +74,7 @@ class ASH_EXPORT CandidateWindowView : public views::BubbleDelegateView,
   friend class CandidateWindowViewTest;
 
   // Overridden from views::ButtonListener:
-  virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) override;
+  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
   void SelectCandidateAt(int index_in_page);
   void UpdateVisibility();
diff --git a/ash/ime/candidate_window_view_unittest.cc b/ash/ime/candidate_window_view_unittest.cc
index b0295fe..dd523b5 100644
--- a/ash/ime/candidate_window_view_unittest.cc
+++ b/ash/ime/candidate_window_view_unittest.cc
@@ -65,10 +65,10 @@ void InitCandidateWindowWithCandidatesFilled(
 class CandidateWindowViewTest : public views::ViewsTestBase {
  public:
   CandidateWindowViewTest() {}
-  virtual ~CandidateWindowViewTest() {}
+  ~CandidateWindowViewTest() override {}
 
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     views::ViewsTestBase::SetUp();
     candidate_window_view_ = new CandidateWindowView(GetContext());
     candidate_window_view_->InitWidget();
diff --git a/ash/ime/infolist_window.cc b/ash/ime/infolist_window.cc
index 3467b87..dec8b73 100644
--- a/ash/ime/infolist_window.cc
+++ b/ash/ime/infolist_window.cc
@@ -40,12 +40,12 @@ const int kInfolistHideDelayMilliSeconds = 500;
 class InfolistBorder : public views::BubbleBorder {
  public:
   InfolistBorder();
-  virtual ~InfolistBorder();
+  ~InfolistBorder() override;
 
   // views::BubbleBorder implementation.
-  virtual gfx::Rect GetBounds(const gfx::Rect& anchor_rect,
-                              const gfx::Size& contents_size) const override;
-  virtual gfx::Insets GetInsets() const override;
+  gfx::Rect GetBounds(const gfx::Rect& anchor_rect,
+                      const gfx::Size& contents_size) const override;
+  gfx::Insets GetInsets() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InfolistBorder);
@@ -88,13 +88,13 @@ class InfolistEntryView : public views::View {
   InfolistEntryView(const ui::InfolistEntry& entry,
                     const gfx::FontList& title_font_list,
                     const gfx::FontList& description_font_list);
-  virtual ~InfolistEntryView();
+  ~InfolistEntryView() override;
 
   void SetEntry(const ui::InfolistEntry& entry);
 
  private:
   // views::View implementation.
-  virtual gfx::Size GetPreferredSize() const override;
+  gfx::Size GetPreferredSize() const override;
 
   void UpdateBackground();
 
diff --git a/ash/ime/infolist_window.h b/ash/ime/infolist_window.h
index 345c1a1..535f025 100644
--- a/ash/ime/infolist_window.h
+++ b/ash/ime/infolist_window.h
@@ -26,7 +26,7 @@ class ASH_EXPORT InfolistWindow : public views::BubbleDelegateView {
  public:
   InfolistWindow(views::View* candidate_window,
                  const std::vector<ui::InfolistEntry>& entries);
-  virtual ~InfolistWindow();
+  ~InfolistWindow() override;
   void InitWidget();
 
   // Updates infolist contents with |entries|.
@@ -42,7 +42,7 @@ class ASH_EXPORT InfolistWindow : public views::BubbleDelegateView {
 
  private:
   // views::WidgetDelegate implementation.
-  virtual void WindowClosing() override;
+  void WindowClosing() override;
 
   // The list of visible entries. Owned by views hierarchy.
   std::vector<InfolistEntryView*> entry_views_;
diff --git a/ash/ime/input_method_menu_manager_unittest.cc b/ash/ime/input_method_menu_manager_unittest.cc
index e843cf3..d4a62b1 100644
--- a/ash/ime/input_method_menu_manager_unittest.cc
+++ b/ash/ime/input_method_menu_manager_unittest.cc
@@ -18,11 +18,10 @@ TEST(InputMethodMenuManagerTest, TestGetSingleton) {
 class MockObserver : public InputMethodMenuManager::Observer {
  public:
   MockObserver() : input_method_menu_item_changed_count_(0) {}
-  virtual ~MockObserver() {}
+  ~MockObserver() override {}
 
   // Called when the list of menu items is changed.
-  virtual void InputMethodMenuItemChanged(
-      InputMethodMenuManager* manager) override {
+  void InputMethodMenuItemChanged(InputMethodMenuManager* manager) override {
     input_method_menu_item_changed_count_++;
   }
   int input_method_menu_item_changed_count_;
@@ -32,15 +31,13 @@ class InputMethodMenuManagerStatefulTest : public testing::Test{
  public:
   InputMethodMenuManagerStatefulTest()
       : observer_(new MockObserver()) {}
-  virtual ~InputMethodMenuManagerStatefulTest() {}
-  virtual void SetUp() override {
+  ~InputMethodMenuManagerStatefulTest() override {}
+  void SetUp() override {
     menu_manager_ = InputMethodMenuManager::GetInstance();
     menu_manager_->AddObserver(observer_.get());
   }
 
-  virtual void TearDown() override {
-    menu_manager_->RemoveObserver(observer_.get());
-  }
+  void TearDown() override { menu_manager_->RemoveObserver(observer_.get()); }
 
   InputMethodMenuManager* menu_manager_;
   scoped_ptr<MockObserver> observer_;
diff --git a/ash/ime/mode_indicator_view.cc b/ash/ime/mode_indicator_view.cc
index 9c16b56..c8df071 100644
--- a/ash/ime/mode_indicator_view.cc
+++ b/ash/ime/mode_indicator_view.cc
@@ -28,11 +28,11 @@ class ModeIndicatorFrameView : public views::BubbleFrameView {
  public:
   explicit ModeIndicatorFrameView(const gfx::Insets& content_margins)
       : views::BubbleFrameView(content_margins) {}
-  virtual ~ModeIndicatorFrameView() {}
+  ~ModeIndicatorFrameView() override {}
 
  private:
   // views::BubbleFrameView overrides:
-  virtual gfx::Rect GetAvailableScreenBounds(const gfx::Rect& rect) override {
+  gfx::Rect GetAvailableScreenBounds(const gfx::Rect& rect) override {
     return gfx::Screen::GetNativeScreen()->GetDisplayNearestPoint(
         rect.CenterPoint()).bounds();
   }
diff --git a/ash/ime/mode_indicator_view.h b/ash/ime/mode_indicator_view.h
index b38997b..9e00ceb 100644
--- a/ash/ime/mode_indicator_view.h
+++ b/ash/ime/mode_indicator_view.h
@@ -25,20 +25,20 @@ class ASH_EXPORT ModeIndicatorView : public views::BubbleDelegateView {
   ModeIndicatorView(gfx::NativeView parent,
                     const gfx::Rect& cursor_bounds,
                     const base::string16& label);
-  virtual ~ModeIndicatorView();
+  ~ModeIndicatorView() override;
 
   // Show the mode indicator then hide with fading animation.
   void ShowAndFadeOut();
 
   // views::BubbleDelegateView override:
-  virtual gfx::Size GetPreferredSize() const override;
+  gfx::Size GetPreferredSize() const override;
 
  protected:
   // views::BubbleDelegateView override:
-  virtual void Init() override;
+  void Init() override;
 
   // views::WidgetDelegateView overrides:
-  virtual views::NonClientFrameView* CreateNonClientFrameView(
+  views::NonClientFrameView* CreateNonClientFrameView(
       views::Widget* widget) override;
 
  private:
diff --git a/ash/keyboard_overlay/keyboard_overlay_delegate.cc b/ash/keyboard_overlay/keyboard_overlay_delegate.cc
index 84daf8d..76563f5b 100644
--- a/ash/keyboard_overlay/keyboard_overlay_delegate.cc
+++ b/ash/keyboard_overlay/keyboard_overlay_delegate.cc
@@ -33,10 +33,10 @@ class PaintMessageHandler
       public base::SupportsWeakPtr<PaintMessageHandler> {
  public:
   explicit PaintMessageHandler(views::Widget* widget) : widget_(widget) {}
-  virtual ~PaintMessageHandler() {}
+  ~PaintMessageHandler() override {}
 
   // WebUIMessageHandler implementation.
-  virtual void RegisterMessages() override;
+  void RegisterMessages() override;
 
  private:
   void DidPaint(const base::ListValue* args);
diff --git a/ash/keyboard_overlay/keyboard_overlay_delegate.h b/ash/keyboard_overlay/keyboard_overlay_delegate.h
index d9f8cf2..ef92dea 100644
--- a/ash/keyboard_overlay/keyboard_overlay_delegate.h
+++ b/ash/keyboard_overlay/keyboard_overlay_delegate.h
@@ -29,26 +29,25 @@ class ASH_WITH_CONTENT_EXPORT KeyboardOverlayDelegate
   views::Widget* Show(views::WebDialogView* view);
 
   // Overridden from ui::WebDialogDelegate:
-  virtual void GetDialogSize(gfx::Size* size) const override;
+  void GetDialogSize(gfx::Size* size) const override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(KeyboardOverlayDelegateTest, ShowAndClose);
 
-  virtual ~KeyboardOverlayDelegate();
+  ~KeyboardOverlayDelegate() override;
 
   // Overridden from ui::WebDialogDelegate:
-  virtual ui::ModalType GetDialogModalType() const override;
-  virtual base::string16 GetDialogTitle() const override;
-  virtual GURL GetDialogContentURL() const override;
-  virtual void GetWebUIMessageHandlers(
+  ui::ModalType GetDialogModalType() const override;
+  base::string16 GetDialogTitle() const override;
+  GURL GetDialogContentURL() const override;
+  void GetWebUIMessageHandlers(
       std::vector<content::WebUIMessageHandler*>* handlers) const override;
-  virtual std::string GetDialogArgs() const override;
-  virtual void OnDialogClosed(const std::string& json_retval) override;
-  virtual void OnCloseContents(content::WebContents* source,
-                               bool* out_close_dialog) override;
-  virtual bool ShouldShowDialogTitle() const override;
-  virtual bool HandleContextMenu(
-      const content::ContextMenuParams& params) override;
+  std::string GetDialogArgs() const override;
+  void OnDialogClosed(const std::string& json_retval) override;
+  void OnCloseContents(content::WebContents* source,
+                       bool* out_close_dialog) override;
+  bool ShouldShowDialogTitle() const override;
+  bool HandleContextMenu(const content::ContextMenuParams& params) override;
 
   // The dialog title.
   base::string16 title_;
diff --git a/ash/keyboard_overlay/keyboard_overlay_view.h b/ash/keyboard_overlay/keyboard_overlay_view.h
index 52045b5..d7a473f 100644
--- a/ash/keyboard_overlay/keyboard_overlay_view.h
+++ b/ash/keyboard_overlay/keyboard_overlay_view.h
@@ -38,12 +38,12 @@ class ASH_WITH_CONTENT_EXPORT KeyboardOverlayView
   KeyboardOverlayView(content::BrowserContext* context,
                       ui::WebDialogDelegate* delegate,
                       WebContentsHandler* handler);
-  virtual ~KeyboardOverlayView();
+  ~KeyboardOverlayView() override;
 
   // Overridden from ash::OverlayEventFilter::Delegate:
-  virtual void Cancel() override;
-  virtual bool IsCancelingKeyEvent(ui::KeyEvent* event) override;
-  virtual aura::Window* GetWindow() override;
+  void Cancel() override;
+  bool IsCancelingKeyEvent(ui::KeyEvent* event) override;
+  aura::Window* GetWindow() override;
 
   // Shows the keyboard overlay.
   static void ShowDialog(content::BrowserContext* context,
@@ -55,7 +55,7 @@ class ASH_WITH_CONTENT_EXPORT KeyboardOverlayView
   FRIEND_TEST_ALL_PREFIXES(KeyboardOverlayViewTest, NoRedundantCancelingKeys);
 
   // Overridden from views::WidgetDelegate:
-  virtual void WindowClosing() override;
+  void WindowClosing() override;
 
   static void GetCancelingKeysForTesting(
       std::vector<KeyEventData>* canceling_keys);
diff --git a/ash/keyboard_uma_event_filter.h b/ash/keyboard_uma_event_filter.h
index 0928e7f..494ff66 100644
--- a/ash/keyboard_uma_event_filter.h
+++ b/ash/keyboard_uma_event_filter.h
@@ -17,10 +17,10 @@ namespace ash {
 class KeyboardUMAEventFilter : public ui::EventHandler {
  public:
   KeyboardUMAEventFilter();
-  virtual ~KeyboardUMAEventFilter();
+  ~KeyboardUMAEventFilter() override;
 
   // ui::EventHandler overrides:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnKeyEvent(ui::KeyEvent* event) override;
 
  private:
   // The timestamp of the last character keystroke.
diff --git a/ash/magnifier/magnification_controller.cc b/ash/magnifier/magnification_controller.cc
index 144b605..f43154f 100644
--- a/ash/magnifier/magnification_controller.cc
+++ b/ash/magnifier/magnification_controller.cc
@@ -75,34 +75,34 @@ class MagnificationControllerImpl : virtual public MagnificationController,
                                     public ui::InputMethodObserver {
  public:
   MagnificationControllerImpl();
-  virtual ~MagnificationControllerImpl();
+  ~MagnificationControllerImpl() override;
 
   // MagnificationController overrides:
-  virtual void SetEnabled(bool enabled) override;
-  virtual bool IsEnabled() const override;
-  virtual void SetScale(float scale, bool animate) override;
-  virtual float GetScale() const override { return scale_; }
-  virtual void MoveWindow(int x, int y, bool animate) override;
-  virtual void MoveWindow(const gfx::Point& point, bool animate) override;
-  virtual gfx::Point GetWindowPosition() const override {
+  void SetEnabled(bool enabled) override;
+  bool IsEnabled() const override;
+  void SetScale(float scale, bool animate) override;
+  float GetScale() const override { return scale_; }
+  void MoveWindow(int x, int y, bool animate) override;
+  void MoveWindow(const gfx::Point& point, bool animate) override;
+  gfx::Point GetWindowPosition() const override {
     return gfx::ToFlooredPoint(origin_);
   }
-  virtual void SetScrollDirection(ScrollDirection direction) override;
+  void SetScrollDirection(ScrollDirection direction) override;
 
   // For test
-  virtual gfx::Point GetPointOfInterestForTesting() override {
+  gfx::Point GetPointOfInterestForTesting() override {
     return point_of_interest_;
   }
 
  private:
   // ui::ImplicitAnimationObserver overrides:
-  virtual void OnImplicitAnimationsCompleted() override;
+  void OnImplicitAnimationsCompleted() override;
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowDestroying(aura::Window* root_window) override;
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
+  void OnWindowDestroying(aura::Window* root_window) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
 
   // Redraws the magnification window with the given origin position and the
   // given scale. Returns true if the window is changed; otherwise, false.
@@ -149,9 +149,9 @@ class MagnificationControllerImpl : virtual public MagnificationController,
   void ValidateScale(float* scale);
 
   // ui::EventHandler overrides:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
-  virtual void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Moves the view port when |point| is located within
   // |x_panning_margin| and |y_pannin_margin| to the edge of the visible
@@ -165,16 +165,13 @@ class MagnificationControllerImpl : virtual public MagnificationController,
                            int y_target_margin);
 
   // ui::InputMethodObserver:
-  virtual void OnTextInputTypeChanged(
-      const ui::TextInputClient* client) override {}
-  virtual void OnFocus() override {}
-  virtual void OnBlur() override {}
-  virtual void OnTextInputStateChanged(
-      const ui::TextInputClient* client) override {}
-  virtual void OnInputMethodDestroyed(
-      const ui::InputMethod* input_method) override {}
-  virtual void OnShowImeIfNeeded() override {}
-  virtual void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
+  void OnTextInputTypeChanged(const ui::TextInputClient* client) override {}
+  void OnFocus() override {}
+  void OnBlur() override {}
+  void OnTextInputStateChanged(const ui::TextInputClient* client) override {}
+  void OnInputMethodDestroyed(const ui::InputMethod* input_method) override {}
+  void OnShowImeIfNeeded() override {}
+  void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
 
   // Target root window. This must not be NULL.
   aura::Window* root_window_;
diff --git a/ash/magnifier/partial_magnification_controller.h b/ash/magnifier/partial_magnification_controller.h
index f78f52b..7c73685 100644
--- a/ash/magnifier/partial_magnification_controller.h
+++ b/ash/magnifier/partial_magnification_controller.h
@@ -23,7 +23,7 @@ class PartialMagnificationController
     public views::WidgetObserver {
  public:
   PartialMagnificationController();
-  virtual ~PartialMagnificationController();
+  ~PartialMagnificationController() override;
 
   // Enables (or disables if |enabled| is false) partial screen magnifier
   // feature.
@@ -63,13 +63,13 @@ class PartialMagnificationController
   void RemoveZoomWidgetObservers();
 
   // ui::EventHandler overrides:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
 
   // Overridden from WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowDestroying(aura::Window* window) override;
 
   // Overridden from WidgetObserver:
-  virtual void OnWidgetDestroying(views::Widget* widget) override;
+  void OnWidgetDestroying(views::Widget* widget) override;
 
   // True if the magnified window is in motion of zooming or un-zooming effect.
   // Otherwise, false.
diff --git a/ash/popup_message.cc b/ash/popup_message.cc
index 14aad63..aa80b07 100644
--- a/ash/popup_message.cc
+++ b/ash/popup_message.cc
@@ -54,7 +54,7 @@ class PopupMessage::MessageBubble : public views::BubbleDelegateView {
 
  private:
   // views::View overrides:
-  virtual gfx::Size GetPreferredSize() const override;
+  gfx::Size GetPreferredSize() const override;
 
   // Each component (width/height) can force a size override for that component
   // if not 0.
diff --git a/ash/root_window_controller.cc b/ash/root_window_controller.cc
index a8ba722..68e15ab 100644
--- a/ash/root_window_controller.cc
+++ b/ash/root_window_controller.cc
@@ -213,50 +213,33 @@ void SetUsesEasyResizeTargeter(aura::Window* container) {
 class EmptyWindowDelegate : public aura::WindowDelegate {
  public:
   EmptyWindowDelegate() {}
-  virtual ~EmptyWindowDelegate() {}
+  ~EmptyWindowDelegate() override {}
 
   // aura::WindowDelegate overrides:
-  virtual gfx::Size GetMinimumSize() const override {
-    return gfx::Size();
-  }
-  virtual gfx::Size GetMaximumSize() const override {
-    return gfx::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 gfx::Size(); }
+  gfx::Size GetMaximumSize() const override { return gfx::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 {
-  }
-  virtual void OnDeviceScaleFactorChanged(
-      float device_scale_factor) override {
-  }
-  virtual void OnWindowDestroying(aura::Window* window) override {}
-  virtual void OnWindowDestroyed(aura::Window* window) override {
-    delete this;
-  }
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
-  }
-  virtual bool HasHitTestMask() const override {
-    return false;
-  }
-  virtual void GetHitTestMask(gfx::Path* mask) const override {}
+  bool CanFocus() override { return false; }
+  void OnCaptureLost() override {}
+  void OnPaint(gfx::Canvas* canvas) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  void OnWindowDestroying(aura::Window* window) override {}
+  void OnWindowDestroyed(aura::Window* window) override { delete this; }
+  void OnWindowTargetVisibilityChanged(bool visible) override {}
+  bool HasHitTestMask() const override { return false; }
+  void GetHitTestMask(gfx::Path* mask) const override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EmptyWindowDelegate);
diff --git a/ash/root_window_controller.h b/ash/root_window_controller.h
index 0b79b20..1494c96f 100644
--- a/ash/root_window_controller.h
+++ b/ash/root_window_controller.h
@@ -105,7 +105,7 @@ class ASH_EXPORT RootWindowController : public ShellObserver {
   // Returns container which contains a given |window|.
   static aura::Window* GetContainerForWindow(aura::Window* window);
 
-  virtual ~RootWindowController();
+  ~RootWindowController() override;
 
   AshWindowTreeHost* ash_host() { return ash_host_.get(); }
   const AshWindowTreeHost* ash_host() const { return ash_host_.get(); }
@@ -267,8 +267,8 @@ class ASH_EXPORT RootWindowController : public ShellObserver {
   void DisableTouchHudProjection();
 
   // Overridden from ShellObserver.
-  virtual void OnLoginStateChanged(user::LoginStatus status) override;
-  virtual void OnTouchHudProjectionToggled(bool enabled) override;
+  void OnLoginStateChanged(user::LoginStatus status) override;
+  void OnTouchHudProjectionToggled(bool enabled) override;
 
   scoped_ptr<AshWindowTreeHost> ash_host_;
   RootWindowLayoutManager* root_window_layout_;
diff --git a/ash/root_window_controller_unittest.cc b/ash/root_window_controller_unittest.cc
index 4d7a086..28999b6 100644
--- a/ash/root_window_controller_unittest.cc
+++ b/ash/root_window_controller_unittest.cc
@@ -48,14 +48,12 @@ namespace {
 class TestDelegate : public views::WidgetDelegateView {
  public:
   explicit TestDelegate(bool system_modal) : system_modal_(system_modal) {}
-  virtual ~TestDelegate() {}
+  ~TestDelegate() override {}
 
   // Overridden from views::WidgetDelegate:
-  virtual views::View* GetContentsView() override {
-    return this;
-  }
+  views::View* GetContentsView() override { return this; }
 
-  virtual ui::ModalType GetModalType() const override {
+  ui::ModalType GetModalType() const override {
     return system_modal_ ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE;
   }
 
@@ -69,7 +67,7 @@ class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate,
                              public aura::client::FocusChangeObserver {
  public:
   DeleteOnBlurDelegate() : window_(NULL) {}
-  virtual ~DeleteOnBlurDelegate() {}
+  ~DeleteOnBlurDelegate() override {}
 
   void SetWindow(aura::Window* window) {
     window_ = window;
@@ -78,13 +76,11 @@ class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate,
 
  private:
   // aura::test::TestWindowDelegate overrides:
-  virtual bool CanFocus() override {
-    return true;
-  }
+  bool CanFocus() override { return true; }
 
   // aura::client::FocusChangeObserver implementation:
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     if (window_ == lost_focus)
       delete window_;
   }
@@ -526,9 +522,7 @@ TEST_F(RootWindowControllerTest, FocusBlockedWindow) {
 class DestroyedWindowObserver : public aura::WindowObserver {
  public:
   DestroyedWindowObserver() : destroyed_(false), window_(NULL) {}
-  virtual ~DestroyedWindowObserver() {
-    Shutdown();
-  }
+  ~DestroyedWindowObserver() override { Shutdown(); }
 
   void SetWindow(Window* window) {
     window_ = window;
@@ -538,7 +532,7 @@ class DestroyedWindowObserver : public aura::WindowObserver {
   bool destroyed() const { return destroyed_; }
 
   // WindowObserver overrides:
-  virtual void OnWindowDestroying(Window* window) override {
+  void OnWindowDestroying(Window* window) override {
     destroyed_ = true;
     Shutdown();
   }
@@ -614,10 +608,10 @@ TEST_F(NoSessionRootWindowControllerTest, Event) {
 class VirtualKeyboardRootWindowControllerTest
     : public RootWindowControllerTest {
  public:
-  VirtualKeyboardRootWindowControllerTest() {};
-  virtual ~VirtualKeyboardRootWindowControllerTest() {};
+  VirtualKeyboardRootWindowControllerTest() {}
+  ~VirtualKeyboardRootWindowControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         keyboard::switches::kEnableVirtualKeyboard);
     test::AshTestBase::SetUp();
@@ -634,7 +628,7 @@ class MockTextInputClient : public ui::DummyTextInputClient {
   MockTextInputClient() :
       ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
 
-  virtual void EnsureCaretInRect(const gfx::Rect& rect) override {
+  void EnsureCaretInRect(const gfx::Rect& rect) override {
     visible_rect_ = rect;
   }
 
@@ -653,7 +647,7 @@ class TargetHitTestEventHandler : public ui::test::TestEventHandler {
   TargetHitTestEventHandler() {}
 
   // ui::test::TestEventHandler overrides.
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_PRESSED)
       ui::test::TestEventHandler::OnMouseEvent(event);
     event->StopPropagation();
diff --git a/ash/rotator/screen_rotation.h b/ash/rotator/screen_rotation.h
index 500f6c3..360e53b 100644
--- a/ash/rotator/screen_rotation.h
+++ b/ash/rotator/screen_rotation.h
@@ -31,7 +31,7 @@ class ASH_EXPORT ScreenRotation : public ui::LayerAnimationElement {
   // |degrees| are clockwise. |layer| is the target of the animation. Does not
   // take ownership of |layer|.
   ScreenRotation(int degrees, ui::Layer* layer);
-  virtual ~ScreenRotation();
+  ~ScreenRotation() override;
 
  private:
   // Generates the intermediate transformation matrices used during the
@@ -39,11 +39,10 @@ class ASH_EXPORT ScreenRotation : public ui::LayerAnimationElement {
   void InitTransform(ui::Layer* layer);
 
   // Implementation of ui::LayerAnimationDelegate
-  virtual void OnStart(ui::LayerAnimationDelegate* delegate) override;
-  virtual bool OnProgress(double t,
-                          ui::LayerAnimationDelegate* delegate) override;
-  virtual void OnGetTarget(TargetValue* target) const override;
-  virtual void OnAbort(ui::LayerAnimationDelegate* delegate) override;
+  void OnStart(ui::LayerAnimationDelegate* delegate) override;
+  bool OnProgress(double t, ui::LayerAnimationDelegate* delegate) override;
+  void OnGetTarget(TargetValue* target) const override;
+  void OnAbort(ui::LayerAnimationDelegate* delegate) override;
 
   scoped_ptr<ui::InterpolatedTransform> interpolated_transform_;
 
diff --git a/ash/screensaver/screensaver_view.h b/ash/screensaver/screensaver_view.h
index 2a5bf6e..3fb2cdf 100644
--- a/ash/screensaver/screensaver_view.h
+++ b/ash/screensaver/screensaver_view.h
@@ -47,13 +47,13 @@ class ScreensaverView : public views::WidgetDelegateView,
   friend class test::ScreensaverViewTest;
 
   explicit ScreensaverView(const GURL& url);
-  virtual ~ScreensaverView();
+  ~ScreensaverView() override;
 
   // views::WidgetDelegate overrides.
-  virtual views::View* GetContentsView() override;
+  views::View* GetContentsView() override;
 
   // content::WebContentsObserver overrides.
-  virtual void RenderProcessGone(base::TerminationStatus status) override;
+  void RenderProcessGone(base::TerminationStatus status) override;
 
   void Show();
   void Close();
diff --git a/ash/screensaver/screensaver_view_unittest.cc b/ash/screensaver/screensaver_view_unittest.cc
index 4fb096c..305300b 100644
--- a/ash/screensaver/screensaver_view_unittest.cc
+++ b/ash/screensaver/screensaver_view_unittest.cc
@@ -21,9 +21,9 @@ class ScreensaverViewTest : public ash::test::AshTestBase {
     webview_test_helper_.reset(new views::WebViewTestHelper());
   }
 
-  virtual ~ScreensaverViewTest() {}
+  ~ScreensaverViewTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     RunAllPendingInMessageLoop();
   }
diff --git a/ash/shell.cc b/ash/shell.cc
index 83b0406..73bfb99 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -155,13 +155,12 @@ using views::Widget;
 class AshVisibilityController : public ::wm::VisibilityController {
  public:
   AshVisibilityController() {}
-  virtual ~AshVisibilityController() {}
+  ~AshVisibilityController() override {}
 
  private:
   // Overridden from ::wm::VisibilityController:
-  virtual bool CallAnimateOnChildWindowVisibilityChanged(
-      aura::Window* window,
-      bool visible) override {
+  bool CallAnimateOnChildWindowVisibilityChanged(aura::Window* window,
+                                                 bool visible) override {
     return AnimateOnChildWindowVisibilityChanged(window, visible);
   }
 
diff --git a/ash/shell.h b/ash/shell.h
index 9e6e046..ea2382c 100644
--- a/ash/shell.h
+++ b/ash/shell.h
@@ -589,7 +589,7 @@ class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate,
 
   // Takes ownership of |delegate|.
   explicit Shell(ShellDelegate* delegate);
-  virtual ~Shell();
+  ~Shell() override;
 
   void Init(const ShellInitParams& init_params);
 
@@ -600,18 +600,18 @@ class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate,
   void InitRootWindow(aura::Window* root_window);
 
   // ash::SystemModalContainerEventFilterDelegate overrides:
-  virtual bool CanWindowReceiveEvents(aura::Window* window) override;
+  bool CanWindowReceiveEvents(aura::Window* window) override;
 
   // Overridden from ui::EventTarget:
-  virtual bool CanAcceptEvent(const ui::Event& event) override;
-  virtual EventTarget* GetParentTarget() override;
-  virtual scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
-  virtual ui::EventTargeter* GetEventTargeter() override;
-  virtual void OnEvent(ui::Event* event) override;
+  bool CanAcceptEvent(const ui::Event& event) override;
+  EventTarget* GetParentTarget() override;
+  scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
+  ui::EventTargeter* GetEventTargeter() override;
+  void OnEvent(ui::Event* event) override;
 
   // 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;
 
   static Shell* instance_;
 
diff --git a/ash/shell_unittest.cc b/ash/shell_unittest.cc
index 160d295..ab09f9a 100644
--- a/ash/shell_unittest.cc
+++ b/ash/shell_unittest.cc
@@ -92,21 +92,15 @@ void ExpectAllContainers() {
 class ModalWindow : public views::WidgetDelegateView {
  public:
   ModalWindow() {}
-  virtual ~ModalWindow() {}
+  ~ModalWindow() override {}
 
   // Overridden from views::WidgetDelegate:
-  virtual views::View* GetContentsView() override {
-    return this;
-  }
-  virtual bool CanResize() const override {
-    return true;
-  }
-  virtual base::string16 GetWindowTitle() const override {
+  views::View* GetContentsView() override { return this; }
+  bool CanResize() const override { return true; }
+  base::string16 GetWindowTitle() const override {
     return base::ASCIIToUTF16("Modal Window");
   }
-  virtual ui::ModalType GetModalType() const override {
-    return ui::MODAL_TYPE_SYSTEM;
-  }
+  ui::ModalType GetModalType() const override { return ui::MODAL_TYPE_SYSTEM; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ModalWindow);
@@ -115,24 +109,18 @@ class ModalWindow : public views::WidgetDelegateView {
 class SimpleMenuDelegate : public ui::SimpleMenuModel::Delegate {
  public:
   SimpleMenuDelegate() {}
-  virtual ~SimpleMenuDelegate() {}
+  ~SimpleMenuDelegate() override {}
 
-  virtual bool IsCommandIdChecked(int command_id) const override {
-    return false;
-  }
+  bool IsCommandIdChecked(int command_id) const override { return false; }
 
-  virtual bool IsCommandIdEnabled(int command_id) const override {
-    return true;
-  }
+  bool IsCommandIdEnabled(int command_id) const override { return true; }
 
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) override {
+  bool GetAcceleratorForCommandId(int command_id,
+                                  ui::Accelerator* accelerator) override {
     return false;
   }
 
-  virtual void ExecuteCommand(int command_id, int event_flags) override {
-  }
+  void ExecuteCommand(int command_id, int event_flags) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleMenuDelegate);
@@ -279,9 +267,7 @@ class TestModalDialogDelegate : public views::DialogDelegateView {
   TestModalDialogDelegate() {}
 
   // Overridden from views::WidgetDelegate:
-  virtual ui::ModalType GetModalType() const override {
-    return ui::MODAL_TYPE_SYSTEM;
-  }
+  ui::ModalType GetModalType() const override { return ui::MODAL_TYPE_SYSTEM; }
 };
 
 TEST_F(ShellTest, CreateLockScreenModalWindow) {
@@ -525,7 +511,7 @@ TEST_F(ShellTest, EnvPreTargetHandler) {
 class ShellTest2 : public test::AshTestBase {
  public:
   ShellTest2() {}
-  virtual ~ShellTest2() {}
+  ~ShellTest2() override {}
 
  protected:
   scoped_ptr<aura::Window> window_;
diff --git a/ash/snap_to_pixel_layout_manager.h b/ash/snap_to_pixel_layout_manager.h
index 21abe8e..a5233d4 100644
--- a/ash/snap_to_pixel_layout_manager.h
+++ b/ash/snap_to_pixel_layout_manager.h
@@ -16,18 +16,18 @@ namespace ash {
 class ASH_EXPORT SnapToPixelLayoutManager : public aura::LayoutManager {
  public:
   explicit SnapToPixelLayoutManager(aura::Window* container);
-  virtual ~SnapToPixelLayoutManager();
+  ~SnapToPixelLayoutManager() override;
 
  protected:
   // 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;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SnapToPixelLayoutManager);
diff --git a/ash/sticky_keys/sticky_keys_overlay.cc b/ash/sticky_keys/sticky_keys_overlay.cc
index 1b0fb5d..0766ba25 100644
--- a/ash/sticky_keys/sticky_keys_overlay.cc
+++ b/ash/sticky_keys/sticky_keys_overlay.cc
@@ -47,7 +47,7 @@ class StickyKeyOverlayLabel : public views::Label {
  public:
   explicit StickyKeyOverlayLabel(const std::string& key_name);
 
-  virtual ~StickyKeyOverlayLabel();
+  ~StickyKeyOverlayLabel() override;
 
   StickyKeyState state() const { return state_; }
 
@@ -105,10 +105,10 @@ class StickyKeysOverlayView : public views::WidgetDelegateView {
  public:
   StickyKeysOverlayView();
 
-  virtual ~StickyKeysOverlayView();
+  ~StickyKeysOverlayView() override;
 
   // views::WidgetDelegateView overrides:
-  virtual void OnPaint(gfx::Canvas* canvas) override;
+  void OnPaint(gfx::Canvas* canvas) override;
 
   void SetKeyState(ui::EventFlags modifier, StickyKeyState state);
 
diff --git a/ash/sticky_keys/sticky_keys_overlay.h b/ash/sticky_keys/sticky_keys_overlay.h
index 34ea266c..6391794 100644
--- a/ash/sticky_keys/sticky_keys_overlay.h
+++ b/ash/sticky_keys/sticky_keys_overlay.h
@@ -31,7 +31,7 @@ class StickyKeysOverlayView;
 class ASH_EXPORT StickyKeysOverlay : public ui::LayerAnimationObserver {
  public:
   StickyKeysOverlay();
-  virtual ~StickyKeysOverlay();
+  ~StickyKeysOverlay() override;
 
   // Shows or hides the overlay.
   void Show(bool visible);
@@ -56,12 +56,9 @@ class ASH_EXPORT StickyKeysOverlay : public ui::LayerAnimationObserver {
   gfx::Rect CalculateOverlayBounds();
 
   // gfx::LayerAnimationObserver overrides:
-  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;
 
   bool is_visible_;
   scoped_ptr<views::Widget> overlay_widget_;
diff --git a/ash/tooltips/tooltip_controller_unittest.cc b/ash/tooltips/tooltip_controller_unittest.cc
index 54b6271..8240185 100644
--- a/ash/tooltips/tooltip_controller_unittest.cc
+++ b/ash/tooltips/tooltip_controller_unittest.cc
@@ -74,9 +74,9 @@ TooltipController* GetController() {
 class TooltipControllerTest : public AshTestBase {
  public:
   TooltipControllerTest() {}
-  virtual ~TooltipControllerTest() {}
+  ~TooltipControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     helper_.reset(new TooltipControllerTestHelper(GetController()));
   }
diff --git a/ash/touch/touch_hud_debug.cc b/ash/touch/touch_hud_debug.cc
index b714edf..c7212cf 100644
--- a/ash/touch/touch_hud_debug.cc
+++ b/ash/touch/touch_hud_debug.cc
@@ -257,7 +257,7 @@ class TouchHudCanvas : public views::View {
     paint_.setStyle(SkPaint::kFill_Style);
   }
 
-  virtual ~TouchHudCanvas() {}
+  ~TouchHudCanvas() override {}
 
   void SetScale(int scale) {
     if (scale_ == scale)
@@ -308,7 +308,7 @@ class TouchHudCanvas : public views::View {
   }
 
   // Overridden from views::View.
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     for (int i = 0; i < kMaxPaths; ++i) {
       if (paths_[i].countPoints() == 0)
         continue;
diff --git a/ash/touch/touch_hud_debug.h b/ash/touch/touch_hud_debug.h
index 9409243..547ab27 100644
--- a/ash/touch/touch_hud_debug.h
+++ b/ash/touch/touch_hud_debug.h
@@ -49,22 +49,21 @@ class ASH_EXPORT TouchHudDebug : public TouchObserverHUD {
   Mode mode() const { return mode_; }
 
   // Overriden from TouchObserverHUD.
-  virtual void Clear() override;
+  void Clear() override;
 
  private:
-  virtual ~TouchHudDebug();
+  ~TouchHudDebug() override;
 
   void SetMode(Mode mode);
 
   void UpdateTouchPointLabel(int index);
 
   // Overriden from TouchObserverHUD.
-  virtual void OnTouchEvent(ui::TouchEvent* event) override;
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) override;
-  virtual void SetHudForRootWindowController(
-      RootWindowController* controller) override;
-  virtual void UnsetHudForRootWindowController(
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t metrics) override;
+  void SetHudForRootWindowController(RootWindowController* controller) override;
+  void UnsetHudForRootWindowController(
       RootWindowController* controller) override;
 
   static const int kMaxTouchPoints = 32;
diff --git a/ash/touch/touch_hud_projection.cc b/ash/touch/touch_hud_projection.cc
index 990345e..47fab8d 100644
--- a/ash/touch/touch_hud_projection.cc
+++ b/ash/touch/touch_hud_projection.cc
@@ -72,13 +72,13 @@ class TouchPointView : public views::View,
   }
 
  private:
-  virtual ~TouchPointView() {
+  ~TouchPointView() override {
     GetWidget()->RemoveObserver(this);
     parent()->RemoveChildView(this);
   }
 
   // Overridden from views::View.
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     int alpha = kProjectionAlpha;
     if (fadeout_)
       alpha = static_cast<int>(fadeout_->CurrentValueBetween(alpha, 0));
@@ -100,22 +100,22 @@ class TouchPointView : public views::View,
   }
 
   // Overridden from gfx::AnimationDelegate.
-  virtual void AnimationEnded(const gfx::Animation* animation) override {
+  void AnimationEnded(const gfx::Animation* animation) override {
     DCHECK_EQ(fadeout_.get(), animation);
     delete this;
   }
 
-  virtual void AnimationProgressed(const gfx::Animation* animation) override {
+  void AnimationProgressed(const gfx::Animation* animation) override {
     DCHECK_EQ(fadeout_.get(), animation);
     SchedulePaint();
   }
 
-  virtual void AnimationCanceled(const gfx::Animation* animation) override {
+  void AnimationCanceled(const gfx::Animation* animation) override {
     AnimationEnded(animation);
   }
 
   // Overridden from views::WidgetObserver.
-  virtual void OnWidgetDestroying(views::Widget* widget) override {
+  void OnWidgetDestroying(views::Widget* widget) override {
     if (fadeout_)
       fadeout_->Stop();
     else
diff --git a/ash/touch/touch_hud_projection.h b/ash/touch/touch_hud_projection.h
index cde756d..2394976 100644
--- a/ash/touch/touch_hud_projection.h
+++ b/ash/touch/touch_hud_projection.h
@@ -19,18 +19,17 @@ class TouchHudProjection : public TouchObserverHUD {
   explicit TouchHudProjection(aura::Window* initial_root);
 
   // Overriden from TouchObserverHUD.
-  virtual void Clear() override;
+  void Clear() override;
 
  private:
   friend class TouchHudProjectionTest;
 
-  virtual ~TouchHudProjection();
+  ~TouchHudProjection() override;
 
   // Overriden from TouchObserverHUD.
-  virtual void OnTouchEvent(ui::TouchEvent* event) override;
-  virtual void SetHudForRootWindowController(
-      RootWindowController* controller) override;
-  virtual void UnsetHudForRootWindowController(
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  void SetHudForRootWindowController(RootWindowController* controller) override;
+  void UnsetHudForRootWindowController(
       RootWindowController* controller) override;
 
   std::map<int, TouchPointView*> points_;
diff --git a/ash/touch/touch_observer_hud.h b/ash/touch/touch_observer_hud.h
index 329d7dc..e168e9f 100644
--- a/ash/touch/touch_observer_hud.h
+++ b/ash/touch/touch_observer_hud.h
@@ -43,7 +43,7 @@ class ASH_EXPORT TouchObserverHUD : public ui::EventHandler,
  protected:
   explicit TouchObserverHUD(aura::Window* initial_root);
 
-  virtual ~TouchObserverHUD();
+  ~TouchObserverHUD() override;
 
   virtual void SetHudForRootWindowController(
       RootWindowController* controller) = 0;
@@ -53,16 +53,16 @@ class ASH_EXPORT TouchObserverHUD : public ui::EventHandler,
   views::Widget* widget() { return widget_; }
 
   // Overriden from ui::EventHandler.
-  virtual void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Overridden from views::WidgetObserver.
-  virtual void OnWidgetDestroying(views::Widget* widget) override;
+  void OnWidgetDestroying(views::Widget* widget) override;
 
   // Overridden from gfx::DisplayObserver.
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override;
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override;
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) override;
+  void OnDisplayAdded(const gfx::Display& new_display) override;
+  void OnDisplayRemoved(const gfx::Display& old_display) override;
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t metrics) override;
 
 #if defined(OS_CHROMEOS)
   // Overriden from ui::DisplayConfigurator::Observer.
@@ -71,9 +71,9 @@ class ASH_EXPORT TouchObserverHUD : public ui::EventHandler,
 #endif  // defined(OS_CHROMEOS)
 
   // Overriden form DisplayController::Observer.
-  virtual void OnDisplaysInitialized() override;
-  virtual void OnDisplayConfigurationChanging() override;
-  virtual void OnDisplayConfigurationChanged() override;
+  void OnDisplaysInitialized() override;
+  void OnDisplayConfigurationChanging() override;
+  void OnDisplayConfigurationChanged() override;
 
  private:
   friend class TouchHudTestBase;
diff --git a/ash/touch/touch_observer_hud_unittest.cc b/ash/touch/touch_observer_hud_unittest.cc
index 77bfa3c..4955214 100644
--- a/ash/touch/touch_observer_hud_unittest.cc
+++ b/ash/touch/touch_observer_hud_unittest.cc
@@ -24,9 +24,9 @@ namespace ash {
 class TouchHudTestBase : public test::AshTestBase {
  public:
   TouchHudTestBase() {}
-  virtual ~TouchHudTestBase() {}
+  ~TouchHudTestBase() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
 
     // Initialize display infos. They should be initialized after Ash
@@ -212,9 +212,9 @@ class TouchHudTestBase : public test::AshTestBase {
 class TouchHudDebugTest : public TouchHudTestBase {
  public:
   TouchHudDebugTest() {}
-  virtual ~TouchHudDebugTest() {}
+  ~TouchHudDebugTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     // Add ash-touch-hud flag to enable debug touch HUD. This flag should be set
     // before Ash environment is set up, i.e., before TouchHudTestBase::SetUp().
     CommandLine::ForCurrentProcess()->AppendSwitch(
@@ -272,7 +272,7 @@ class TouchHudDebugTest : public TouchHudTestBase {
 class TouchHudProjectionTest : public TouchHudTestBase {
  public:
   TouchHudProjectionTest() {}
-  virtual ~TouchHudProjectionTest() {}
+  ~TouchHudProjectionTest() override {}
 
   void EnableTouchHudProjection() {
     Shell::GetInstance()->SetTouchHudProjectionEnabled(true);
diff --git a/ash/virtual_keyboard_controller.h b/ash/virtual_keyboard_controller.h
index ebbc0fd..b2788cc 100644
--- a/ash/virtual_keyboard_controller.h
+++ b/ash/virtual_keyboard_controller.h
@@ -14,11 +14,11 @@ namespace ash {
 class ASH_EXPORT VirtualKeyboardController : public ShellObserver {
  public:
   VirtualKeyboardController();
-  virtual ~VirtualKeyboardController();
+  ~VirtualKeyboardController() override;
 
   // ShellObserver:
-  virtual void OnMaximizeModeStarted() override;
-  virtual void OnMaximizeModeEnded() override;
+  void OnMaximizeModeStarted() override;
+  void OnMaximizeModeEnded() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardController);