replace OVERRIDE and FINAL with override and final in ash/

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 45 matching lines @@
   }
 
   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;
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
+  virtual 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() {}
 
   virtual bool HandleBrightnessDown(
-      const ui::Accelerator& accelerator) OVERRIDE {
+      const ui::Accelerator& accelerator) override {
     ++handle_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleBrightnessUp(const ui::Accelerator& accelerator) OVERRIDE {
+  virtual 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 SetBrightnessPercent(double percent, bool gradual) override {}
   virtual void GetBrightnessPercent(
-      const base::Callback<void(double)>& callback) OVERRIDE {
+      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_;
   }
   const ui::Accelerator& last_accelerator() const {
@@ skipping 12 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() {}
 
-  virtual void HandleNextIme() OVERRIDE {
+  virtual void HandleNextIme() override {
     ++handle_next_ime_count_;
   }
-  virtual bool HandlePreviousIme(const ui::Accelerator& accelerator) OVERRIDE {
+  virtual bool HandlePreviousIme(const ui::Accelerator& accelerator) override {
     ++handle_previous_ime_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
-  virtual bool HandleSwitchIme(const ui::Accelerator& accelerator) OVERRIDE {
+  virtual 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(
-      const ui::Accelerator& accelerator) OVERRIDE {
+      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() {}
 
   virtual bool HandleKeyboardBrightnessDown(
-      const ui::Accelerator& accelerator) OVERRIDE {
+      const ui::Accelerator& accelerator) override {
     ++handle_keyboard_brightness_down_count_;
     last_accelerator_ = accelerator;
     return consume_;
   }
 
   virtual bool HandleKeyboardBrightnessUp(
-      const ui::Accelerator& accelerator) OVERRIDE {
+      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 885 matching lines @@
 }
 
 namespace {
 
 class PreferredReservedAcceleratorsTest : public test::AshTestBase {
  public:
   PreferredReservedAcceleratorsTest() {}
   virtual ~PreferredReservedAcceleratorsTest() {}
 
   // test::AshTestBase:
-  virtual void SetUp() OVERRIDE {
+  virtual 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 208 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