replace OVERRIDE and FINAL with override and final in ui/

BUG=417463

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

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

39 files changed, 235 insertions, 235 deletions

diff --git a/ui/wm/core/accelerator_filter.h b/ui/wm/core/accelerator_filter.h
index 4e5295e..0ac7605 100644
--- a/ui/wm/core/accelerator_filter.h
+++ b/ui/wm/core/accelerator_filter.h
@@ -25,7 +25,7 @@ class WM_EXPORT AcceleratorFilter : public ui::EventHandler {
   virtual ~AcceleratorFilter();
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
 
  private:
   scoped_ptr<AcceleratorDelegate> delegate_;
diff --git a/ui/wm/core/base_focus_rules.h b/ui/wm/core/base_focus_rules.h
index 07dfb65..8073541 100644
--- a/ui/wm/core/base_focus_rules.h
+++ b/ui/wm/core/base_focus_rules.h
@@ -26,15 +26,15 @@ class WM_EXPORT BaseFocusRules : public FocusRules {
       aura::Window* window) const;
 
   // Overridden from FocusRules:
-  virtual bool IsToplevelWindow(aura::Window* window) const OVERRIDE;
-  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE;
-  virtual bool CanFocusWindow(aura::Window* window) const OVERRIDE;
-  virtual aura::Window* GetToplevelWindow(aura::Window* window) const OVERRIDE;
+  virtual bool IsToplevelWindow(aura::Window* window) const override;
+  virtual bool CanActivateWindow(aura::Window* window) const override;
+  virtual bool CanFocusWindow(aura::Window* window) const override;
+  virtual aura::Window* GetToplevelWindow(aura::Window* window) const override;
   virtual aura::Window* GetActivatableWindow(
-      aura::Window* window) const OVERRIDE;
-  virtual aura::Window* GetFocusableWindow(aura::Window* window) const OVERRIDE;
+      aura::Window* window) const override;
+  virtual aura::Window* GetFocusableWindow(aura::Window* window) const override;
   virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const OVERRIDE;
+      aura::Window* ignore) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BaseFocusRules);
diff --git a/ui/wm/core/capture_controller.h b/ui/wm/core/capture_controller.h
index d802818..230ea50 100644
--- a/ui/wm/core/capture_controller.h
+++ b/ui/wm/core/capture_controller.h
@@ -29,10 +29,10 @@ class WM_EXPORT CaptureController : public aura::client::CaptureClient {
   bool is_active() const { return !root_windows_.empty(); }
 
   // Overridden from aura::client::CaptureClient:
-  virtual void SetCapture(aura::Window* window) OVERRIDE;
-  virtual void ReleaseCapture(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetCaptureWindow() OVERRIDE;
-  virtual aura::Window* GetGlobalCaptureWindow() OVERRIDE;
+  virtual void SetCapture(aura::Window* window) override;
+  virtual void ReleaseCapture(aura::Window* window) override;
+  virtual aura::Window* GetCaptureWindow() override;
+  virtual aura::Window* GetGlobalCaptureWindow() override;
 
  private:
   friend class ScopedCaptureClient;
@@ -66,7 +66,7 @@ class WM_EXPORT ScopedCaptureClient : public aura::WindowObserver {
   }
 
   // Overridden from aura::WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+  virtual void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   // Invoked from destructor and OnWindowDestroyed() to cleanup.
diff --git a/ui/wm/core/compound_event_filter.h b/ui/wm/core/compound_event_filter.h
index ab4fdf8..a7767f3 100644
--- a/ui/wm/core/compound_event_filter.h
+++ b/ui/wm/core/compound_event_filter.h
@@ -73,11 +73,11 @@ class WM_EXPORT CompoundEventFilter : public ui::EventHandler {
                                         bool enable);
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
+  virtual void OnTouchEvent(ui::TouchEvent* event) override;
+  virtual void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Additional pre-target event handlers.
   ObserverList<ui::EventHandler, true> handlers_;
diff --git a/ui/wm/core/compound_event_filter_unittest.cc b/ui/wm/core/compound_event_filter_unittest.cc
index 85282fc..05f75e9 100644
--- a/ui/wm/core/compound_event_filter_unittest.cc
+++ b/ui/wm/core/compound_event_filter_unittest.cc
@@ -39,7 +39,7 @@ class ConsumeGestureEventFilter : public ui::EventHandler {
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* e) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* e) override {
     e->StopPropagation();
   }
 
diff --git a/ui/wm/core/cursor_manager.h b/ui/wm/core/cursor_manager.h
index f60ef14..4f9c21b 100644
--- a/ui/wm/core/cursor_manager.h
+++ b/ui/wm/core/cursor_manager.h
@@ -43,33 +43,33 @@ class WM_EXPORT CursorManager : public aura::client::CursorClient,
   virtual ~CursorManager();
 
   // Overridden from aura::client::CursorClient:
-  virtual void SetCursor(gfx::NativeCursor) OVERRIDE;
-  virtual gfx::NativeCursor GetCursor() const OVERRIDE;
-  virtual void ShowCursor() OVERRIDE;
-  virtual void HideCursor() OVERRIDE;
-  virtual bool IsCursorVisible() const OVERRIDE;
-  virtual void SetCursorSet(ui::CursorSetType cursor_set) OVERRIDE;
-  virtual ui::CursorSetType GetCursorSet() const OVERRIDE;
-  virtual void EnableMouseEvents() OVERRIDE;
-  virtual void DisableMouseEvents() OVERRIDE;
-  virtual bool IsMouseEventsEnabled() const OVERRIDE;
-  virtual void SetDisplay(const gfx::Display& display) OVERRIDE;
-  virtual void LockCursor() OVERRIDE;
-  virtual void UnlockCursor() OVERRIDE;
-  virtual bool IsCursorLocked() const OVERRIDE;
+  virtual void SetCursor(gfx::NativeCursor) override;
+  virtual gfx::NativeCursor GetCursor() const override;
+  virtual void ShowCursor() override;
+  virtual void HideCursor() override;
+  virtual bool IsCursorVisible() const override;
+  virtual void SetCursorSet(ui::CursorSetType cursor_set) override;
+  virtual ui::CursorSetType GetCursorSet() const override;
+  virtual void EnableMouseEvents() override;
+  virtual void DisableMouseEvents() override;
+  virtual bool IsMouseEventsEnabled() const override;
+  virtual void SetDisplay(const gfx::Display& display) override;
+  virtual void LockCursor() override;
+  virtual void UnlockCursor() override;
+  virtual bool IsCursorLocked() const override;
   virtual void AddObserver(
-      aura::client::CursorClientObserver* observer) OVERRIDE;
+      aura::client::CursorClientObserver* observer) override;
   virtual void RemoveObserver(
-      aura::client::CursorClientObserver* observer) OVERRIDE;
+      aura::client::CursorClientObserver* observer) override;
   virtual bool ShouldHideCursorOnKeyEvent(
-      const ui::KeyEvent& event) const OVERRIDE;
+      const ui::KeyEvent& event) const override;
 
  private:
   // Overridden from NativeCursorManagerDelegate:
-  virtual void CommitCursor(gfx::NativeCursor cursor) OVERRIDE;
-  virtual void CommitVisibility(bool visible) OVERRIDE;
-  virtual void CommitCursorSet(ui::CursorSetType cursor_set) OVERRIDE;
-  virtual void CommitMouseEventsEnabled(bool enabled) OVERRIDE;
+  virtual void CommitCursor(gfx::NativeCursor cursor) override;
+  virtual void CommitVisibility(bool visible) override;
+  virtual void CommitCursorSet(ui::CursorSetType cursor_set) override;
+  virtual void CommitMouseEventsEnabled(bool enabled) override;
 
   scoped_ptr<NativeCursorManager> delegate_;
 
