Standardize usage of virtual/override/final specifiers.

ui/wm/core/focus_controller_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/wm/core/focus_controller.h"
 
 #include <map>
 
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/default_capture_client.h"
@@ skipping 19 matching lines @@
 
 class FocusNotificationObserver : public aura::client::ActivationChangeObserver,
                                   public aura::client::FocusChangeObserver {
  public:
   FocusNotificationObserver()
       : activation_changed_count_(0),
         focus_changed_count_(0),
         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_);
     EXPECT_EQ(focus_changed_count, focus_changed_count_);
   }
   int reactivation_count() const {
     return reactivation_count_;
   }
   aura::Window* reactivation_requested_window() const {
     return reactivation_requested_window_;
   }
   aura::Window* reactivation_actual_window() const {
     return reactivation_actual_window_;
   }
 
  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_;
   }
 
   int activation_changed_count_;
   int focus_changed_count_;
   int reactivation_count_;
   aura::Window* reactivation_requested_window_;
   aura::Window* reactivation_actual_window_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusNotificationObserver);
@@ skipping 15 matching lines @@
       public aura::client::FocusChangeObserver {
  public:
   RecordingActivationAndFocusChangeObserver(aura::Window* root,
                                             WindowDeleter* deleter)
       : root_(root),
         deleter_(deleter),
         was_notified_with_deleted_window_(false) {
     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);
   }
 
   bool was_notified_with_deleted_window() const {
     return was_notified_with_deleted_window_;
   }
 
   // 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;
   }
 
  private:
   aura::Window* root_;
 
   // Not owned.
   WindowDeleter* deleter_;
 
   // Whether the observer was notified about the loss of activation or the
   // loss of focus with a window already deleted by |deleter_| as the
   // |lost_active| or |lost_focus| parameter.
   bool was_notified_with_deleted_window_;
 
   DISALLOW_COPY_AND_ASSIGN(RecordingActivationAndFocusChangeObserver);
 };
 
 // ActivationChangeObserver that deletes the window losing activation.
 class DeleteOnLoseActivationChangeObserver :
     public aura::client::ActivationChangeObserver,
     public WindowDeleter {
  public:
   explicit DeleteOnLoseActivationChangeObserver(aura::Window* window)
       : root_(window->GetRootWindow()),
         window_(window),
         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;
     }
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() override {
+  aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
  private:
   aura::Window* root_;
   aura::Window* window_;
   bool did_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseActivationChangeObserver);
 };
 
 // FocusChangeObserver that deletes the window losing focus.
 class DeleteOnLoseFocusChangeObserver
     : public aura::client::FocusChangeObserver,
       public WindowDeleter {
  public:
   explicit DeleteOnLoseFocusChangeObserver(aura::Window* window)
       : root_(window->GetRootWindow()),
         window_(window),
         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;
     }
   }
 
   // Overridden from WindowDeleter:
