Standardize usage of virtual/override/final specifiers.

ash/accelerators/accelerator_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 "ash/accelerators/accelerator_controller.h"
 
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 33 matching lines @@
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 namespace ash {
 
 namespace {
 
 class TestTarget : public ui::AcceleratorTarget {
  public:
   TestTarget() : accelerator_pressed_count_(0), accelerator_repeat_count_(0) {}
-  virtual ~TestTarget() {}
+  ~TestTarget() override {}
 
   int accelerator_pressed_count() const {
     return accelerator_pressed_count_;
   }
 
   int accelerator_repeat_count() const { return accelerator_repeat_count_; }
 
   void reset() {
     accelerator_pressed_count_ = 0;
     accelerator_repeat_count_ = 0;
   }
 
   // Overridden from ui::AcceleratorTarget:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
-  virtual bool CanHandleAccelerators() const override;
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
+  bool CanHandleAccelerators() const override;
 
  private:
   int accelerator_pressed_count_;
   int accelerator_repeat_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTarget);
 };
 
 class ReleaseAccelerator : public ui::Accelerator {
  public:
   ReleaseAccelerator(ui::KeyboardCode keycode, int modifiers)
       : ui::Accelerator(keycode, modifiers) {
     set_type(ui::ET_KEY_RELEASED);
   }
 };
 
 class DummyBrightnessControlDelegate : public BrightnessControlDelegate {
  public:
   explicit DummyBrightnessControlDelegate(bool consume)
       : consume_(consume),
         handle_brightness_down_count_(0),
         handle_brightness_up_count_(0) {
   }
-  virtual ~DummyBrightnessControlDelegate() {}
+  ~DummyBrightnessControlDelegate() override {}
 
-  virtual bool HandleBrightnessDown(
-      const ui::Accelerator& accelerator) override {
+  bool HandleBrightnessDown(const ui::Accelerator& accelerator) override {
     ++handle_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleBrightnessUp(const ui::Accelerator& accelerator) override {
+  bool HandleBrightnessUp(const ui::Accelerator& accelerator) override {
     ++handle_brightness_up_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual void SetBrightnessPercent(double percent, bool gradual) override {}
-  virtual void GetBrightnessPercent(
+  void SetBrightnessPercent(double percent, bool gradual) override {}
+  void GetBrightnessPercent(
       const base::Callback<void(double)>& callback) override {
     callback.Run(100.0);
   }
 
   int handle_brightness_down_count() const {
     return handle_brightness_down_count_;
   }
   int handle_brightness_up_count() const {
     return handle_brightness_up_count_;
   }
@@ skipping 11 matching lines @@
 };
 
 class DummyImeControlDelegate : public ImeControlDelegate {
  public:
   explicit DummyImeControlDelegate(bool consume)
       : consume_(consume),
         handle_next_ime_count_(0),
         handle_previous_ime_count_(0),
         handle_switch_ime_count_(0) {
   }
-  virtual ~DummyImeControlDelegate() {}
+  ~DummyImeControlDelegate() override {}
 
-  virtual void HandleNextIme() override {
-    ++handle_next_ime_count_;
-  }
-  virtual bool HandlePreviousIme(const ui::Accelerator& accelerator) override {
+  void HandleNextIme() override { ++handle_next_ime_count_; }
+  bool HandlePreviousIme(const ui::Accelerator& accelerator) override {
     ++handle_previous_ime_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleSwitchIme(const ui::Accelerator& accelerator) override {
+  bool HandleSwitchIme(const ui::Accelerator& accelerator) override {
     ++handle_switch_ime_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
 
   int handle_next_ime_count() const {
     return handle_next_ime_count_;
   }
   int handle_previous_ime_count() const {
     return handle_previous_ime_count_;
   }
   int handle_switch_ime_count() const {
     return handle_switch_ime_count_;
   }
   const ui::Accelerator& last_accelerator() const {
     return last_accelerator_;
   }
-  virtual ui::Accelerator RemapAccelerator(
+  ui::Accelerator RemapAccelerator(
       const ui::Accelerator& accelerator) override {
     return ui::Accelerator(accelerator);
   }
 
  private:
   const bool consume_;
   int handle_next_ime_count_;
   int handle_previous_ime_count_;
   int handle_switch_ime_count_;
   ui::Accelerator last_accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(DummyImeControlDelegate);
 };
 
 class DummyKeyboardBrightnessControlDelegate
     : public KeyboardBrightnessControlDelegate {
  public:
   explicit DummyKeyboardBrightnessControlDelegate(bool consume)
       : consume_(consume),
         handle_keyboard_brightness_down_count_(0),
         handle_keyboard_brightness_up_count_(0) {
   }
-  virtual ~DummyKeyboardBrightnessControlDelegate() {}
+  ~DummyKeyboardBrightnessControlDelegate() override {}
 
-  virtual bool HandleKeyboardBrightnessDown(
+  bool HandleKeyboardBrightnessDown(
       const ui::Accelerator& accelerator) override {
     ++handle_keyboard_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
 
-  virtual bool HandleKeyboardBrightnessUp(
-      const ui::Accelerator& accelerator) override {
+  bool HandleKeyboardBrightnessUp(const ui::Accelerator& accelerator) override {
     ++handle_keyboard_brightness_up_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
 
   int handle_keyboard_brightness_down_count() const {
     return handle_keyboard_brightness_down_count_;
   }
 
   int handle_keyboard_brightness_up_count() const {
@@ skipping 23 matching lines @@
 
 bool TestTarget::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace
 
 class AcceleratorControllerTest : public test::AshTestBase {
  public:
   AcceleratorControllerTest() {}
-  virtual ~AcceleratorControllerTest() {}
+  ~AcceleratorControllerTest() override {}
 
  protected:
   void EnableInternalDisplay() {
     test::DisplayManagerTestApi(Shell::GetInstance()->display_manager()).
         SetFirstDisplayAsInternalDisplay();
   }
 
   static AcceleratorController* GetController();
 
   // Several functions to access ExitWarningHandler (as friend).
@@ skipping 991 matching lines @@
       ui::Accelerator(ui::VKEY_A, ui::EF_NONE)));
   EXPECT_FALSE(GetController()->IsPreferred(
       ui::Accelerator(ui::VKEY_A, ui::EF_NONE)));
 }
 
 namespace {
 
 class PreferredReservedAcceleratorsTest : public test::AshTestBase {
  public:
   PreferredReservedAcceleratorsTest() {}
-  virtual ~PreferredReservedAcceleratorsTest() {}
+  ~PreferredReservedAcceleratorsTest() override {}
 
   // test::AshTestBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     Shell::GetInstance()->lock_state_controller()->
         set_animator_for_test(new test::TestSessionStateAnimator);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PreferredReservedAcceleratorsTest);
 };
 
 }  // namespace
@@ skipping 202 matching lines @@
     window.reset(CreateTestWindowInShellWithBounds(gfx::Rect(5, 5, 20, 20)));
     wm::ActivateWindow(window.get());
     GetController()->PerformAction(WINDOW_MINIMIZE, dummy);
     delegate->TriggerAccessibilityAlert(A11Y_ALERT_NONE);
     GetController()->PerformAction(kActionsNeedingWindow[i], dummy);
     EXPECT_NE(delegate->GetLastAccessibilityAlert(), A11Y_ALERT_WINDOW_NEEDED);
   }
 }
 
 }  // namespace ash