diff --git a/ui/wm/core/cursor_manager_unittest.cc b/ui/wm/core/cursor_manager_unittest.cc
index 58c3b17..8dd2aa8 100644
--- a/ui/wm/core/cursor_manager_unittest.cc
+++ b/ui/wm/core/cursor_manager_unittest.cc
@@ -15,29 +15,29 @@ class TestingCursorManager : public wm::NativeCursorManager {
   // Overridden from wm::NativeCursorManager:
   virtual void SetDisplay(
       const gfx::Display& display,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {}
+      wm::NativeCursorManagerDelegate* delegate) override {}
 
   virtual void SetCursor(
       gfx::NativeCursor cursor,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitCursor(cursor);
   }
 
   virtual void SetVisibility(
       bool visible,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitVisibility(visible);
   }
 
   virtual void SetMouseEventsEnabled(
       bool enabled,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitMouseEventsEnabled(enabled);
   }
 
   virtual void SetCursorSet(
       ui::CursorSetType cursor_set,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitCursorSet(cursor_set);
   }
 };
@@ -66,7 +66,7 @@ class TestingCursorClientObserver : public aura::client::CursorClientObserver {
   bool did_visibility_change() const { return did_visibility_change_; }
 
   // Overridden from aura::client::CursorClientObserver:
-  virtual void OnCursorVisibilityChanged(bool is_visible) OVERRIDE {
+  virtual void OnCursorVisibilityChanged(bool is_visible) override {
     cursor_visibility_ = is_visible;
     did_visibility_change_ = true;
   }
diff --git a/ui/wm/core/default_activation_client.cc b/ui/wm/core/default_activation_client.cc
index 94af0a5..d6383d6 100644
--- a/ui/wm/core/default_activation_client.cc
+++ b/ui/wm/core/default_activation_client.cc
@@ -23,7 +23,7 @@ class DefaultActivationClient::Deleter : public aura::WindowObserver {
   virtual ~Deleter() {}
 
   // Overridden from WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(aura::Window* window) override {
     DCHECK_EQ(window, root_window_);
     root_window_->RemoveObserver(this);
     delete client_;
diff --git a/ui/wm/core/default_activation_client.h b/ui/wm/core/default_activation_client.h
index 13b2474..fb9f9e2 100644
--- a/ui/wm/core/default_activation_client.h
+++ b/ui/wm/core/default_activation_client.h
@@ -33,18 +33,18 @@ class WM_EXPORT DefaultActivationClient : public aura::client::ActivationClient,
 
   // Overridden from aura::client::ActivationClient:
   virtual void AddObserver(
-      aura::client::ActivationChangeObserver* observer) OVERRIDE;
+      aura::client::ActivationChangeObserver* observer) override;
   virtual void RemoveObserver(
-      aura::client::ActivationChangeObserver* observer) OVERRIDE;
-  virtual void ActivateWindow(aura::Window* window) OVERRIDE;
-  virtual void DeactivateWindow(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetActiveWindow() OVERRIDE;
-  virtual aura::Window* GetActivatableWindow(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetToplevelWindow(aura::Window* window) OVERRIDE;
-  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE;
+      aura::client::ActivationChangeObserver* observer) override;
+  virtual void ActivateWindow(aura::Window* window) override;
+  virtual void DeactivateWindow(aura::Window* window) override;
+  virtual aura::Window* GetActiveWindow() override;
+  virtual aura::Window* GetActivatableWindow(aura::Window* window) override;
+  virtual aura::Window* GetToplevelWindow(aura::Window* window) override;
+  virtual bool CanActivateWindow(aura::Window* window) const override;
 
   // Overridden from WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+  virtual void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   class Deleter;
diff --git a/ui/wm/core/easy_resize_window_targeter.h b/ui/wm/core/easy_resize_window_targeter.h
index 35b9eb2..5693300 100644
--- a/ui/wm/core/easy_resize_window_targeter.h
+++ b/ui/wm/core/easy_resize_window_targeter.h
@@ -34,7 +34,7 @@ class WM_EXPORT EasyResizeWindowTargeter : public aura::WindowTargeter {
   // ui::EventTargeter:
   virtual bool EventLocationInsideBounds(
       ui::EventTarget* target,
-      const ui::LocatedEvent& event) const OVERRIDE;
+      const ui::LocatedEvent& event) const override;
 
  private:
   // Returns true if the hit testing (EventLocationInsideBounds()) should use
diff --git a/ui/wm/core/focus_controller.h b/ui/wm/core/focus_controller.h
index 2f1aa0e..9e4149f 100644
--- a/ui/wm/core/focus_controller.h
+++ b/ui/wm/core/focus_controller.h
@@ -46,40 +46,40 @@ class WM_EXPORT FocusController : public aura::client::ActivationClient,
  private:
   // Overridden from aura::client::ActivationClient:
   virtual void AddObserver(
-      aura::client::ActivationChangeObserver* observer) OVERRIDE;
+      aura::client::ActivationChangeObserver* observer) override;
   virtual void RemoveObserver(
-      aura::client::ActivationChangeObserver* observer) OVERRIDE;
-  virtual void ActivateWindow(aura::Window* window) OVERRIDE;
-  virtual void DeactivateWindow(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetActiveWindow() OVERRIDE;
-  virtual aura::Window* GetActivatableWindow(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetToplevelWindow(aura::Window* window) OVERRIDE;
-  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE;
+      aura::client::ActivationChangeObserver* observer) override;
+  virtual void ActivateWindow(aura::Window* window) override;
+  virtual void DeactivateWindow(aura::Window* window) override;
+  virtual aura::Window* GetActiveWindow() override;
+  virtual aura::Window* GetActivatableWindow(aura::Window* window) override;
+  virtual aura::Window* GetToplevelWindow(aura::Window* window) override;
+  virtual bool CanActivateWindow(aura::Window* window) const override;
 
   // Overridden from aura::client::FocusClient:
   virtual void AddObserver(
-      aura::client::FocusChangeObserver* observer) OVERRIDE;
+      aura::client::FocusChangeObserver* observer) override;
   virtual void RemoveObserver(
-      aura::client::FocusChangeObserver* observer) OVERRIDE;
-  virtual void FocusWindow(aura::Window* window) OVERRIDE;
-  virtual void ResetFocusWithinActiveWindow(aura::Window* window) OVERRIDE;
-  virtual aura::Window* GetFocusedWindow() OVERRIDE;
+      aura::client::FocusChangeObserver* observer) override;
+  virtual void FocusWindow(aura::Window* window) override;
+  virtual void ResetFocusWithinActiveWindow(aura::Window* window) override;
+  virtual aura::Window* GetFocusedWindow() override;
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
+  virtual void OnTouchEvent(ui::TouchEvent* event) override;
+  virtual void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) OVERRIDE;
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
+                                         bool visible) override;
+  virtual void OnWindowDestroying(aura::Window* window) override;
   virtual void OnWindowHierarchyChanging(
-      const HierarchyChangeParams& params) OVERRIDE;
+      const HierarchyChangeParams& params) override;
   virtual void OnWindowHierarchyChanged(
-      const HierarchyChangeParams& params) OVERRIDE;
+      const HierarchyChangeParams& params) override;
 
   // Internal implementation that sets the focused window, fires events etc.
   // This function must be called with a valid focusable window.