-  virtual aura::Window* GetDeletedWindow() override {
+  aura::Window* GetDeletedWindow() override {
     return did_delete_ ? window_ : NULL;
   }
 
  private:
   aura::Window* root_;
   aura::Window* window_;
   bool did_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteOnLoseFocusChangeObserver);
 };
 
 class ScopedFocusNotificationObserver : public FocusNotificationObserver {
  public:
   ScopedFocusNotificationObserver(aura::Window* root_window)
       : root_window_(root_window) {
     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);
   }
 
  private:
   aura::Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedFocusNotificationObserver);
 };
 
 class ScopedTargetFocusNotificationObserver : public FocusNotificationObserver {
  public:
   ScopedTargetFocusNotificationObserver(aura::Window* root_window, int id)
       : target_(root_window->GetChildById(id)) {
     aura::client::SetActivationChangeObserver(target_, this);
     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);
     }
   }
 
  private:
   aura::Window* target_;
   aura::WindowTracker tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedTargetFocusNotificationObserver);
 };
 
 class ScopedFocusedTextInputClientChanger
     : public ScopedFocusNotificationObserver {
  public:
   ScopedFocusedTextInputClientChanger(aura::Window* root_window,
                                       ui::TextInputClient* text_input_client)
       : ScopedFocusNotificationObserver(root_window),
         text_input_client_(text_input_client) {}
 
  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_);
   }
 
   ui::TextInputClient* text_input_client_;
 };
 
 // Used to fake the handling of events in the pre-target phase.
 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);
 };
 
 class FocusShiftingActivationObserver
     : public aura::client::ActivationChangeObserver {
  public:
   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;
   }
 
  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_) {
       aura::client::FocusClient* client =
           aura::client::GetFocusClient(gained_active);
       client->FocusWindow(shift_focus_to_);
     }
   }
 
   aura::Window* activated_window_;
   aura::Window* shift_focus_to_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusShiftingActivationObserver);
 };
 
 // BaseFocusRules subclass that allows basic overrides of focus/activation to
 // be tested. This is intended more as a test that the override system works at
 // all, rather than as an exhaustive set of use cases, those should be covered
 // in tests for those FocusRules implementations.
 class TestFocusRules : public BaseFocusRules {
  public:
   TestFocusRules() : focus_restriction_(NULL) {}
 
   // Restricts focus and activation to this window and its child hierarchy.
   void set_focus_restriction(aura::Window* focus_restriction) {
     focus_restriction_ = focus_restriction;
   }
 
   // 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) ?
         next_activatable : GetActivatableWindow(focus_restriction_);
   }
 
  private:
   bool CanFocusOrActivate(aura::Window* window) const {
     return !focus_restriction_ || focus_restriction_->Contains(window);
   }
 
   aura::Window* focus_restriction_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFocusRules);
 };
 
 // Common infrastructure shared by all FocusController test types.
 class FocusControllerTestBase : public aura::test::AuraTestBase {
  protected:
   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
     // before allowing the base setup.
     test_focus_rules_ = new TestFocusRules;
     focus_controller_.reset(new FocusController(test_focus_rules_));
     aura::test::AuraTestBase::SetUp();
     root_window()->AddPreTargetHandler(focus_controller_.get());
     aura::client::SetFocusClient(root_window(), focus_controller_.get());
     aura::client::SetActivationClient(root_window(), focus_controller_.get());
@@ skipping 22 matching lines @@
     aura::Window* w21 = aura::test::CreateTestWindowWithDelegate(
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 21,
         gfx::Rect(5, 5, 10, 10), w2);
     aura::test::CreateTestWindowWithDelegate(
         aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(), 211,
         gfx::Rect(1, 1, 5, 5), w21);
     aura::test::CreateTestWindowWithDelegate(
         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.
     focus_controller_.reset();
     wm_state_.reset();
   }
 
   void FocusWindow(aura::Window* window) {
     aura::client::GetFocusClient(root_window())->FocusWindow(window);
   }
@@ skipping 67 matching lines @@
     DCHECK(window);
     FocusWindowDirect(window);
   }
   void ActivateWindowById(int id) {
     aura::Window* window = root_window()->GetChildById(id);
     DCHECK(window);
     ActivateWindowDirect(window);
   }
 
   // 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());
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
     // Verify that attempting to deactivate NULL does not crash and does not
     // change activation.
     DeactivateWindow(NULL);
     EXPECT_EQ(2, GetActiveWindowId());
     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);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
 
     FocusWindowById(1);
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(0, 0);
 
     FocusWindowById(2);
     root_observer.ExpectCounts(2, 2);
     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);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
 
     FocusWindowById(1);
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
 
     FocusWindowById(1);
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
   }
