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=avi@chromium.org Review URL: https://codereview.chromium.org/681873003 Cr-Commit-Position: refs/heads/master@{#301447}
author: dcheng <dcheng@chromium.org> 2014-10-27 14:15:05 -0700
committer: Commit bot <commit-bot@chromium.org> 2014-10-27 21:15:27 +0000
commit: a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2 (patch)
tree: dd1e6ceb329119b972818c7b9d83caf11f598d95 /ui
parent: f6ae4499e0072dec50a75ba0718adfdbfa6c5c9f (diff)
download: chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.zip
chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.tar.gz
chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.tar.bz2
37 files changed, 301 insertions, 356 deletions
diff --git a/ui/wm/core/accelerator_filter.h b/ui/wm/core/accelerator_filter.h
index 0ac7605..44579ef 100644
--- a/ui/wm/core/accelerator_filter.h
+++ b/ui/wm/core/accelerator_filter.h
@@ -22,10 +22,10 @@ class AcceleratorDelegate;
 class WM_EXPORT AcceleratorFilter : public ui::EventHandler {
  public:
   AcceleratorFilter(scoped_ptr<AcceleratorDelegate> delegate);
-  virtual ~AcceleratorFilter();
+  ~AcceleratorFilter() override;
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  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 8073541..4ce5e3a 100644
--- a/ui/wm/core/base_focus_rules.h
+++ b/ui/wm/core/base_focus_rules.h
@@ -16,7 +16,7 @@ namespace wm {
 class WM_EXPORT BaseFocusRules : public FocusRules {
  protected:
   BaseFocusRules();
-  virtual ~BaseFocusRules();
+  ~BaseFocusRules() override;
 
   // Returns true if the children of |window| can be activated.
   virtual bool SupportsChildActivation(aura::Window* window) const = 0;
@@ -26,15 +26,13 @@ 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 aura::Window* GetActivatableWindow(
-      aura::Window* window) const override;
-  virtual aura::Window* GetFocusableWindow(aura::Window* window) const override;
-  virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const override;
+  bool IsToplevelWindow(aura::Window* window) const override;
+  bool CanActivateWindow(aura::Window* window) const override;
+  bool CanFocusWindow(aura::Window* window) const override;
+  aura::Window* GetToplevelWindow(aura::Window* window) const override;
+  aura::Window* GetActivatableWindow(aura::Window* window) const override;
+  aura::Window* GetFocusableWindow(aura::Window* window) const override;
+  aura::Window* GetNextActivatableWindow(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 230ea50..bd9beb9 100644
--- a/ui/wm/core/capture_controller.h
+++ b/ui/wm/core/capture_controller.h
@@ -29,17 +29,17 @@ 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;
+  void SetCapture(aura::Window* window) override;
+  void ReleaseCapture(aura::Window* window) override;
+  aura::Window* GetCaptureWindow() override;
+  aura::Window* GetGlobalCaptureWindow() override;
 
  private:
   friend class ScopedCaptureClient;
   typedef std::set<aura::Window*> RootWindows;
 
   CaptureController();
-  virtual ~CaptureController();
+  ~CaptureController() override;
 
   // The current capture window. NULL if there is no capture window.
   aura::Window* capture_window_;
@@ -56,7 +56,7 @@ class WM_EXPORT CaptureController : public aura::client::CaptureClient {
 class WM_EXPORT ScopedCaptureClient : public aura::WindowObserver {
  public:
   explicit ScopedCaptureClient(aura::Window* root);
-  virtual ~ScopedCaptureClient();
+  ~ScopedCaptureClient() override;
 
   // Returns true if there is a CaptureController with at least one RootWindow.
   static bool IsActive();
@@ -66,7 +66,7 @@ class WM_EXPORT ScopedCaptureClient : public aura::WindowObserver {
   }
 
   // Overridden from aura::WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) override;
+  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 a7767f3..946f3c8 100644
--- a/ui/wm/core/compound_event_filter.h
+++ b/ui/wm/core/compound_event_filter.h
@@ -40,7 +40,7 @@ namespace wm {
 class WM_EXPORT CompoundEventFilter : public ui::EventHandler {
  public:
   CompoundEventFilter();
-  virtual ~CompoundEventFilter();
+  ~CompoundEventFilter() override;
 
   // Returns the cursor for the specified component.
   static gfx::NativeCursor CursorForWindowComponent(int window_component);
@@ -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;
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  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 05f75e9..453e03f 100644
--- a/ui/wm/core/compound_event_filter_unittest.cc
+++ b/ui/wm/core/compound_event_filter_unittest.cc
@@ -35,13 +35,11 @@ namespace {
 class ConsumeGestureEventFilter : public ui::EventHandler {
  public:
   ConsumeGestureEventFilter() {}
-  virtual ~ConsumeGestureEventFilter() {}
+  ~ConsumeGestureEventFilter() override {}
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* e) override {
-    e->StopPropagation();
-  }
+  void OnGestureEvent(ui::GestureEvent* e) override { e->StopPropagation(); }
 
   DISALLOW_COPY_AND_ASSIGN(ConsumeGestureEventFilter);
 };
diff --git a/ui/wm/core/cursor_manager_unittest.cc b/ui/wm/core/cursor_manager_unittest.cc
index 8dd2aa8..24de948 100644
--- a/ui/wm/core/cursor_manager_unittest.cc
+++ b/ui/wm/core/cursor_manager_unittest.cc
@@ -13,31 +13,27 @@ namespace {
 class TestingCursorManager : public wm::NativeCursorManager {
  public:
   // Overridden from wm::NativeCursorManager:
-  virtual void SetDisplay(
-      const gfx::Display& display,
-      wm::NativeCursorManagerDelegate* delegate) override {}
+  void SetDisplay(const gfx::Display& display,
+                  wm::NativeCursorManagerDelegate* delegate) override {}
 
-  virtual void SetCursor(
-      gfx::NativeCursor cursor,
-      wm::NativeCursorManagerDelegate* delegate) override {
+  void SetCursor(gfx::NativeCursor cursor,
+                 wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitCursor(cursor);
   }
 
-  virtual void SetVisibility(
-      bool visible,
-      wm::NativeCursorManagerDelegate* delegate) override {
+  void SetVisibility(bool visible,
+                     wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitVisibility(visible);
   }
 
-  virtual void SetMouseEventsEnabled(
+  void SetMouseEventsEnabled(
       bool enabled,
       wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitMouseEventsEnabled(enabled);
   }
 
-  virtual void SetCursorSet(
-      ui::CursorSetType cursor_set,
-      wm::NativeCursorManagerDelegate* delegate) override {
+  void SetCursorSet(ui::CursorSetType cursor_set,
+                    wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitCursorSet(cursor_set);
   }
 };
@@ -66,7 +62,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 {
+  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 d6383d6..20c0d79 100644
--- a/ui/wm/core/default_activation_client.cc
+++ b/ui/wm/core/default_activation_client.cc
@@ -20,10 +20,10 @@ class DefaultActivationClient::Deleter : public aura::WindowObserver {
   }
 
  private:
-  virtual ~Deleter() {}
+  ~Deleter() override {}
 
   // Overridden from WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) override {
+  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 fb9f9e2..726d886 100644
--- a/ui/wm/core/default_activation_client.h
+++ b/ui/wm/core/default_activation_client.h
@@ -32,24 +32,23 @@ class WM_EXPORT DefaultActivationClient : public aura::client::ActivationClient,
   explicit DefaultActivationClient(aura::Window* root_window);
 
   // Overridden from aura::client::ActivationClient:
-  virtual void AddObserver(
+  void AddObserver(aura::client::ActivationChangeObserver* observer) override;
+  void RemoveObserver(
       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;
+  void ActivateWindow(aura::Window* window) override;
+  void DeactivateWindow(aura::Window* window) override;
+  aura::Window* GetActiveWindow() override;
+  aura::Window* GetActivatableWindow(aura::Window* window) override;
+  aura::Window* GetToplevelWindow(aura::Window* window) override;
+  bool CanActivateWindow(aura::Window* window) const override;
 
   // Overridden from WindowObserver:
-  virtual void OnWindowDestroyed(aura::Window* window) override;
+  void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   class Deleter;
 
-  virtual ~DefaultActivationClient();
+  ~DefaultActivationClient() override;
   void RemoveActiveWindow(aura::Window* window);
 
   // This class explicitly does NOT store the active window in a window property
diff --git a/ui/wm/core/easy_resize_window_targeter.h b/ui/wm/core/easy_resize_window_targeter.h
index 5693300..2543a23 100644
--- a/ui/wm/core/easy_resize_window_targeter.h
+++ b/ui/wm/core/easy_resize_window_targeter.h
@@ -20,7 +20,7 @@ class WM_EXPORT EasyResizeWindowTargeter : public aura::WindowTargeter {
                            const gfx::Insets& mouse_extend,
                            const gfx::Insets& touch_extend);
 
-  virtual ~EasyResizeWindowTargeter();
+  ~EasyResizeWindowTargeter() override;
 
  protected:
   void set_mouse_extend(const gfx::Insets& mouse_extend) {
@@ -32,9 +32,8 @@ class WM_EXPORT EasyResizeWindowTargeter : public aura::WindowTargeter {
   }
 
   // ui::EventTargeter:
-  virtual bool EventLocationInsideBounds(
-      ui::EventTarget* target,
-      const ui::LocatedEvent& event) const override;
+  bool EventLocationInsideBounds(ui::EventTarget* target,
+                                 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 9e4149f..43d3c608b 100644
--- a/ui/wm/core/focus_controller.h
+++ b/ui/wm/core/focus_controller.h
@@ -41,45 +41,39 @@ class WM_EXPORT FocusController : public aura::client::ActivationClient,
  public:
   // |rules| cannot be NULL.
   explicit FocusController(FocusRules* rules);
-  virtual ~FocusController();
+  ~FocusController() override;
 
  private:
   // Overridden from aura::client::ActivationClient:
-  virtual void AddObserver(
+  void AddObserver(aura::client::ActivationChangeObserver* observer) override;
+  void RemoveObserver(
       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;
+  void ActivateWindow(aura::Window* window) override;
+  void DeactivateWindow(aura::Window* window) override;
+  aura::Window* GetActiveWindow() override;
+  aura::Window* GetActivatableWindow(aura::Window* window) override;
+  aura::Window* GetToplevelWindow(aura::Window* window) override;
+  bool CanActivateWindow(aura::Window* window) const override;
 
   // Overridden from aura::client::FocusClient:
-  virtual void AddObserver(
-      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;
+  void AddObserver(aura::client::FocusChangeObserver* observer) override;
+  void RemoveObserver(aura::client::FocusChangeObserver* observer) override;
+  void FocusWindow(aura::Window* window) override;
+  void ResetFocusWithinActiveWindow(aura::Window* window) override;
+  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;
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  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;
-  virtual void OnWindowHierarchyChanging(
-      const HierarchyChangeParams& params) override;
-  virtual void OnWindowHierarchyChanged(
-      const HierarchyChangeParams& params) override;
+  void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
+  void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override;
+  void OnWindowHierarchyChanged(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 2508bcd..6bd6091 100644
--- a/ui/wm/core/focus_controller_unittest.cc
+++ b/ui/wm/core/focus_controller_unittest.cc
@@ -37,7 +37,7 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
         reactivation_count_(0),
         reactivation_requested_window_(NULL),
         reactivation_actual_window_(NULL) {}
-  virtual ~FocusNotificationObserver() {}
+  ~FocusNotificationObserver() override {}
 
   void ExpectCounts(int activation_changed_count, int focus_changed_count) {
     EXPECT_EQ(activation_changed_count, activation_changed_count_);
@@ -55,21 +55,20 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
 
  private:
   // 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 {
     ++activation_changed_count_;
   }
-  virtual void OnAttemptToReactivateWindow(
-      aura::Window* request_active,
-      aura::Window* actual_active) override {
+  void OnAttemptToReactivateWindow(aura::Window* request_active,
+                                   aura::Window* actual_active) override {
     ++reactivation_count_;
     reactivation_requested_window_ = request_active;
     reactivation_actual_window_ = actual_active;
   }
 
   // Overridden from aura::client::FocusChangeObserver:
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     ++focus_changed_count_;
   }
 
@@ -105,7 +104,7 @@ class RecordingActivationAndFocusChangeObserver
     aura::client::GetActivationClient(root_)->AddObserver(this);
     aura::client::GetFocusClient(root_)->AddObserver(this);
   }
-  virtual ~RecordingActivationAndFocusChangeObserver() {
+  ~RecordingActivationAndFocusChangeObserver() override {
     aura::client::GetActivationClient(root_)->RemoveObserver(this);
     aura::client::GetFocusClient(root_)->RemoveObserver(this);
   }
@@ -115,15 +114,15 @@ class RecordingActivationAndFocusChangeObserver
   }
 
   // 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 {
     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 {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     if (lost_focus && lost_focus == deleter_->GetDeletedWindow())
       was_notified_with_deleted_window_ = true;
   }
@@ -153,13 +152,13 @@ class DeleteOnLoseActivationChangeObserver :
         did_delete_(false) {
     aura::client::GetActivationClient(root_)->AddObserver(this);
   }
-  virtual ~DeleteOnLoseActivationChangeObserver() {
+  ~DeleteOnLoseActivationChangeObserver() override {
     aura::client::GetActivationClient(root_)->RemoveObserver(this);
   }
 
   // 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 {
     if (window_ && lost_active == window_) {
       delete lost_active;
       did_delete_ = true;
@@ -167,7 +166,7 @@ class DeleteOnLoseActivationChangeObserver :
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() override {
+  aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
@@ -190,13 +189,13 @@ class DeleteOnLoseFocusChangeObserver
         did_delete_(false) {
     aura::client::GetFocusClient(root_)->AddObserver(this);
   }
-  virtual ~DeleteOnLoseFocusChangeObserver() {
+  ~DeleteOnLoseFocusChangeObserver() override {
     aura::client::GetFocusClient(root_)->RemoveObserver(this);
   }
 
   // Overridden from aura::client::FocusChangeObserver:
-  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 == window_) {
       delete lost_focus;
       did_delete_ = true;
@@ -204,7 +203,7 @@ class DeleteOnLoseFocusChangeObserver
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() override {
+  aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
@@ -223,7 +222,7 @@ class ScopedFocusNotificationObserver : public FocusNotificationObserver {
     aura::client::GetActivationClient(root_window_)->AddObserver(this);
     aura::client::GetFocusClient(root_window_)->AddObserver(this);
   }
-  virtual ~ScopedFocusNotificationObserver() {
+  ~ScopedFocusNotificationObserver() override {
     aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
     aura::client::GetFocusClient(root_window_)->RemoveObserver(this);
   }
@@ -242,7 +241,7 @@ class ScopedTargetFocusNotificationObserver : public FocusNotificationObserver {
     aura::client::SetFocusChangeObserver(target_, this);
     tracker_.Add(target_);
   }
-  virtual ~ScopedTargetFocusNotificationObserver() {
+  ~ScopedTargetFocusNotificationObserver() override {
     if (tracker_.Contains(target_)) {
       aura::client::SetActivationChangeObserver(target_, NULL);
       aura::client::SetFocusChangeObserver(target_, NULL);
@@ -266,8 +265,8 @@ class ScopedFocusedTextInputClientChanger
 
  private:
   // Overridden from aura::client::FocusChangeObserver:
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(
         text_input_client_);
   }
@@ -279,15 +278,11 @@ class ScopedFocusedTextInputClientChanger
 class SimpleEventHandler : public ui::EventHandler {
  public:
   SimpleEventHandler() {}
-  virtual ~SimpleEventHandler() {}
+  ~SimpleEventHandler() override {}
 
   // Overridden from ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
-    event->SetHandled();
-  }
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
-    event->SetHandled();
-  }
+  void OnMouseEvent(ui::MouseEvent* event) override { event->SetHandled(); }
+  void OnGestureEvent(ui::GestureEvent* event) override { event->SetHandled(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleEventHandler);
@@ -299,7 +294,7 @@ class FocusShiftingActivationObserver
   explicit FocusShiftingActivationObserver(aura::Window* activated_window)
       : activated_window_(activated_window),
         shift_focus_to_(NULL) {}
-  virtual ~FocusShiftingActivationObserver() {}
+  ~FocusShiftingActivationObserver() override {}
 
   void set_shift_focus_to(aura::Window* shift_focus_to) {
     shift_focus_to_ = shift_focus_to;
@@ -307,8 +302,8 @@ class FocusShiftingActivationObserver
 
  private:
   // 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 {
     // Shift focus to a child. This should prevent the default focusing from
     // occurring in FocusController::FocusWindow().
     if (gained_active == activated_window_) {
@@ -338,33 +333,30 @@ class TestFocusRules : public BaseFocusRules {
   }
 
   // Overridden from BaseFocusRules:
-  virtual bool SupportsChildActivation(aura::Window* window) const override {
+  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 {
+  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 {
+  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* GetActivatableWindow(aura::Window* window) const override {
     return BaseFocusRules::GetActivatableWindow(
         CanFocusOrActivate(window) ? window : focus_restriction_);
   }
-  virtual aura::Window* GetFocusableWindow(
-      aura::Window* window) const override {
+  aura::Window* GetFocusableWindow(aura::Window* window) const override {
     return BaseFocusRules::GetFocusableWindow(
         CanFocusOrActivate(window) ? window : focus_restriction_);
   }
-  virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const override {
+  aura::Window* GetNextActivatableWindow(aura::Window* ignore) const override {
     aura::Window* next_activatable =
         BaseFocusRules::GetNextActivatableWindow(ignore);
     return CanFocusOrActivate(next_activatable) ?
@@ -387,7 +379,7 @@ class FocusControllerTestBase : public aura::test::AuraTestBase {
   FocusControllerTestBase() {}
 
   // Overridden from aura::test::AuraTestBase:
-  virtual void SetUp() override {
+  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 +422,7 @@ class FocusControllerTestBase : public aura::test::AuraTestBase {
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 3,
         gfx::Rect(125, 125, 50, 50), root_window());
   }
-  virtual void TearDown() override {
+  void TearDown() override {
     root_window()->RemovePreTargetHandler(focus_controller_.get());
     aura::test::AuraTestBase::TearDown();
     test_focus_rules_ = NULL;  // Owned by FocusController.
@@ -518,14 +510,14 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
   }
 
   // Overridden from FocusControllerTestBase:
-  virtual void BasicFocus() override {
+  void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(2);
     EXPECT_EQ(2, GetFocusedWindowId());
   }
-  virtual void BasicActivation() override {
+  void BasicActivation() override {
     EXPECT_EQ(NULL, GetActiveWindow());
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
@@ -538,7 +530,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     DeactivateWindow(GetActiveWindow());
     EXPECT_EQ(1, GetActiveWindowId());
   }
-  virtual void FocusEvents() override {
+  void FocusEvents() override {
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
@@ -557,7 +549,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(2, 2);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void DuplicateFocusEvents() override {
+  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 +565,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
   }
-  virtual void ActivationEvents() override {
+  void ActivationEvents() override {
     ActivateWindowById(1);
 
     ScopedFocusNotificationObserver root_observer(root_window());
@@ -589,7 +581,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void ReactivationEvents() override {
+  void ReactivationEvents() override {
     ActivateWindowById(1);
     ScopedFocusNotificationObserver root_observer(root_window());
     EXPECT_EQ(0, root_observer.reactivation_count());
@@ -603,7 +595,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(root_window()->GetChildById(1),
               root_observer.reactivation_actual_window());
   }
-  virtual void DuplicateActivationEvents() override {
+  void DuplicateActivationEvents() override {
     // Activating an existing active window should not resend activation events.
     ActivateWindowById(1);
 
@@ -625,7 +617,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
   }
-  virtual void ShiftFocusWithinActiveWindow() override {
+  void ShiftFocusWithinActiveWindow() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
@@ -634,7 +626,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToChildOfInactiveWindow() override {
+  void ShiftFocusToChildOfInactiveWindow() override {
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
     EXPECT_EQ(2, GetFocusedWindowId());
@@ -642,7 +634,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(11, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToParentOfFocusedWindow() override {
+  void ShiftFocusToParentOfFocusedWindow() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(11);
@@ -651,7 +643,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 {
+  void FocusRulesOverride() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     FocusWindowById(11);
     EXPECT_EQ(11, GetFocusedWindowId());
@@ -667,7 +659,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ActivationRulesOverride() override {
+  void ActivationRulesOverride() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
@@ -687,7 +679,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     EXPECT_EQ(2, GetActiveWindowId());
     EXPECT_EQ(2, GetFocusedWindowId());
   }
-  virtual void ShiftFocusOnActivation() override {
+  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 +721,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
   }
-  virtual void ShiftFocusOnActivationDueToHide() override {
+  void ShiftFocusOnActivationDueToHide() override {
     // Similar to ShiftFocusOnActivation except the activation change is
     // triggered by hiding the active window.
     ActivateWindowById(1);
@@ -755,12 +747,12 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
 
     client->RemoveObserver(observer.get());
   }
-  virtual void NoShiftActiveOnActivation() override {
+  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 {
+  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 +773,7 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase {
   }
 
   // Verifies focus change is honored while capture held.
-  virtual void ChangeFocusWhenNothingFocusedAndCaptured() override {
+  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 +792,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 {
+  void DontPassDeletedWindow() override {
     FocusWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
@@ -839,7 +831,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 {
+  void FocusedTextInputClient() override {
     ui::TextInputFocusManager* text_input_focus_manager =
         ui::TextInputFocusManager::GetInstance();
     ui::DummyTextInputClient text_input_client;
@@ -883,16 +875,14 @@ class FocusControllerApiTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) override {
-    FocusWindow(window);
-  }
-  virtual void ActivateWindowDirect(aura::Window* window) override {
+  void FocusWindowDirect(aura::Window* window) override { FocusWindow(window); }
+  void ActivateWindowDirect(aura::Window* window) override {
     ActivateWindow(window);
   }
-  virtual void DeactivateWindowDirect(aura::Window* window) override {
+  void DeactivateWindowDirect(aura::Window* window) override {
     DeactivateWindow(window);
   }
-  virtual bool IsInputEvent() override { return false; }
+  bool IsInputEvent() override { return false; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest);
 };
@@ -921,21 +911,21 @@ class FocusControllerMouseEventTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) override {
+  void FocusWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.ClickLeftButton();
   }
-  virtual void ActivateWindowDirect(aura::Window* window) override {
+  void ActivateWindowDirect(aura::Window* window) override {
     ui::test::EventGenerator generator(root_window(), window);
     generator.ClickLeftButton();
   }
-  virtual void DeactivateWindowDirect(aura::Window* window) override {
+  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; }
+  bool IsInputEvent() override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest);
 };
@@ -946,21 +936,21 @@ class FocusControllerGestureEventTest : public FocusControllerDirectTestBase {
 
  private:
   // Overridden from FocusControllerTestBase:
-  virtual void FocusWindowDirect(aura::Window* window) override {
+  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 {
+  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 {
+  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; }
+  bool IsInputEvent() override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest);
 };
@@ -984,7 +974,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
   virtual void PostDispostionChangeExpectations() {}
 
   // Overridden from FocusControllerTestBase:
-  virtual void BasicFocus() override {
+  void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
 
     aura::Window* w211 = root_window()->GetChildById(211);
@@ -995,7 +985,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     // BasicFocusRules passes focus to the parent.
     EXPECT_EQ(parent_ ? 2 : 21, GetFocusedWindowId());
   }
-  virtual void BasicActivation() override {
+  void BasicActivation() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     EXPECT_EQ(NULL, GetActiveWindow());
@@ -1008,7 +998,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     EXPECT_EQ(3, GetActiveWindowId());
     PostDispostionChangeExpectations();
   }
-  virtual void FocusEvents() override {
+  void FocusEvents() override {
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
 
@@ -1021,7 +1011,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     root_observer.ExpectCounts(0, 1);
     observer211.ExpectCounts(0, 1);
   }
-  virtual void ActivationEvents() override {
+  void ActivationEvents() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     aura::Window* w2 = root_window()->GetChildById(2);
@@ -1039,7 +1029,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
     observer2.ExpectCounts(1, 1);
     observer3.ExpectCounts(1, 1);
   }
-  virtual void FocusRulesOverride() override {
+  void FocusRulesOverride() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
@@ -1053,7 +1043,7 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase {
 
     test_focus_rules()->set_focus_restriction(NULL);
   }
-  virtual void ActivationRulesOverride() override {
+  void ActivationRulesOverride() override {
     DCHECK(!parent_) << "Activation tests don't support parent changes.";
 
     aura::Window* w1 = root_window()->GetChildById(1);
@@ -1096,7 +1086,7 @@ class FocusControllerHideTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) override {
+  void ChangeWindowDisposition(aura::Window* window) override {
     GetDispositionWindow(window)->Hide();
   }
 
@@ -1124,7 +1114,7 @@ class FocusControllerDestructionTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) override {
+  void ChangeWindowDisposition(aura::Window* window) override {
     delete GetDispositionWindow(window);
   }
 
@@ -1153,12 +1143,12 @@ class FocusControllerRemovalTest : public FocusControllerImplicitTestBase {
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) override {
+  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 {
+  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 6102f8b..b3cf2e1 100644
--- a/ui/wm/core/image_grid.h
+++ b/ui/wm/core/image_grid.h
@@ -130,18 +130,17 @@ class WM_EXPORT ImageGrid {
   class ImagePainter : public ui::LayerDelegate {
    public:
     ImagePainter(const gfx::ImageSkia& image) : image_(image) {}
-    virtual ~ImagePainter() {}
+    ~ImagePainter() override {}
 
     // Clips |layer| to |clip_rect|.  Triggers a repaint if the clipping
     // rectangle has changed.  An empty rectangle disables clipping.
     void SetClipRect(const gfx::Rect& clip_rect, ui::Layer* layer);
 
     // ui::LayerDelegate implementation:
-    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;
+    void OnPaintLayer(gfx::Canvas* canvas) override;
+    void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override;
+    void OnDeviceScaleFactorChanged(float device_scale_factor) override;
+    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 d658d77..c6bd65a 100644
--- a/ui/wm/core/input_method_event_filter.h
+++ b/ui/wm/core/input_method_event_filter.h
@@ -27,7 +27,7 @@ class WM_EXPORT InputMethodEventFilter
       public ui::internal::InputMethodDelegate {
  public:
   explicit InputMethodEventFilter(gfx::AcceleratedWidget widget);
-  virtual ~InputMethodEventFilter();
+  ~InputMethodEventFilter() override;
 
   void SetInputMethodPropertyInRootWindow(aura::Window* root_window);
 
@@ -35,10 +35,10 @@ class WM_EXPORT InputMethodEventFilter
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnKeyEvent(ui::KeyEvent* event) override;
 
   // Overridden from ui::internal::InputMethodDelegate:
-  virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override;
+  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 9a2d31b..5da0358 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_; }
+  aura::Window* GetAttachedWindow() const override { return window_; }
 
  private:
   aura::Window* window_;
@@ -44,10 +44,10 @@ class TestTextInputClient : public ui::DummyTextInputClient {
 class InputMethodEventFilterTest : public aura::test::AuraTestBase {
  public:
   InputMethodEventFilterTest() {}
-  virtual ~InputMethodEventFilterTest() {}
+  ~InputMethodEventFilterTest() override {}
 
   // testing::Test overrides:
-  virtual void SetUp() override {
+  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 {
+  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 e289329..cc209f3 100644
--- a/ui/wm/core/masked_window_targeter.h
+++ b/ui/wm/core/masked_window_targeter.h
@@ -17,7 +17,7 @@ namespace wm {
 class WM_EXPORT MaskedWindowTargeter : public aura::WindowTargeter {
  public:
   explicit MaskedWindowTargeter(aura::Window* masked_window);
-  virtual ~MaskedWindowTargeter();
+  ~MaskedWindowTargeter() override;
 
  protected:
   // Sets the hit-test mask for |window| in |mask| (in |window|'s local
@@ -25,9 +25,8 @@ class WM_EXPORT MaskedWindowTargeter : public aura::WindowTargeter {
   virtual bool GetHitTestMask(aura::Window* window, gfx::Path* mask) const = 0;
 
   // ui::EventTargeter:
-  virtual bool EventLocationInsideBounds(
-      ui::EventTarget* target,
-      const ui::LocatedEvent& event) const override;
+  bool EventLocationInsideBounds(ui::EventTarget* target,
+                                 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 1eca937..70cb6c1 100644
--- a/ui/wm/core/nested_accelerator_controller.h
+++ b/ui/wm/core/nested_accelerator_controller.h
@@ -23,13 +23,12 @@ class WM_EXPORT NestedAcceleratorController
     : public aura::client::DispatcherClient {
  public:
   explicit NestedAcceleratorController(NestedAcceleratorDelegate* delegate);
-  virtual ~NestedAcceleratorController();
+  ~NestedAcceleratorController() override;
 
   // aura::client::DispatcherClient:
-  virtual void PrepareNestedLoopClosures(
-      base::MessagePumpDispatcher* dispatcher,
-      base::Closure* run_closure,
-      base::Closure* quit_closure) override;
+  void PrepareNestedLoopClosures(base::MessagePumpDispatcher* dispatcher,
+                                 base::Closure* run_closure,
+                                 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 ce548d5..968bcba 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 {
+  bool CanDispatchEvent(const ui::PlatformEvent& event) override {
     return true;
   }
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override {
+  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;
@@ -57,16 +57,16 @@ class MockDispatcher : public ui::PlatformEventDispatcher {
 class TestTarget : public ui::AcceleratorTarget {
  public:
   TestTarget() : accelerator_pressed_count_(0) {}
-  virtual ~TestTarget() {}
+  ~TestTarget() override {}
 
   int accelerator_pressed_count() const { return accelerator_pressed_count_; }
 
   // Overridden from ui::AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
     accelerator_pressed_count_++;
     return true;
   }
-  virtual bool CanHandleAccelerators() const override { return true; }
+  bool CanHandleAccelerators() const override { return true; }
 
  private:
   int accelerator_pressed_count_;
@@ -101,11 +101,10 @@ class MockNestedAcceleratorDelegate : public NestedAcceleratorDelegate {
  public:
   MockNestedAcceleratorDelegate()
       : accelerator_manager_(new ui::AcceleratorManager) {}
-  virtual ~MockNestedAcceleratorDelegate() {}
+  ~MockNestedAcceleratorDelegate() override {}
 
   // NestedAcceleratorDelegate:
-  virtual Result ProcessAccelerator(
-      const ui::Accelerator& accelerator) override {
+  Result ProcessAccelerator(const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator) ?
         RESULT_PROCESSED : RESULT_NOT_PROCESSED;
   }
@@ -125,9 +124,9 @@ class MockNestedAcceleratorDelegate : public NestedAcceleratorDelegate {
 class NestedAcceleratorTest : public aura::test::AuraTestBase {
  public:
   NestedAcceleratorTest() {}
-  virtual ~NestedAcceleratorTest() {}
+  ~NestedAcceleratorTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     delegate_ = new MockNestedAcceleratorDelegate();
     nested_accelerator_controller_.reset(
@@ -136,7 +135,7 @@ class NestedAcceleratorTest : public aura::test::AuraTestBase {
                                       nested_accelerator_controller_.get());
   }
 
-  virtual void TearDown() override {
+  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 16a4efb..bc0f49c 100644
--- a/ui/wm/core/nested_accelerator_dispatcher_linux.cc
+++ b/ui/wm/core/nested_accelerator_dispatcher_linux.cc
@@ -51,20 +51,20 @@ class NestedAcceleratorDispatcherLinux : public NestedAcceleratorDispatcher,
       : NestedAcceleratorDispatcher(delegate),
         restore_dispatcher_(OverrideDispatcher(this)) {}
 
-  virtual ~NestedAcceleratorDispatcherLinux() {}
+  ~NestedAcceleratorDispatcherLinux() override {}
 
  private:
   // AcceleratorDispatcher:
-  virtual scoped_ptr<base::RunLoop> CreateRunLoop() override {
+  scoped_ptr<base::RunLoop> CreateRunLoop() override {
     return scoped_ptr<base::RunLoop>(new base::RunLoop());
   }
 
   // ui::PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override {
+  bool CanDispatchEvent(const ui::PlatformEvent& event) override {
     return true;
   }
 
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override {
+  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/shadow.h b/ui/wm/core/shadow.h
index 19f5972..69f3065 100644
--- a/ui/wm/core/shadow.h
+++ b/ui/wm/core/shadow.h
@@ -34,7 +34,7 @@ class WM_EXPORT Shadow : public ui::ImplicitAnimationObserver {
   };
 
   Shadow();
-  virtual ~Shadow();
+  ~Shadow() override;
 
   void Init(Style style);
 
@@ -54,7 +54,7 @@ class WM_EXPORT Shadow : public ui::ImplicitAnimationObserver {
   void SetStyle(Style style);
 
   // ui::ImplicitAnimationObserver overrides:
-  virtual void OnImplicitAnimationsCompleted() override;
+  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 abd33ad..99bfadf 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;
+  void OnWindowInitialized(aura::Window* window) override;
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowPropertyChanged(
-      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;
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
+  void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   friend class base::RefCounted<Impl>;
@@ -116,7 +116,7 @@ class ShadowController::Impl :
   typedef std::map<aura::Window*, linked_ptr<Shadow> > WindowShadowMap;
 
   Impl();
-  virtual ~Impl();
+  ~Impl() override;
 
   // Forwarded from ShadowController.
   void OnWindowActivated(aura::Window* gained_active,
diff --git a/ui/wm/core/shadow_controller.h b/ui/wm/core/shadow_controller.h
index 9deeda6..360a997 100644
--- a/ui/wm/core/shadow_controller.h
+++ b/ui/wm/core/shadow_controller.h
@@ -48,11 +48,11 @@ class WM_EXPORT ShadowController :
   };
 
   explicit ShadowController(aura::client::ActivationClient* activation_client);
-  virtual ~ShadowController();
+  ~ShadowController() override;
 
   // aura::client::ActivationChangeObserver overrides:
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override;
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override;
 
  private:
   class Impl;
diff --git a/ui/wm/core/shadow_controller_unittest.cc b/ui/wm/core/shadow_controller_unittest.cc
index 1b1aa18..18116d4 100644
--- a/ui/wm/core/shadow_controller_unittest.cc
+++ b/ui/wm/core/shadow_controller_unittest.cc
@@ -25,9 +25,9 @@ namespace wm {
 class ShadowControllerTest : public aura::test::AuraTestBase {
  public:
   ShadowControllerTest() {}
-  virtual ~ShadowControllerTest() {}
+  ~ShadowControllerTest() override {}
 
-  virtual void SetUp() override {
+  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 {
+  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 2ffdd4a..10f4495 100644
--- a/ui/wm/core/shadow_unittest.cc
+++ b/ui/wm/core/shadow_unittest.cc
@@ -35,20 +35,18 @@ class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
     image_small_ = gfx::Image::CreateFrom1xBitmap(bitmap_small);
     image_large_ = gfx::Image::CreateFrom1xBitmap(bitmap_large);
   }
-  virtual ~MockResourceBundleDelegate() {}
+  ~MockResourceBundleDelegate() override {}
 
   // ResourceBundle::Delegate:
-  virtual base::FilePath GetPathForResourcePack(
-      const base::FilePath& pack_path,
-      ui::ScaleFactor scale_factor) override {
+  base::FilePath GetPathForResourcePack(const base::FilePath& pack_path,
+                                        ui::ScaleFactor scale_factor) override {
     return base::FilePath();
   }
-  virtual base::FilePath GetPathForLocalePack(
-      const base::FilePath& pack_path,
-      const std::string& locale) override {
+  base::FilePath GetPathForLocalePack(const base::FilePath& pack_path,
+                                      const std::string& locale) override {
     return base::FilePath();
   }
-  virtual gfx::Image GetImageNamed(int resource_id) override {
+  gfx::Image GetImageNamed(int resource_id) override {
     last_resource_id_ = resource_id;
     switch (resource_id) {
       case IDR_WINDOW_BUBBLE_SHADOW_SMALL:
@@ -61,25 +59,24 @@ class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
         return gfx::Image();
     }
   }
-  virtual gfx::Image GetNativeImageNamed(
-      int resource_id, ui::ResourceBundle::ImageRTL rtl) override {
+  gfx::Image GetNativeImageNamed(int resource_id,
+                                 ui::ResourceBundle::ImageRTL rtl) override {
     return gfx::Image();
   }
-  virtual base::RefCountedStaticMemory* LoadDataResourceBytes(
-      int resource_id, ui::ScaleFactor scale_factor) override {
+  base::RefCountedStaticMemory* LoadDataResourceBytes(
+      int resource_id,
+      ui::ScaleFactor scale_factor) override {
     return NULL;
   }
-  virtual bool GetRawDataResource(
-      int resource_id, ui::ScaleFactor scale_factor,
-      base::StringPiece* value) override {
+  bool GetRawDataResource(int resource_id,
+                          ui::ScaleFactor scale_factor,
+                          base::StringPiece* value) override {
     return false;
   }
-  virtual bool GetLocalizedString(
-      int message_id, base::string16* value) override {
+  bool GetLocalizedString(int message_id, base::string16* value) override {
     return false;
   }
-  virtual scoped_ptr<gfx::Font> GetFont(
-      ui::ResourceBundle::FontStyle style) override {
+  scoped_ptr<gfx::Font> GetFont(ui::ResourceBundle::FontStyle style) override {
     return scoped_ptr<gfx::Font>();
   }
 
@@ -98,12 +95,12 @@ class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
 class ShadowTest: public aura::test::AuraTestBase {
  public:
   ShadowTest() {}
-  virtual ~ShadowTest() {}
+  ~ShadowTest() override {}
 
   MockResourceBundleDelegate* delegate() { return delegate_.get(); }
 
   // aura::testAuraBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     aura::test::AuraTestBase::SetUp();
     delegate_.reset(new MockResourceBundleDelegate());
     if (ResourceBundle::HasSharedInstance())
@@ -111,7 +108,7 @@ class ShadowTest: public aura::test::AuraTestBase {
     ui::ResourceBundle::InitSharedInstanceWithLocale(
         "en-US", delegate(), ui::ResourceBundle::LOAD_COMMON_RESOURCES);
   }
-  virtual void TearDown() override {
+  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 4322b41..0dcf989 100644
--- a/ui/wm/core/transient_window_controller.h
+++ b/ui/wm/core/transient_window_controller.h
@@ -16,16 +16,13 @@ class WM_EXPORT TransientWindowController
     : public aura::client::TransientWindowClient {
  public:
   TransientWindowController();
-  virtual ~TransientWindowController();
+  ~TransientWindowController() override;
 
   // TransientWindowClient:
-  virtual void AddTransientChild(aura::Window* parent,
-                                 aura::Window* child) override;
-  virtual void RemoveTransientChild(aura::Window* parent,
-                                    aura::Window* child) override;
-  virtual aura::Window* GetTransientParent(aura::Window* window) override;
-  virtual const aura::Window* GetTransientParent(
-      const aura::Window* window) override;
+  void AddTransientChild(aura::Window* parent, aura::Window* child) override;
+  void RemoveTransientChild(aura::Window* parent, aura::Window* child) override;
+  aura::Window* GetTransientParent(aura::Window* window) override;
+  const aura::Window* GetTransientParent(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 a6c5139..9973cd0 100644
--- a/ui/wm/core/transient_window_manager.h
+++ b/ui/wm/core/transient_window_manager.h
@@ -32,7 +32,7 @@ class WM_EXPORT TransientWindowManager : public aura::WindowObserver {
  public:
   typedef std::vector<aura::Window*> Windows;
 
-  virtual ~TransientWindowManager();
+  ~TransientWindowManager() override;
 
   // Returns the TransientWindowManager for |window|. This never returns NULL.
   static TransientWindowManager* Get(aura::Window* window);
@@ -80,14 +80,12 @@ class WM_EXPORT TransientWindowManager : public aura::WindowObserver {
   void UpdateTransientChildVisibility(bool visible);
 
   // WindowObserver:
-  virtual void OnWindowParentChanged(aura::Window* window,
-                                     aura::Window* parent) override;
-  virtual void OnWindowVisibilityChanging(aura::Window* window,
-                                          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;
+  void OnWindowParentChanged(aura::Window* window,
+                             aura::Window* parent) override;
+  void OnWindowVisibilityChanging(aura::Window* window, bool visible) override;
+  void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
+  void OnWindowStackingChanged(aura::Window* window) override;
+  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 79d2559..93f7bc7 100644
--- a/ui/wm/core/transient_window_manager_unittest.cc
+++ b/ui/wm/core/transient_window_manager_unittest.cc
@@ -26,19 +26,16 @@ class TestTransientWindowObserver : public TransientWindowObserver {
   TestTransientWindowObserver() : add_count_(0), remove_count_(0) {
   }
 
-  virtual ~TestTransientWindowObserver() {
-  }
+  ~TestTransientWindowObserver() override {}
 
   int add_count() const { return add_count_; }
   int remove_count() const { return remove_count_; }
 
   // TransientWindowObserver overrides:
-  virtual void OnTransientChildAdded(Window* window,
-                                     Window* transient) override {
+  void OnTransientChildAdded(Window* window, Window* transient) override {
     add_count_++;
   }
-  virtual void OnTransientChildRemoved(Window* window,
-                                       Window* transient) override {
+  void OnTransientChildRemoved(Window* window, Window* transient) override {
     remove_count_++;
   }
 
@@ -52,14 +49,14 @@ class TestTransientWindowObserver : public TransientWindowObserver {
 class TransientWindowManagerTest : public aura::test::AuraTestBase {
  public:
   TransientWindowManagerTest() {}
-  virtual ~TransientWindowManagerTest() {}
+  ~TransientWindowManagerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     wm_state_.reset(new wm::WMState);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     wm_state_.reset();
     AuraTestBase::TearDown();
   }
@@ -349,7 +346,7 @@ class DestroyedTrackingDelegate : public aura::test::TestWindowDelegate {
       : name_(name),
         results_(results) {}
 
-  virtual void OnWindowDestroyed(aura::Window* window) override {
+  void OnWindowDestroyed(aura::Window* window) override {
     results_->push_back(name_);
   }
 
@@ -457,17 +454,15 @@ class StackingMadrigalLayoutManager : public aura::LayoutManager {
       : root_window_(root_window) {
     root_window_->SetLayoutManager(this);
   }
-  virtual ~StackingMadrigalLayoutManager() {
-  }
+  ~StackingMadrigalLayoutManager() override {}
 
  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 OnChildWindowVisibilityChanged(Window* child,
-                                              bool visible) override {
+  void OnWindowResized() override {}
+  void OnWindowAddedToLayout(Window* child) override {}
+  void OnWillRemoveWindowFromLayout(Window* child) override {}
+  void OnWindowRemovedFromLayout(Window* child) override {}
+  void OnChildWindowVisibilityChanged(Window* child, bool visible) override {
     Window::Windows::const_iterator it = root_window_->children().begin();
     Window* last_window = NULL;
     for (; it != root_window_->children().end(); ++it) {
@@ -481,8 +476,8 @@ class StackingMadrigalLayoutManager : public aura::LayoutManager {
       last_window = *it;
     }
   }
-  virtual void SetChildBounds(Window* child,
-                              const gfx::Rect& requested_bounds) override {
+  void SetChildBounds(Window* child,
+                      const gfx::Rect& requested_bounds) override {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
@@ -497,8 +492,7 @@ class StackingMadrigalVisibilityClient : public aura::client::VisibilityClient {
       : ignored_window_(NULL) {
     aura::client::SetVisibilityClient(root_window, this);
   }
-  virtual ~StackingMadrigalVisibilityClient() {
-  }
+  ~StackingMadrigalVisibilityClient() override {}
 
   void set_ignored_window(Window* ignored_window) {
     ignored_window_ = ignored_window;
@@ -506,7 +500,7 @@ class StackingMadrigalVisibilityClient : public aura::client::VisibilityClient {
 
  private:
   // Overridden from client::VisibilityClient:
-  virtual void UpdateLayerVisibility(Window* window, bool visible) override {
+  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 ce9d55c..77a129f 100644
--- a/ui/wm/core/transient_window_stacking_client.h
+++ b/ui/wm/core/transient_window_stacking_client.h
@@ -16,12 +16,12 @@ class WM_EXPORT TransientWindowStackingClient
     : public aura::client::WindowStackingClient {
  public:
   TransientWindowStackingClient();
-  virtual ~TransientWindowStackingClient();
+  ~TransientWindowStackingClient() override;
 
   // WindowStackingClient:
-  virtual bool AdjustStacking(aura::Window** child,
-                              aura::Window** target,
-                              aura::Window::StackDirection* direction) override;
+  bool AdjustStacking(aura::Window** child,
+                      aura::Window** target,
+                      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 c067496..23a99e7 100644
--- a/ui/wm/core/transient_window_stacking_client_unittest.cc
+++ b/ui/wm/core/transient_window_stacking_client_unittest.cc
@@ -19,15 +19,15 @@ namespace wm {
 class TransientWindowStackingClientTest : public aura::test::AuraTestBase {
  public:
   TransientWindowStackingClientTest() {}
-  virtual ~TransientWindowStackingClientTest() {}
+  ~TransientWindowStackingClientTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     client_.reset(new TransientWindowStackingClient);
     aura::client::SetWindowStackingClient(client_.get());
   }
 
-  virtual void TearDown() override {
+  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 7e5db9f..0b92bc3 100644
--- a/ui/wm/core/user_activity_detector.h
+++ b/ui/wm/core/user_activity_detector.h
@@ -27,7 +27,7 @@ class WM_EXPORT UserActivityDetector : public ui::EventHandler {
   static const int kDisplayPowerChangeIgnoreMouseMs;
 
   UserActivityDetector();
-  virtual ~UserActivityDetector();
+  ~UserActivityDetector() override;
 
   base::TimeTicks last_activity_time() const { return last_activity_time_; }
 
@@ -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;
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
+  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 0273093..71e1f2d 100644
--- a/ui/wm/core/user_activity_detector_unittest.cc
+++ b/ui/wm/core/user_activity_detector_unittest.cc
@@ -26,9 +26,7 @@ class TestUserActivityObserver : public UserActivityObserver {
   void reset_stats() { num_invocations_ = 0; }
 
   // UserActivityObserver implementation.
-  virtual void OnUserActivity(const ui::Event* event) override {
-    num_invocations_++;
-  }
+  void OnUserActivity(const ui::Event* event) override { num_invocations_++; }
 
  private:
   // Number of times that OnUserActivity() has been called.
@@ -40,9 +38,9 @@ class TestUserActivityObserver : public UserActivityObserver {
 class UserActivityDetectorTest : public aura::test::AuraTestBase {
  public:
   UserActivityDetectorTest() {}
-  virtual ~UserActivityDetectorTest() {}
+  ~UserActivityDetectorTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     observer_.reset(new TestUserActivityObserver);
     detector_.reset(new UserActivityDetector);
@@ -52,7 +50,7 @@ class UserActivityDetectorTest : public aura::test::AuraTestBase {
     detector_->set_now_for_test(now_);
   }
 
-  virtual void TearDown() override {
+  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 d29a6da..c6f5258 100644
--- a/ui/wm/core/visibility_controller.h
+++ b/ui/wm/core/visibility_controller.h
@@ -16,7 +16,7 @@ class WM_EXPORT VisibilityController
     : public aura::client::VisibilityClient {
  public:
   VisibilityController();
-  virtual ~VisibilityController();
+  ~VisibilityController() override;
 
  protected:
   // Subclasses override if they want to call a different implementation of
@@ -28,8 +28,7 @@ class WM_EXPORT VisibilityController
 
  private:
   // Overridden from aura::client::VisibilityClient:
-  virtual void UpdateLayerVisibility(aura::Window* window,
-                                     bool visible) override;
+  void UpdateLayerVisibility(aura::Window* window, 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 c523c98..03bb1b9 100644
--- a/ui/wm/core/window_animations.cc
+++ b/ui/wm/core/window_animations.cc
@@ -63,18 +63,18 @@ class HidingWindowAnimationObserverBase : public aura::WindowObserver {
       : window_(window) {
     window_->AddObserver(this);
   }
-  virtual ~HidingWindowAnimationObserverBase() {
+  ~HidingWindowAnimationObserverBase() override {
     if (window_)
       window_->RemoveObserver(this);
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
 
-  virtual void OnWindowDestroyed(aura::Window* window) override {
+  void OnWindowDestroyed(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     WindowInvalid();
   }
@@ -165,10 +165,10 @@ class ImplicitHidingWindowAnimationObserver
   ImplicitHidingWindowAnimationObserver(
       aura::Window* window,
       ui::ScopedLayerAnimationSettings* settings);
-  virtual ~ImplicitHidingWindowAnimationObserver() {}
+  ~ImplicitHidingWindowAnimationObserver() override {}
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() override;
+  void OnImplicitAnimationsCompleted() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImplicitHidingWindowAnimationObserver);
@@ -400,7 +400,7 @@ class RotateHidingWindowAnimationObserver
  public:
   explicit RotateHidingWindowAnimationObserver(aura::Window* window)
       : HidingWindowAnimationObserverBase(window) {}
-  virtual ~RotateHidingWindowAnimationObserver() {}
+  ~RotateHidingWindowAnimationObserver() override {}
 
   // Destroys itself after |last_sequence| ends or is aborted. Does not take
   // ownership of |last_sequence|, which should not be NULL.
@@ -409,15 +409,13 @@ class RotateHidingWindowAnimationObserver
   }
 
   // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {
     OnAnimationCompleted();
   }
-  virtual void OnLayerAnimationScheduled(
+  void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) override {}
 
  private:
diff --git a/ui/wm/core/window_animations_unittest.cc b/ui/wm/core/window_animations_unittest.cc
index b1db736..095ea02 100644
--- a/ui/wm/core/window_animations_unittest.cc
+++ b/ui/wm/core/window_animations_unittest.cc
@@ -47,9 +47,7 @@ class WindowAnimationsTest : public aura::test::AuraTestBase {
  public:
   WindowAnimationsTest() {}
 
-  virtual void TearDown() override {
-    AuraTestBase::TearDown();
-  }
+  void TearDown() override { AuraTestBase::TearDown(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowAnimationsTest);
@@ -255,16 +253,13 @@ TEST_F(WindowAnimationsTest, HideAnimationDetachLayersWithTransientChildren) {
 class NotifyHideCompletedAnimationHost : public aura::client::AnimationHost {
  public:
   NotifyHideCompletedAnimationHost() : hide_completed_(false) {}
-  virtual ~NotifyHideCompletedAnimationHost() {}
+  ~NotifyHideCompletedAnimationHost() override {}
 
   // Overridden from TestWindowDelegate:
-  virtual void OnWindowHidingAnimationCompleted() override {
-    hide_completed_ = true;
-  }
+  void OnWindowHidingAnimationCompleted() override { hide_completed_ = true; }
 
-  virtual void SetHostTransitionOffsets(
-      const gfx::Vector2d& top_left,
-      const gfx::Vector2d& bottom_right) override {}
+  void SetHostTransitionOffsets(const gfx::Vector2d& top_left,
+                                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 33386ce..1b3baaf 100644
--- a/ui/wm/core/window_modality_controller.h
+++ b/ui/wm/core/window_modality_controller.h
@@ -35,23 +35,22 @@ class WM_EXPORT WindowModalityController : public ui::EventHandler,
                                            public aura::WindowObserver {
  public:
   explicit WindowModalityController(ui::EventTarget* event_target);
-  virtual ~WindowModalityController();
+  ~WindowModalityController() override;
 
   // 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;
+  void OnKeyEvent(ui::KeyEvent* event) override;
+  void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Overridden from aura::EnvObserver:
-  virtual void OnWindowInitialized(aura::Window* window) override;
+  void OnWindowInitialized(aura::Window* window) override;
 
   // Overridden from aura::WindowObserver:
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) override;
-  virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) override;
-  virtual void OnWindowDestroyed(aura::Window* window) override;
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override;
+  void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
+  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 1022788..82d9879 100644
--- a/ui/wm/public/scoped_tooltip_disabler.h
+++ b/ui/wm/public/scoped_tooltip_disabler.h
@@ -17,14 +17,14 @@ class AURA_EXPORT ScopedTooltipDisabler : aura::WindowObserver {
   // are reenabled from the destructor when there are no most outstanding
   // ScopedTooltipDisablers for |window|.
   explicit ScopedTooltipDisabler(aura::Window* window);
-  virtual ~ScopedTooltipDisabler();
+  ~ScopedTooltipDisabler() override;
 
  private:
   // Reenables the tooltips on the TooltipClient.
   void EnableTooltips();
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override;
+  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 a0ac59d..ebc0d51 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 {
+  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 {
+  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 990b478..9b92e28 100644
--- a/ui/wm/test/wm_test_helper.h
+++ b/ui/wm/test/wm_test_helper.h
@@ -40,14 +40,14 @@ class WMTestHelper : public aura::client::WindowTreeClient {
  public:
   WMTestHelper(const gfx::Size& default_window_size,
                ui::ContextFactory* context_factory);
-  virtual ~WMTestHelper();
+  ~WMTestHelper() override;
 
   aura::WindowTreeHost* host() { return host_.get(); }
 
   // Overridden from client::WindowTreeClient:
-  virtual aura::Window* GetDefaultParent(aura::Window* context,
-                                         aura::Window* window,
-                                         const gfx::Rect& bounds) override;
+  aura::Window* GetDefaultParent(aura::Window* context,
+                                 aura::Window* window,
+                                 const gfx::Rect& bounds) override;
 
  private:
   scoped_ptr<aura::WindowTreeHost> host_;
author	dcheng <dcheng@chromium.org>	2014-10-27 14:15:05 -0700
committer	Commit bot <commit-bot@chromium.org>	2014-10-27 21:15:27 +0000
commit	a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2 (patch)
tree	dd1e6ceb329119b972818c7b9d83caf11f598d95 /ui
parent	f6ae4499e0072dec50a75ba0718adfdbfa6c5c9f (diff)
download	chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.zip chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.tar.gz chromium_src-a74e3540d4fd6c65b9b97d879d0a346ed2c60cd2.tar.bz2