diff --git a/ui/wm/core/focus_controller_unittest.cc b/ui/wm/core/focus_controller_unittest.cc
index a10cef3..2508bcd 100644
--- a/ui/wm/core/focus_controller_unittest.cc
+++ b/ui/wm/core/focus_controller_unittest.cc
@@ -56,12 +56,12 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
  private:
   // Overridden from aura::client::ActivationChangeObserver:
   virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE {
+                                 aura::Window* lost_active) override {
     ++activation_changed_count_;
   }
   virtual void OnAttemptToReactivateWindow(
       aura::Window* request_active,
-      aura::Window* actual_active) OVERRIDE {
+      aura::Window* actual_active) override {
     ++reactivation_count_;
     reactivation_requested_window_ = request_active;
     reactivation_actual_window_ = actual_active;
@@ -69,7 +69,7 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
 
   // Overridden from aura::client::FocusChangeObserver:
   virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) OVERRIDE {
+                               aura::Window* lost_focus) override {
     ++focus_changed_count_;
   }
 
@@ -116,14 +116,14 @@ class RecordingActivationAndFocusChangeObserver
 
   // Overridden from aura::client::ActivationChangeObserver:
   virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE {
+                                 aura::Window* lost_active) override {
     if (lost_active && lost_active == deleter_->GetDeletedWindow())
       was_notified_with_deleted_window_ = true;
   }
 
   // Overridden from aura::client::FocusChangeObserver:
   virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) OVERRIDE {
+                               aura::Window* lost_focus) override {
     if (lost_focus && lost_focus == deleter_->GetDeletedWindow())
       was_notified_with_deleted_window_ = true;
   }