-  virtual void ActivationEvents() override {
+  void ActivationEvents() override {
     ActivateWindowById(1);
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
 
     ActivateWindowById(2);
     root_observer.ExpectCounts(1, 1);
     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());
     root_window()->GetChildById(2)->Hide();
     // When we attempt to activate "2", which cannot be activated because it
     // is not visible, "1" will be reactivated.
     ActivateWindowById(2);
     EXPECT_EQ(1, root_observer.reactivation_count());
     EXPECT_EQ(root_window()->GetChildById(2),
               root_observer.reactivation_requested_window());
     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);
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer1(root_window(), 1);
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
 
     root_observer.ExpectCounts(0, 0);
     observer1.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
 
     ActivateWindowById(2);
     root_observer.ExpectCounts(1, 1);
     observer1.ExpectCounts(1, 1);
     observer2.ExpectCounts(1, 1);
 
     ActivateWindowById(2);
     root_observer.ExpectCounts(1, 1);
     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());
     FocusWindowById(11);
     EXPECT_EQ(11, GetFocusedWindowId());
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToChildOfInactiveWindow() override {
+  void ShiftFocusToChildOfInactiveWindow() override {
     ActivateWindowById(2);
     EXPECT_EQ(2, GetActiveWindowId());
     EXPECT_EQ(2, GetFocusedWindowId());
     FocusWindowById(11);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(11, GetFocusedWindowId());
   }
-  virtual void ShiftFocusToParentOfFocusedWindow() override {
+  void ShiftFocusToParentOfFocusedWindow() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
     FocusWindowById(11);
     EXPECT_EQ(11, GetFocusedWindowId());
     FocusWindowById(1);
     // 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());
 
     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(211));
     FocusWindowById(12);
     // Input events leave focus unchanged; direct API calls will change focus
     // to the restricted window.
     int focused_window = IsInputEvent() ? 11 : 211;
     EXPECT_EQ(focused_window, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
     FocusWindowById(12);
     EXPECT_EQ(12, GetFocusedWindowId());
   }
-  virtual void ActivationRulesOverride() override {
+  void ActivationRulesOverride() override {
     ActivateWindowById(1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w3 = root_window()->GetChildById(3);
     test_focus_rules()->set_focus_restriction(w3);
 
     ActivateWindowById(2);
     // Input events leave activation unchanged; direct API calls will activate
     // the restricted window.
     int active_window = IsInputEvent() ? 1 : 3;
     EXPECT_EQ(active_window, GetActiveWindowId());
     EXPECT_EQ(active_window, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(NULL);
     ActivateWindowById(2);
     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.
     ActivateWindowById(2);
     EXPECT_EQ(2, GetFocusedWindowId());
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
 
     ActivateWindowById(2);
 
@@ skipping 21 matching lines @@
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
 
     client->RemoveObserver(observer.get());
 
     ActivateWindowById(2);
     EXPECT_EQ(2, GetFocusedWindowId());
     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);
     EXPECT_EQ(1, GetFocusedWindowId());
 
     // Removes window 3 as candidate for next activatable window.
     root_window()->GetChildById(3)->Hide();
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* target = root_window()->GetChildById(2);
     aura::client::ActivationClient* client =
         aura::client::GetActivationClient(root_window());
 
     scoped_ptr<FocusShiftingActivationObserver> observer(
         new FocusShiftingActivationObserver(target));
     observer->set_shift_focus_to(target->GetChildById(21));
     client->AddObserver(observer.get());
 
     // Hide the active window.
     root_window()->GetChildById(1)->Hide();
 
     EXPECT_EQ(21, GetFocusedWindowId());
 
     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
     // to the window. This test verifies whether that is indeed the case.
     ActivateWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w2 = root_window()->GetChildById(2);
     aura::client::GetCaptureClient(root_window())->SetCapture(w2);
     ui::test::EventGenerator generator(root_window(), w2);
     generator.ClickLeftButton();
 
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
     aura::client::GetCaptureClient(root_window())->ReleaseCapture(w2);
   }
 
   // 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);
     aura::client::GetCaptureClient(root_window())->SetCapture(w1);
 
     EXPECT_EQ(-1, GetActiveWindowId());
     EXPECT_EQ(-1, GetFocusedWindowId());
 
     FocusWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::client::GetCaptureClient(root_window())->ReleaseCapture(w1);
   }
 
   // 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());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     {
       aura::Window* to_delete = root_window()->GetChildById(1);
       DeleteOnLoseActivationChangeObserver observer1(to_delete);
       RecordingActivationAndFocusChangeObserver observer2(root_window(),
                                                           &observer1);
@@ skipping 18 matching lines @@
       EXPECT_EQ(3, GetActiveWindowId());
       EXPECT_EQ(3, GetFocusedWindowId());
 
       EXPECT_EQ(to_delete, observer1.GetDeletedWindow());
       EXPECT_FALSE(observer2.was_notified_with_deleted_window());
     }
   }
 
   // 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;
     ui::TextInputClient* null_text_input_client = NULL;
 
     EXPECT_EQ(null_text_input_client,
               text_input_focus_manager->GetFocusedTextInputClient());
 
     text_input_focus_manager->FocusTextInputClient(&text_input_client);
     EXPECT_EQ(&text_input_client,
@@ skipping 23 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FocusControllerDirectTestBase);
 };
 
 // Focus and Activation changes via aura::client::ActivationClient API.
 class FocusControllerApiTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerApiTest() {}
 
  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);
 };
 
 // Focus and Activation changes via input events.
 class FocusControllerMouseEventTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerMouseEventTest() {}
 
   // Tests that a handled mouse or gesture event does not trigger a window
   // activation.
   void IgnoreHandledEvent() {
     EXPECT_EQ(NULL, GetActiveWindow());
     aura::Window* w1 = root_window()->GetChildById(1);
     SimpleEventHandler handler;
     root_window()->PrependPreTargetHandler(&handler);
     ui::test::EventGenerator generator(root_window(), w1);
     generator.ClickLeftButton();
     EXPECT_EQ(NULL, GetActiveWindow());
     generator.GestureTapAt(w1->bounds().CenterPoint());
     EXPECT_EQ(NULL, GetActiveWindow());
     root_window()->RemovePreTargetHandler(&handler);
     generator.ClickLeftButton();
     EXPECT_EQ(1, GetActiveWindowId());
   }
 
  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);
 };
 
 class FocusControllerGestureEventTest : public FocusControllerDirectTestBase {
  public:
   FocusControllerGestureEventTest() {}
 
  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);
 };
 
 // Test base for tests where focus is implicitly set to a window as the result
 // of a disposition change to the focused window or the hierarchy that contains
 // it.
 class FocusControllerImplicitTestBase : public FocusControllerTestBase {
  protected:
   explicit FocusControllerImplicitTestBase(bool parent) : parent_(parent) {}
 
   aura::Window* GetDispositionWindow(aura::Window* window) {
     return parent_ ? window->parent() : window;
   }
 
   // Change the disposition of |window| in such a way as it will lose focus.
   virtual void ChangeWindowDisposition(aura::Window* window) = 0;
 
   // Allow each disposition change test to add additional post-disposition
   // change expectations.
   virtual void PostDispostionChangeExpectations() {}
 
   // Overridden from FocusControllerTestBase:
-  virtual void BasicFocus() override {
+  void BasicFocus() override {
     EXPECT_EQ(NULL, GetFocusedWindow());
 
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
     EXPECT_EQ(211, GetFocusedWindowId());
 
     ChangeWindowDisposition(w211);
     // 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());
 
     aura::Window* w2 = root_window()->GetChildById(2);
     ActivateWindow(w2);
     EXPECT_EQ(2, GetActiveWindowId());
 
     ChangeWindowDisposition(w2);
     EXPECT_EQ(3, GetActiveWindowId());
     PostDispostionChangeExpectations();
   }
-  virtual void FocusEvents() override {
+  void FocusEvents() override {
     aura::Window* w211 = root_window()->GetChildById(211);
     FocusWindow(w211);
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer211(root_window(), 211);
     root_observer.ExpectCounts(0, 0);
     observer211.ExpectCounts(0, 0);
 
     ChangeWindowDisposition(w211);
     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);
     ActivateWindow(w2);
 
     ScopedFocusNotificationObserver root_observer(root_window());
     ScopedTargetFocusNotificationObserver observer2(root_window(), 2);
     ScopedTargetFocusNotificationObserver observer3(root_window(), 3);
     root_observer.ExpectCounts(0, 0);
     observer2.ExpectCounts(0, 0);
     observer3.ExpectCounts(0, 0);
 
     ChangeWindowDisposition(w2);
     root_observer.ExpectCounts(1, 1);
     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);
     EXPECT_EQ(211, GetFocusedWindowId());
 
     test_focus_rules()->set_focus_restriction(root_window()->GetChildById(11));
     ChangeWindowDisposition(w211);
     // Normally, focus would shift to the parent (w21) but the override shifts
     // it to 11.
     EXPECT_EQ(11, GetFocusedWindowId());
 
     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);
     ActivateWindow(w1);
 
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w3 = root_window()->GetChildById(3);
     test_focus_rules()->set_focus_restriction(w3);
@@ skipping 22 matching lines @@
 // Focus and Activation changes in response to window visibility changes.
 class FocusControllerHideTest : public FocusControllerImplicitTestBase {
  public:
   FocusControllerHideTest() : FocusControllerImplicitTestBase(false) {}
 
  protected:
   FocusControllerHideTest(bool parent)
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) override {
+  void ChangeWindowDisposition(aura::Window* window) override {
     GetDispositionWindow(window)->Hide();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusControllerHideTest);
 };
 
 // Focus and Activation changes in response to window parent visibility
 // changes.
 class FocusControllerParentHideTest : public FocusControllerHideTest {
  public:
   FocusControllerParentHideTest() : FocusControllerHideTest(true) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusControllerParentHideTest);
 };
 
 // Focus and Activation changes in response to window destruction.
 class FocusControllerDestructionTest : public FocusControllerImplicitTestBase {
  public:
   FocusControllerDestructionTest() : FocusControllerImplicitTestBase(false) {}
 
  protected:
   FocusControllerDestructionTest(bool parent)
       : FocusControllerImplicitTestBase(parent) {}
 
   // Overridden from FocusControllerImplicitTestBase:
-  virtual void ChangeWindowDisposition(aura::Window* window) override {
+  void ChangeWindowDisposition(aura::Window* window) override {
     delete GetDispositionWindow(window);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusControllerDestructionTest);
 };
 
 // Focus and Activation changes in response to window parent destruction.
 class FocusControllerParentDestructionTest
     : public FocusControllerDestructionTest {
  public:
   FocusControllerParentDestructionTest()
       : FocusControllerDestructionTest(true) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusControllerParentDestructionTest);
 };
 
 // Focus and Activation changes in response to window removal.
 class FocusControllerRemovalTest : public FocusControllerImplicitTestBase {
  public:
   FocusControllerRemovalTest() : FocusControllerImplicitTestBase(false) {}
 
  protected:
   FocusControllerRemovalTest(bool parent)
       : 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();
   }
 
  private:
   scoped_ptr<aura::Window> window_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerRemovalTest);
 };
 
@@ skipping 104 matching lines @@
 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, DontPassDeletedWindow);
 
 // - Verifies that the focused text input client is cleard when the window focus
 //   changes.
 ALL_FOCUS_TESTS(FocusedTextInputClient);
 
 // If a mouse event was handled, it should not activate a window.
 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
 
 }  // namespace wm