@@ -159,7 +159,7 @@ class DeleteOnLoseActivationChangeObserver :
 
   // Overridden from aura::client::ActivationChangeObserver:
   virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE {
+                                 aura::Window* lost_active) override {
     if (window_ && lost_active == window_) {
       delete lost_active;
       did_delete_ = true;
@@ -167,7 +167,7 @@ class DeleteOnLoseActivationChangeObserver :
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() OVERRIDE {
+  virtual aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
@@ -196,7 +196,7 @@ class DeleteOnLoseFocusChangeObserver
 
   // Overridden from aura::client::FocusChangeObserver:
   virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) OVERRIDE {
+                               aura::Window* lost_focus) override {
     if (window_ && lost_focus == window_) {
       delete lost_focus;
       did_delete_ = true;
@@ -204,7 +204,7 @@ class DeleteOnLoseFocusChangeObserver
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() OVERRIDE {
+  virtual aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
@@ -267,7 +267,7 @@ class ScopedFocusedTextInputClientChanger
  private:
   // Overridden from aura::client::FocusChangeObserver:
   virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) OVERRIDE {
+                               aura::Window* lost_focus) override {
     ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(
         text_input_client_);
   }
@@ -282,10 +282,10 @@ class SimpleEventHandler : public ui::EventHandler {
   virtual ~SimpleEventHandler() {}
 
   // Overridden from ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     event->SetHandled();
   }
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     event->SetHandled();
   }
 
@@ -308,7 +308,7 @@ class FocusShiftingActivationObserver
  private:
   // Overridden from aura::client::ActivationChangeObserver:
   virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE {
+                                 aura::Window* lost_active) override {
     // Shift focus to a child. This should prevent the default focusing from
     // occurring in FocusController::FocusWindow().
     if (gained_active == activated_window_) {
@@ -338,33 +338,33 @@ class TestFocusRules : public BaseFocusRules {
   }
 
   // Overridden from BaseFocusRules:
-  virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
+  virtual bool SupportsChildActivation(aura::Window* window) const override {
     // In FocusControllerTests, only the RootWindow has activatable children.
     return window->GetRootWindow() == window;
   }
-  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE {
+  virtual bool CanActivateWindow(aura::Window* window) const override {
     // Restricting focus to a non-activatable child window means the activatable
     // parent outside the focus restriction is activatable.
     bool can_activate =
         CanFocusOrActivate(window) || window->Contains(focus_restriction_);
     return can_activate ? BaseFocusRules::CanActivateWindow(window) : false;
   }
-  virtual bool CanFocusWindow(aura::Window* window) const OVERRIDE {
+  virtual bool CanFocusWindow(aura::Window* window) const override {
     return CanFocusOrActivate(window) ?
         BaseFocusRules::CanFocusWindow(window) : false;
   }
   virtual aura::Window* GetActivatableWindow(
-      aura::Window* window) const OVERRIDE {
+      aura::Window* window) const override {
     return BaseFocusRules::GetActivatableWindow(
         CanFocusOrActivate(window) ? window : focus_restriction_);
   }
   virtual aura::Window* GetFocusableWindow(
-      aura::Window* window) const OVERRIDE {
+      aura::Window* window) const override {
     return BaseFocusRules::GetFocusableWindow(
         CanFocusOrActivate(window) ? window : focus_restriction_);
   }
   virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const OVERRIDE {
+      aura::Window* ignore) const override {
     aura::Window* next_activatable =
         BaseFocusRules::GetNextActivatableWindow(ignore);
     return CanFocusOrActivate(next_activatable) ?
@@ -387,7 +387,7 @@ class FocusControllerTestBase : public aura::test::AuraTestBase {
   FocusControllerTestBase() {}
 
   // Overridden from aura::test::AuraTestBase:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     wm_state_.reset(new wm::WMState);
     // FocusController registers itself as an Env observer so it can catch all
     // window initializations, including the root_window()'s, so we create it
@@ -430,7 +430,7 @@ class FocusControllerTestBase : public aura::test::AuraTestBase {
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3,
         gfx::Rect(125, 125, 50, 50), root_window());
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     root_window()->RemovePreTargetHandler(focus_controller_.get());
     aura::test::AuraTestBase::TearDown();
     test_focus_rules_ = NULL;  // Owned by FocusController.
@@ -518,14 +518,14 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
   }
 
   // Overridden from FocusControllerTestBase:
-  virtual void BasicFocus() OVERRIDE {
+  virtual void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(2);
     EXPECT_EQ(2, GetFocusedWindowId());
   }
-  virtual void BasicActivation() OVERRIDE {
+  virtual void BasicActivation() override {
     EXPECT_EQ(NULL, GetActiveWindow());
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
@@ -538,7 +538,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     DeactivateWindow(GetActiveWindow());
     EXPECT_EQ(1, GetActiveWindowId());
   }
-  virtual void FocusEvents() OVERRIDE {
+  virtual void FocusEvents() override {
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
@@ -557,7 +557,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(2, 2);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void DuplicateFocusEvents() OVERRIDE {
+  virtual void DuplicateFocusEvents() override {
     // Focusing an existing focused window should not resend focus events.
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
@@ -573,7 +573,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
   }
-  virtual void ActivationEvents() OVERRIDE {
+  virtual void ActivationEvents() override {
     ActivateWindowById(1);
 
     ScopedFocusNotificationObserver root_observer(root_window());
@@ -589,7 +589,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void ReactivationEvents() OVERRIDE {
+  virtual void ReactivationEvents() override {
     ActivateWindowById(1);
     ScopedFocusNotificationObserver root_observer(root_window());
     EXPECT_EQ(0, root_observer.reactivation_count());
@@ -603,7 +603,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(root_window()->GetChildById(1),
               root_observer.reactivation_actual_window());
   }
-  virtual void DuplicateActivationEvents() OVERRIDE {
+  virtual void DuplicateActivationEvents() override {
     // Activating an existing active window should not resend activation events.
     ActivateWindowById(1);
 
@@ -625,7 +625,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void ShiftFocusWithinActiveWindow() OVERRIDE {
+  virtual void ShiftFocusWithinActiveWindow() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
@@ -634,7 +634,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToChildOfInactiveWindow() OVERRIDE {
+  virtual void ShiftFocusToChildOfInactiveWindow() override {
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
     EXPECT_EQ(2, GetFocusedWindowId());
@@ -642,7 +642,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(11, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToParentOfFocusedWindow() OVERRIDE {
+  virtual void ShiftFocusToParentOfFocusedWindow() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(11);
@@ -651,7 +651,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     // Focus should _not_ shift to the parent of the already-focused window.
     EXPECT_EQ(11, GetFocusedWindowId());
   }
-  virtual void FocusRulesOverride() OVERRIDE {
+  virtual void FocusRulesOverride() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(11);
     EXPECT_EQ(11, GetFocusedWindowId());
@@ -667,7 +667,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ActivationRulesOverride() OVERRIDE {
+  virtual void ActivationRulesOverride() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
@@ -687,7 +687,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(2, GetActiveWindowId());
     EXPECT_EQ(2, GetFocusedWindowId());
   }
-  virtual void ShiftFocusOnActivation() OVERRIDE {
+  virtual void ShiftFocusOnActivation() override {
     // When a window is activated, by default that window is also focused.
     // An ActivationChangeObserver may shift focus to another window within the
     // same activatable window.
@@ -729,7 +729,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
   }
-  virtual void ShiftFocusOnActivationDueToHide() OVERRIDE {
+  virtual void ShiftFocusOnActivationDueToHide() override {
     // Similar to ShiftFocusOnActivation except the activation change is
     // triggered by hiding the active window.
     ActivateWindowById(1);
@@ -755,12 +755,12 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
 
     client->RemoveObserver(observer.get());
   }
-  virtual void NoShiftActiveOnActivation() OVERRIDE {
+  virtual void NoShiftActiveOnActivation() override {
     // When a window is activated, we need to prevent any change to activation
     // from being made in response to an activation change notification.
   }
 
-  virtual void NoFocusChangeOnClickOnCaptureWindow() OVERRIDE {
+  virtual void NoFocusChangeOnClickOnCaptureWindow() override {
     scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
         new aura::client::DefaultCaptureClient(root_window()));
     // Clicking on a window which has capture should not cause a focus change
@@ -781,7 +781,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
   }
 
   // Verifies focus change is honored while capture held.
-  virtual void ChangeFocusWhenNothingFocusedAndCaptured() OVERRIDE {
+  virtual void ChangeFocusWhenNothingFocusedAndCaptured() override {
     scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
         new aura::client::DefaultCaptureClient(root_window()));
     aura::Window* w1 = root_window()->GetChildById(1);
@@ -800,7 +800,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
 
   // Verifies if a window that loses activation or focus is deleted during
   // observer notification we don't pass the deleted window to other observers.
-  virtual void DontPassDeletedWindow() OVERRIDE {
+  virtual void DontPassDeletedWindow() override {
     FocusWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
@@ -839,7 +839,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
 
   // Verifies if the focused text input client is cleared when a window gains
   // or loses the focus.
-  virtual void FocusedTextInputClient() OVERRIDE {
+  virtual void FocusedTextInputClient() override {
     ui::TextInputFocusManager* text_input_focus_manager =
         ui::TextInputFocusManager::GetInstance();
     ui::DummyTextInputClient text_input_client;
@@ -883,16 +883,16 @@ class FocusControllerApiTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void FocusWindowDirect(aura::Window* window) override {
     FocusWindow(window);
   }
-  virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void ActivateWindowDirect(aura::Window* window) override {
     ActivateWindow(window);
   }
-  virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void DeactivateWindowDirect(aura::Window* window) override {
     DeactivateWindow(window);
   }
-  virtual bool IsInputEvent() OVERRIDE { return false; }
+  virtual bool IsInputEvent() override { return false; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
 };
@@ -921,21 +921,21 @@ class FocusControllerMouseEventTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void FocusWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.ClickLeftButton();
   }
-  virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void ActivateWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.ClickLeftButton();
   }
-  virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void DeactivateWindowDirect(aura::Window* window) override {
     aura::Window* next_activatable =
         test_focus_rules()->GetNextActivatableWindow(window);
     ui::test::EventGenerator generator(root_window(), next_activatable);
     generator.ClickLeftButton();
   }
-  virtual bool IsInputEvent() OVERRIDE { return true; }
+  virtual bool IsInputEvent() override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest);
 };
@@ -946,21 +946,21 @@ class FocusControllerGestureEventTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void FocusWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
-  virtual void ActivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void ActivateWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
-  virtual void DeactivateWindowDirect(aura::Window* window) OVERRIDE {
+  virtual void DeactivateWindowDirect(aura::Window* window) override {
     aura::Window* next_activatable =
         test_focus_rules()->GetNextActivatableWindow(window);
     ui::test::EventGenerator generator(root_window(), next_activatable);
     generator.GestureTapAt(window->bounds().CenterPoint());
   }
-  virtual bool IsInputEvent() OVERRIDE { return true; }
+  virtual bool IsInputEvent() override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest);
 };
@@ -984,7 +984,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
   virtual void PostDispostionChangeExpectations() {}
 
   // Overridden from FocusControllerTestBase:
-  virtual void BasicFocus() OVERRIDE {
+  virtual void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
 
     aura::Window* w211 = root_window()->GetChildById(211);
@@ -995,7 +995,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     // BasicFocusRules passes focus to the parent.
     EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId());
   }
-  virtual void BasicActivation() OVERRIDE {
+  virtual void BasicActivation() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     EXPECT_EQ(NULL, GetActiveWindow());
@@ -1008,7 +1008,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     EXPECT_EQ(3, GetActiveWindowId());
     PostDispostionChangeExpectations();
   }
-  virtual void FocusEvents() OVERRIDE {
+  virtual void FocusEvents() override {
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
 
@@ -1021,7 +1021,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     root_observer.ExpectCounts(0, 1);
     observer211.ExpectCounts(0, 1);
   }
-  virtual void ActivationEvents() OVERRIDE {
+  virtual void ActivationEvents() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     aura::Window* w2 = root_window()->GetChildById(2);
@@ -1039,7 +1039,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     observer2.ExpectCounts(1, 1);
     observer3.ExpectCounts(1, 1);
   }
-  virtual void FocusRulesOverride() OVERRIDE {
+  virtual void FocusRulesOverride() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
@@ -1053,7 +1053,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
 
     test_focus_rules()->set_focus_restriction(NULL);
   }
-  virtual void ActivationRulesOverride() OVERRIDE {
+  virtual void ActivationRulesOverride() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     aura::Window* w1 = root_window()->GetChildById(1);
@@ -1096,7 +1096,7 @@ class FocusControllerHideTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+  virtual void ChangeWindowDisposition(aura::Window* window) override {
     GetDispositionWindow(window)->Hide();
   }
 
@@ -1124,7 +1124,7 @@ class FocusControllerDestructionTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+  virtual void ChangeWindowDisposition(aura::Window* window) override {
     delete GetDispositionWindow(window);
   }
 
@@ -1153,12 +1153,12 @@ class FocusControllerRemovalTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) OVERRIDE {
+  virtual void ChangeWindowDisposition(aura::Window* window) override {
     aura::Window* disposition_window = GetDispositionWindow(window);
     disposition_window->parent()->RemoveChild(disposition_window);
     window_owner_.reset(disposition_window);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     window_owner_.reset();
     FocusControllerImplicitTestBase::TearDown();
   }
diff --git a/ui/wm/core/image_grid.h b/ui/wm/core/image_grid.h
index 1242dcb..6102f8b 100644
--- a/ui/wm/core/image_grid.h
+++ b/ui/wm/core/image_grid.h
@@ -137,11 +137,11 @@ class WM_EXPORT ImageGrid {
     void SetClipRect(const gfx::Rect& clip_rect, ui::Layer* layer);
 
     // ui::LayerDelegate implementation:
-    virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
+    virtual void OnPaintLayer(gfx::Canvas* canvas) override;
     virtual void OnDelegatedFrameDamage(
-        const gfx::Rect& damage_rect_in_dip) OVERRIDE;
-    virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
-    virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE;
+        const gfx::Rect& damage_rect_in_dip) override;
+    virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override;
+    virtual base::Closure PrepareForLayerBoundsChange() override;
 
    private:
     friend class TestAPI;
diff --git a/ui/wm/core/input_method_event_filter.h b/ui/wm/core/input_method_event_filter.h
index af82308..d658d77 100644
--- a/ui/wm/core/input_method_event_filter.h
+++ b/ui/wm/core/input_method_event_filter.h
@@ -35,10 +35,10 @@ class WM_EXPORT InputMethodEventFilter
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
 
   // Overridden from ui::internal::InputMethodDelegate:
-  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) OVERRIDE;
+  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override;
 
   scoped_ptr<ui::InputMethod> input_method_;
 
diff --git a/ui/wm/core/input_method_event_filter_unittest.cc b/ui/wm/core/input_method_event_filter_unittest.cc
index 810ba2a..9a2d31b 100644
--- a/ui/wm/core/input_method_event_filter_unittest.cc
+++ b/ui/wm/core/input_method_event_filter_unittest.cc
@@ -33,7 +33,7 @@ class TestTextInputClient : public ui::DummyTextInputClient {
  public:
   explicit TestTextInputClient(aura::Window* window) : window_(window) {}
 
-  virtual aura::Window* GetAttachedWindow() const OVERRIDE { return window_; }
+  virtual aura::Window* GetAttachedWindow() const override { return window_; }
 
  private:
   aura::Window* window_;
@@ -47,7 +47,7 @@ class InputMethodEventFilterTest : public aura::test::AuraTestBase {
   virtual ~InputMethodEventFilterTest() {}
 
   // testing::Test overrides:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     aura::test::AuraTestBase::SetUp();
 
     root_window()->AddPreTargetHandler(&root_filter_);
@@ -66,7 +66,7 @@ class InputMethodEventFilterTest : public aura::test::AuraTestBase {
         test_input_client_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     test_window_.reset();
     root_filter_.RemoveHandler(&test_filter_);
     root_filter_.RemoveHandler(input_method_event_filter_.get());
diff --git a/ui/wm/core/masked_window_targeter.h b/ui/wm/core/masked_window_targeter.h
index 61bb3b1e..e289329 100644
--- a/ui/wm/core/masked_window_targeter.h
+++ b/ui/wm/core/masked_window_targeter.h
@@ -27,7 +27,7 @@ class WM_EXPORT MaskedWindowTargeter : public aura::WindowTargeter {
   // ui::EventTargeter:
   virtual bool EventLocationInsideBounds(
       ui::EventTarget* target,
-      const ui::LocatedEvent& event) const OVERRIDE;
+      const ui::LocatedEvent& event) const override;
 
  private:
   aura::Window* masked_window_;
diff --git a/ui/wm/core/nested_accelerator_controller.h b/ui/wm/core/nested_accelerator_controller.h
index 2826d72e..1eca937 100644
--- a/ui/wm/core/nested_accelerator_controller.h
+++ b/ui/wm/core/nested_accelerator_controller.h
@@ -29,7 +29,7 @@ class WM_EXPORT NestedAcceleratorController
   virtual void PrepareNestedLoopClosures(
       base::MessagePumpDispatcher* dispatcher,
       base::Closure* run_closure,
-      base::Closure* quit_closure) OVERRIDE;
+      base::Closure* quit_closure) override;
 
  private:
   void RunNestedMessageLoop(scoped_ptr<base::RunLoop> run_loop,
diff --git a/ui/wm/core/nested_accelerator_controller_unittest.cc b/ui/wm/core/nested_accelerator_controller_unittest.cc
index d0a3688..ce548d5 100644
--- a/ui/wm/core/nested_accelerator_controller_unittest.cc
+++ b/ui/wm/core/nested_accelerator_controller_unittest.cc
@@ -40,10 +40,10 @@ class MockDispatcher : public ui::PlatformEventDispatcher {
 
  private:
   // ui::PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
+  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override {
     return true;
   }
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
+  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override {
     if (ui::EventTypeFromNative(event) == ui::ET_KEY_RELEASED)
       num_key_events_dispatched_++;
     return ui::POST_DISPATCH_NONE;
@@ -62,11 +62,11 @@ class TestTarget : public ui::AcceleratorTarget {
   int accelerator_pressed_count() const { return accelerator_pressed_count_; }
 
   // Overridden from ui::AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE {
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
     accelerator_pressed_count_++;
     return true;
   }
-  virtual bool CanHandleAccelerators() const OVERRIDE { return true; }
+  virtual bool CanHandleAccelerators() const override { return true; }
 
  private:
   int accelerator_pressed_count_;
@@ -105,7 +105,7 @@ class MockNestedAcceleratorDelegate : public NestedAcceleratorDelegate {
 
   // NestedAcceleratorDelegate:
   virtual Result ProcessAccelerator(
-      const ui::Accelerator& accelerator) OVERRIDE {
+      const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator) ?
         RESULT_PROCESSED : RESULT_NOT_PROCESSED;
   }
@@ -127,7 +127,7 @@ class NestedAcceleratorTest : public aura::test::AuraTestBase {
   NestedAcceleratorTest() {}
   virtual ~NestedAcceleratorTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AuraTestBase::SetUp();
     delegate_ = new MockNestedAcceleratorDelegate();
     nested_accelerator_controller_.reset(
@@ -136,7 +136,7 @@ class NestedAcceleratorTest : public aura::test::AuraTestBase {
                                       nested_accelerator_controller_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     aura::client::SetDispatcherClient(root_window(), NULL);
     AuraTestBase::TearDown();
     delegate_ = NULL;
diff --git a/ui/wm/core/nested_accelerator_dispatcher_linux.cc b/ui/wm/core/nested_accelerator_dispatcher_linux.cc
index 3379419..ee5b587 100644
--- a/ui/wm/core/nested_accelerator_dispatcher_linux.cc
+++ b/ui/wm/core/nested_accelerator_dispatcher_linux.cc
@@ -55,16 +55,16 @@ class NestedAcceleratorDispatcherLinux : public NestedAcceleratorDispatcher,
 
  private:
   // AcceleratorDispatcher:
-  virtual scoped_ptr<base::RunLoop> CreateRunLoop() OVERRIDE {
+  virtual scoped_ptr<base::RunLoop> CreateRunLoop() override {
     return scoped_ptr<base::RunLoop>(new base::RunLoop());
   }
 
   // ui::PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
+  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override {
     return true;
   }
 
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) OVERRIDE {
+  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override {
     if (IsKeyEvent(event)) {
       ui::KeyEvent key_event(event);
       ui::Accelerator accelerator = CreateAcceleratorFromKeyEvent(key_event);
diff --git a/ui/wm/core/nested_accelerator_dispatcher_win.cc b/ui/wm/core/nested_accelerator_dispatcher_win.cc
index 3b3fb2d..5504d57 100644
--- a/ui/wm/core/nested_accelerator_dispatcher_win.cc
+++ b/ui/wm/core/nested_accelerator_dispatcher_win.cc
@@ -35,12 +35,12 @@ class NestedAcceleratorDispatcherWin : public NestedAcceleratorDispatcher,
 
  private:
   // NestedAcceleratorDispatcher:
-  virtual scoped_ptr<base::RunLoop> CreateRunLoop() OVERRIDE {
+  virtual scoped_ptr<base::RunLoop> CreateRunLoop() override {
     return scoped_ptr<base::RunLoop>(new base::RunLoop(this));
   }
 
   // MessagePumpDispatcher:
-  virtual uint32_t Dispatch(const MSG& event) OVERRIDE {
+  virtual uint32_t Dispatch(const MSG& event) override {
     if (IsKeyEvent(event)) {
       ui::KeyEvent key_event(event);
       ui::Accelerator accelerator = CreateAcceleratorFromKeyEvent(key_event);
diff --git a/ui/wm/core/shadow.h b/ui/wm/core/shadow.h
index 5e90650..19f5972 100644
--- a/ui/wm/core/shadow.h
+++ b/ui/wm/core/shadow.h
@@ -54,7 +54,7 @@ class WM_EXPORT Shadow : public ui::ImplicitAnimationObserver {
   void SetStyle(Style style);
 
   // ui::ImplicitAnimationObserver overrides:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
+  virtual void OnImplicitAnimationsCompleted() override;
 
  private:
   // Updates the shadow images to the current |style_|.
diff --git a/ui/wm/core/shadow_controller.cc b/ui/wm/core/shadow_controller.cc
index 9d1f50e..abd33ad 100644
--- a/ui/wm/core/shadow_controller.cc
+++ b/ui/wm/core/shadow_controller.cc
@@ -97,16 +97,16 @@ class ShadowController::Impl :
   static Impl* GetInstance();
 
   // aura::EnvObserver override:
-  virtual void OnWindowInitialized(aura::Window* window) OVERRIDE;
+  virtual void OnWindowInitialized(aura::Window* window) override;
 
   // aura::WindowObserver overrides:
   virtual void OnWindowPropertyChanged(
-      aura::Window* window, const void* key, intptr_t old) OVERRIDE;
+      aura::Window* window, const void* key, intptr_t old) override;
   virtual void OnWindowBoundsChanged(
       aura::Window* window,
       const gfx::Rect& old_bounds,
-      const gfx::Rect& new_bounds) OVERRIDE;
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+      const gfx::Rect& new_bounds) override;
+  virtual void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   friend class base::RefCounted<Impl>;
diff --git a/ui/wm/core/shadow_controller.h b/ui/wm/core/shadow_controller.h
index c846894..9deeda6 100644
--- a/ui/wm/core/shadow_controller.h
+++ b/ui/wm/core/shadow_controller.h
@@ -52,7 +52,7 @@ class WM_EXPORT ShadowController :
 
   // aura::client::ActivationChangeObserver overrides:
   virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE;
+                                 aura::Window* lost_active) override;
 
  private:
   class Impl;
diff --git a/ui/wm/core/shadow_controller_unittest.cc b/ui/wm/core/shadow_controller_unittest.cc
index 477e3ac..1b1aa18 100644
--- a/ui/wm/core/shadow_controller_unittest.cc
+++ b/ui/wm/core/shadow_controller_unittest.cc
@@ -27,7 +27,7 @@ class ShadowControllerTest : public aura::test::AuraTestBase {
   ShadowControllerTest() {}
   virtual ~ShadowControllerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     wm_state_.reset(new wm::WMState);
     AuraTestBase::SetUp();
     new wm::DefaultActivationClient(root_window());
@@ -35,7 +35,7 @@ class ShadowControllerTest : public aura::test::AuraTestBase {
         aura::client::GetActivationClient(root_window());
     shadow_controller_.reset(new ShadowController(activation_client));
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     shadow_controller_.reset();
     AuraTestBase::TearDown();
     wm_state_.reset();
diff --git a/ui/wm/core/shadow_unittest.cc b/ui/wm/core/shadow_unittest.cc
index 2090b06..2ffdd4a 100644
--- a/ui/wm/core/shadow_unittest.cc
+++ b/ui/wm/core/shadow_unittest.cc
@@ -40,15 +40,15 @@ class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
   // ResourceBundle::Delegate:
   virtual base::FilePath GetPathForResourcePack(
       const base::FilePath& pack_path,
-      ui::ScaleFactor scale_factor) OVERRIDE {
+      ui::ScaleFactor scale_factor) override {
     return base::FilePath();
   }
   virtual base::FilePath GetPathForLocalePack(
       const base::FilePath& pack_path,
-      const std::string& locale) OVERRIDE {
+      const std::string& locale) override {
     return base::FilePath();
   }
-  virtual gfx::Image GetImageNamed(int resource_id) OVERRIDE {
+  virtual gfx::Image GetImageNamed(int resource_id) override {
     last_resource_id_ = resource_id;
     switch (resource_id) {
       case IDR_WINDOW_BUBBLE_SHADOW_SMALL:
@@ -62,24 +62,24 @@ class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
     }
   }
   virtual gfx::Image GetNativeImageNamed(
-      int resource_id, ui::ResourceBundle::ImageRTL rtl) OVERRIDE {
+      int resource_id, ui::ResourceBundle::ImageRTL rtl) override {
     return gfx::Image();
   }
   virtual base::RefCountedStaticMemory* LoadDataResourceBytes(
-      int resource_id, ui::ScaleFactor scale_factor) OVERRIDE {
+      int resource_id, ui::ScaleFactor scale_factor) override {
     return NULL;
   }
   virtual bool GetRawDataResource(
       int resource_id, ui::ScaleFactor scale_factor,
-      base::StringPiece* value) OVERRIDE {
+      base::StringPiece* value) override {
     return false;
   }
   virtual bool GetLocalizedString(
-      int message_id, base::string16* value) OVERRIDE {
+      int message_id, base::string16* value) override {
     return false;
   }
   virtual scoped_ptr<gfx::Font> GetFont(
-      ui::ResourceBundle::FontStyle style) OVERRIDE {
+      ui::ResourceBundle::FontStyle style) override {
     return scoped_ptr<gfx::Font>();
   }
 
@@ -103,7 +103,7 @@ class ShadowTest: public aura::test::AuraTestBase {
   MockResourceBundleDelegate* delegate() { return delegate_.get(); }
 
   // aura::testAuraBase:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     aura::test::AuraTestBase::SetUp();
     delegate_.reset(new MockResourceBundleDelegate());
     if (ResourceBundle::HasSharedInstance())
@@ -111,7 +111,7 @@ class ShadowTest: public aura::test::AuraTestBase {
     ui::ResourceBundle::InitSharedInstanceWithLocale(
         "en-US", delegate(), ui::ResourceBundle::LOAD_COMMON_RESOURCES);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     ui::ResourceBundle::CleanupSharedInstance();
     base::FilePath ui_test_pak_path;
     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
diff --git a/ui/wm/core/transient_window_controller.h b/ui/wm/core/transient_window_controller.h
index 8638824..4322b41 100644
--- a/ui/wm/core/transient_window_controller.h
+++ b/ui/wm/core/transient_window_controller.h
@@ -20,12 +20,12 @@ class WM_EXPORT TransientWindowController
 
   // TransientWindowClient:
   virtual void AddTransientChild(aura::Window* parent,
-                                 aura::Window* child) OVERRIDE;
+                                 aura::Window* child) override;
   virtual void RemoveTransientChild(aura::Window* parent,
-                                    aura::Window* child) OVERRIDE;
-  virtual aura::Window* GetTransientParent(aura::Window* window) OVERRIDE;
+                                    aura::Window* child) override;
+  virtual aura::Window* GetTransientParent(aura::Window* window) override;
   virtual const aura::Window* GetTransientParent(
-      const aura::Window* window) OVERRIDE;
+      const aura::Window* window) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransientWindowController);
diff --git a/ui/wm/core/transient_window_manager.h b/ui/wm/core/transient_window_manager.h
index 7a7ee46..a6c5139 100644
--- a/ui/wm/core/transient_window_manager.h
+++ b/ui/wm/core/transient_window_manager.h
@@ -81,13 +81,13 @@ class WM_EXPORT TransientWindowManager : public aura::WindowObserver {
 
   // WindowObserver:
   virtual void OnWindowParentChanged(aura::Window* window,
-                                     aura::Window* parent) OVERRIDE;
+                                     aura::Window* parent) override;
   virtual void OnWindowVisibilityChanging(aura::Window* window,
-                                          bool visible) OVERRIDE;
+                                          bool visible) override;
   virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) OVERRIDE;
-  virtual void OnWindowStackingChanged(aura::Window* window) OVERRIDE;
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
+                                         bool visible) override;
+  virtual void OnWindowStackingChanged(aura::Window* window) override;
+  virtual void OnWindowDestroying(aura::Window* window) override;
 
   aura::Window* window_;
   aura::Window* transient_parent_;
diff --git a/ui/wm/core/transient_window_manager_unittest.cc b/ui/wm/core/transient_window_manager_unittest.cc
index eaac027..79d2559 100644
--- a/ui/wm/core/transient_window_manager_unittest.cc
+++ b/ui/wm/core/transient_window_manager_unittest.cc
@@ -34,11 +34,11 @@ class TestTransientWindowObserver : public TransientWindowObserver {
 
   // TransientWindowObserver overrides:
   virtual void OnTransientChildAdded(Window* window,
-                                     Window* transient) OVERRIDE {
+                                     Window* transient) override {
     add_count_++;
   }
   virtual void OnTransientChildRemoved(Window* window,
-                                       Window* transient) OVERRIDE {
+                                       Window* transient) override {
     remove_count_++;
   }
 
@@ -54,12 +54,12 @@ class TransientWindowManagerTest : public aura::test::AuraTestBase {
   TransientWindowManagerTest() {}
   virtual ~TransientWindowManagerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AuraTestBase::SetUp();
     wm_state_.reset(new wm::WMState);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     wm_state_.reset();
     AuraTestBase::TearDown();
   }
@@ -349,7 +349,7 @@ class DestroyedTrackingDelegate : public aura::test::TestWindowDelegate {
       : name_(name),
         results_(results) {}
 
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(aura::Window* window) override {
     results_->push_back(name_);
   }
 
@@ -462,12 +462,12 @@ class StackingMadrigalLayoutManager : public aura::LayoutManager {
 
  private:
   // Overridden from LayoutManager:
-  virtual void OnWindowResized() OVERRIDE {}
-  virtual void OnWindowAddedToLayout(Window* child) OVERRIDE {}
-  virtual void OnWillRemoveWindowFromLayout(Window* child) OVERRIDE {}
-  virtual void OnWindowRemovedFromLayout(Window* child) OVERRIDE {}
+  virtual void OnWindowResized() override {}
+  virtual void OnWindowAddedToLayout(Window* child) override {}
+  virtual void OnWillRemoveWindowFromLayout(Window* child) override {}
+  virtual void OnWindowRemovedFromLayout(Window* child) override {}
   virtual void OnChildWindowVisibilityChanged(Window* child,
-                                              bool visible) OVERRIDE {
+                                              bool visible) override {
     Window::Windows::const_iterator it = root_window_->children().begin();
     Window* last_window = NULL;
     for (; it != root_window_->children().end(); ++it) {
@@ -482,7 +482,7 @@ class StackingMadrigalLayoutManager : public aura::LayoutManager {
     }
   }
   virtual void SetChildBounds(Window* child,
-                              const gfx::Rect& requested_bounds) OVERRIDE {
+                              const gfx::Rect& requested_bounds) override {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
@@ -506,7 +506,7 @@ class StackingMadrigalVisibilityClient : public aura::client::VisibilityClient {
 
  private:
   // Overridden from client::VisibilityClient:
-  virtual void UpdateLayerVisibility(Window* window, bool visible) OVERRIDE {
+  virtual void UpdateLayerVisibility(Window* window, bool visible) override {
     if (!visible) {
       if (window == ignored_window_)
         window->layer()->set_delegate(NULL);
diff --git a/ui/wm/core/transient_window_stacking_client.h b/ui/wm/core/transient_window_stacking_client.h
index 4ab4aea..ce9d55c 100644
--- a/ui/wm/core/transient_window_stacking_client.h
+++ b/ui/wm/core/transient_window_stacking_client.h
@@ -21,7 +21,7 @@ class WM_EXPORT TransientWindowStackingClient
   // WindowStackingClient:
   virtual bool AdjustStacking(aura::Window** child,
                               aura::Window** target,
-                              aura::Window::StackDirection* direction) OVERRIDE;
+                              aura::Window::StackDirection* direction) override;
 
  private:
   // Purely for DCHECKs.
diff --git a/ui/wm/core/transient_window_stacking_client_unittest.cc b/ui/wm/core/transient_window_stacking_client_unittest.cc
index c5d3bd0..c067496 100644
--- a/ui/wm/core/transient_window_stacking_client_unittest.cc
+++ b/ui/wm/core/transient_window_stacking_client_unittest.cc
@@ -21,13 +21,13 @@ class TransientWindowStackingClientTest : public aura::test::AuraTestBase {
   TransientWindowStackingClientTest() {}
   virtual ~TransientWindowStackingClientTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AuraTestBase::SetUp();
     client_.reset(new TransientWindowStackingClient);
     aura::client::SetWindowStackingClient(client_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     aura::client::SetWindowStackingClient(NULL);
     AuraTestBase::TearDown();
   }
diff --git a/ui/wm/core/user_activity_detector.h b/ui/wm/core/user_activity_detector.h
index 851f07a..7e5db9f 100644
--- a/ui/wm/core/user_activity_detector.h
+++ b/ui/wm/core/user_activity_detector.h
@@ -41,11 +41,11 @@ class WM_EXPORT UserActivityDetector : public ui::EventHandler {
   void OnDisplayPowerChanging();
 
   // ui::EventHandler implementation.
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  virtual void OnScrollEvent(ui::ScrollEvent* event) override;
+  virtual void OnTouchEvent(ui::TouchEvent* event) override;
+  virtual void OnGestureEvent(ui::GestureEvent* event) override;
 
  private:
   // Returns |now_for_test_| if set or base::TimeTicks::Now() otherwise.
diff --git a/ui/wm/core/user_activity_detector_unittest.cc b/ui/wm/core/user_activity_detector_unittest.cc
index 620ab0c..0273093 100644
--- a/ui/wm/core/user_activity_detector_unittest.cc
+++ b/ui/wm/core/user_activity_detector_unittest.cc
@@ -26,7 +26,7 @@ class TestUserActivityObserver : public UserActivityObserver {
   void reset_stats() { num_invocations_ = 0; }
 
   // UserActivityObserver implementation.
-  virtual void OnUserActivity(const ui::Event* event) OVERRIDE {
+  virtual void OnUserActivity(const ui::Event* event) override {
     num_invocations_++;
   }
 
@@ -42,7 +42,7 @@ class UserActivityDetectorTest : public aura::test::AuraTestBase {
   UserActivityDetectorTest() {}
   virtual ~UserActivityDetectorTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AuraTestBase::SetUp();
     observer_.reset(new TestUserActivityObserver);
     detector_.reset(new UserActivityDetector);
@@ -52,7 +52,7 @@ class UserActivityDetectorTest : public aura::test::AuraTestBase {
     detector_->set_now_for_test(now_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     detector_->RemoveObserver(observer_.get());
     AuraTestBase::TearDown();
   }
diff --git a/ui/wm/core/visibility_controller.h b/ui/wm/core/visibility_controller.h
index 47ae991..d29a6da 100644
--- a/ui/wm/core/visibility_controller.h
+++ b/ui/wm/core/visibility_controller.h
@@ -29,7 +29,7 @@ class WM_EXPORT VisibilityController
  private:
   // Overridden from aura::client::VisibilityClient:
   virtual void UpdateLayerVisibility(aura::Window* window,
-                                     bool visible) OVERRIDE;
+                                     bool visible) override;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityController);
 };
diff --git a/ui/wm/core/window_animations.cc b/ui/wm/core/window_animations.cc
index 8284990..746ea48 100644
--- a/ui/wm/core/window_animations.cc
+++ b/ui/wm/core/window_animations.cc
@@ -69,12 +69,12 @@ class HidingWindowAnimationObserverBase : public aura::WindowObserver {
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
 
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
@@ -168,7 +168,7 @@ class ImplicitHidingWindowAnimationObserver
   virtual ~ImplicitHidingWindowAnimationObserver() {}
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
+  virtual void OnImplicitAnimationsCompleted() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImplicitHidingWindowAnimationObserver);
@@ -410,15 +410,15 @@ class RotateHidingWindowAnimationObserver
 
   // ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
+      ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
   virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
+      ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
   virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {}
+      ui::LayerAnimationSequence* sequence) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RotateHidingWindowAnimationObserver);
diff --git a/ui/wm/core/window_animations_unittest.cc b/ui/wm/core/window_animations_unittest.cc
index 0a9a944..b1db736 100644
--- a/ui/wm/core/window_animations_unittest.cc
+++ b/ui/wm/core/window_animations_unittest.cc
@@ -47,7 +47,7 @@ class WindowAnimationsTest : public aura::test::AuraTestBase {
  public:
   WindowAnimationsTest() {}
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     AuraTestBase::TearDown();
   }
 
@@ -258,13 +258,13 @@ class NotifyHideCompletedAnimationHost : public aura::client::AnimationHost {
   virtual ~NotifyHideCompletedAnimationHost() {}
 
   // Overridden from TestWindowDelegate:
-  virtual void OnWindowHidingAnimationCompleted() OVERRIDE {
+  virtual void OnWindowHidingAnimationCompleted() override {
     hide_completed_ = true;
   }
 
   virtual void SetHostTransitionOffsets(
       const gfx::Vector2d& top_left,
-      const gfx::Vector2d& bottom_right) OVERRIDE {}
+      const gfx::Vector2d& bottom_right) override {}
 
   bool hide_completed() const { return hide_completed_; }
 
diff --git a/ui/wm/core/window_modality_controller.h b/ui/wm/core/window_modality_controller.h
index 4d52c21..33386ce 100644
--- a/ui/wm/core/window_modality_controller.h
+++ b/ui/wm/core/window_modality_controller.h
@@ -38,20 +38,20 @@ class WM_EXPORT WindowModalityController : public ui::EventHandler,
   virtual ~WindowModalityController();
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  virtual void OnMouseEvent(ui::MouseEvent* event) override;
+  virtual void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Overridden from aura::EnvObserver:
-  virtual void OnWindowInitialized(aura::Window* window) OVERRIDE;
+  virtual void OnWindowInitialized(aura::Window* window) override;
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
-                                       intptr_t old) OVERRIDE;
+                                       intptr_t old) override;
   virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) OVERRIDE;
-  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+                                         bool visible) override;
+  virtual void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   // Processes a mouse/touch event, and returns true if the event should be
diff --git a/ui/wm/public/scoped_tooltip_disabler.h b/ui/wm/public/scoped_tooltip_disabler.h
index 0fd3e11..1022788 100644
--- a/ui/wm/public/scoped_tooltip_disabler.h
+++ b/ui/wm/public/scoped_tooltip_disabler.h
@@ -24,7 +24,7 @@ class AURA_EXPORT ScopedTooltipDisabler : aura::WindowObserver {
   void EnableTooltips();
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
+  virtual void OnWindowDestroying(aura::Window* window) override;
 
   // The RootWindow to disable Tooltips on; NULL if the Window passed to the
   // constructor was not in a root or the root has been destroyed.
diff --git a/ui/wm/test/run_all_unittests.cc b/ui/wm/test/run_all_unittests.cc
index 6e04469..a0ac59d 100644
--- a/ui/wm/test/run_all_unittests.cc
+++ b/ui/wm/test/run_all_unittests.cc
@@ -18,7 +18,7 @@ class WMTestSuite : public base::TestSuite {
   WMTestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {}
 
  protected:
-  virtual void Initialize() OVERRIDE {
+  virtual void Initialize() override {
     base::TestSuite::Initialize();
     gfx::GLSurface::InitializeOneOffForTests();
     ui::RegisterPathProvider();
@@ -28,7 +28,7 @@ class WMTestSuite : public base::TestSuite {
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
   }
 
-  virtual void Shutdown() OVERRIDE {
+  virtual void Shutdown() override {
     ui::ResourceBundle::CleanupSharedInstance();
     base::TestSuite::Shutdown();
   }
diff --git a/ui/wm/test/wm_test_helper.h b/ui/wm/test/wm_test_helper.h
index 79e15ff..990b478 100644
--- a/ui/wm/test/wm_test_helper.h
+++ b/ui/wm/test/wm_test_helper.h
@@ -47,7 +47,7 @@ class WMTestHelper : public aura::client::WindowTreeClient {
   // Overridden from client::WindowTreeClient:
   virtual aura::Window* GetDefaultParent(aura::Window* context,
                                          aura::Window* window,
-                                         const gfx::Rect& bounds) OVERRIDE;
+                                         const gfx::Rect& bounds) override;
 
  private:
   scoped_ptr<aura::WindowTreeHost> host_;