replace OVERRIDE and FINAL with override and final in ui/

ui/keyboard/keyboard_controller_unittest.cc

 // Copyright (c) 2013 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/keyboard/keyboard_controller.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 50 matching lines @@
       : root_(root) {
     root_->AddPreTargetHandler(this);
   }
 
   virtual ~TestFocusController() {
     root_->RemovePreTargetHandler(this);
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     if (event->type() == ui::ET_MOUSE_PRESSED ||
         event->type() == ui::ET_TOUCH_PRESSED) {
       aura::client::GetFocusClient(target)->FocusWindow(target);
     }
   }
 
   aura::Window* root_;
   DISALLOW_COPY_AND_ASSIGN(TestFocusController);
 };
 
 class TestKeyboardControllerProxy : public KeyboardControllerProxy {
  public:
   TestKeyboardControllerProxy()
       : input_method_(
             ui::CreateInputMethod(NULL, gfx::kNullAcceleratedWidget)) {}
 
   virtual ~TestKeyboardControllerProxy() {
     // Destroy the window before the delegate.
     window_.reset();
   }
 
   // Overridden from KeyboardControllerProxy:
-  virtual bool HasKeyboardWindow() const OVERRIDE { return window_; }
-  virtual aura::Window* GetKeyboardWindow() OVERRIDE {
+  virtual bool HasKeyboardWindow() const override { return window_; }
+  virtual aura::Window* GetKeyboardWindow() override {
     if (!window_) {
       window_.reset(new aura::Window(&delegate_));
       window_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
       window_->set_owned_by_parent(false);
     }
     return window_.get();
   }
-  virtual content::BrowserContext* GetBrowserContext() OVERRIDE { return NULL; }
-  virtual ui::InputMethod* GetInputMethod() OVERRIDE {
+  virtual content::BrowserContext* GetBrowserContext() override { return NULL; }
+  virtual ui::InputMethod* GetInputMethod() override {
     return input_method_.get();
   }
   virtual void RequestAudioInput(content::WebContents* web_contents,
       const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) OVERRIDE { return; }
-  virtual void LoadSystemKeyboard() OVERRIDE {};
-  virtual void ReloadKeyboardIfNeeded() OVERRIDE {};
+      const content::MediaResponseCallback& callback) override { return; }
+  virtual void LoadSystemKeyboard() override {};
+  virtual void ReloadKeyboardIfNeeded() override {};
 
  private:
   scoped_ptr<aura::Window> window_;
   aura::test::TestWindowDelegate delegate_;
   scoped_ptr<ui::InputMethod> input_method_;
 
   DISALLOW_COPY_AND_ASSIGN(TestKeyboardControllerProxy);
 };
 
 // Keeps a count of all the events a window receives.
 class EventObserver : public ui::EventHandler {
  public:
   EventObserver() {}
   virtual ~EventObserver() {}
 
   int GetEventCount(ui::EventType type) {
     return event_counts_[type];
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     ui::EventHandler::OnEvent(event);
     event_counts_[event->type()]++;
   }
 
   std::map<ui::EventType, int> event_counts_;
   DISALLOW_COPY_AND_ASSIGN(EventObserver);
 };
 
 class KeyboardContainerObserver : public aura::WindowObserver {
  public:
   explicit KeyboardContainerObserver(aura::Window* window) : window_(window) {
     window_->AddObserver(this);
   }
   virtual ~KeyboardContainerObserver() {
     window_->RemoveObserver(this);
   }
 
  private:
   virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) OVERRIDE {
+                                         bool visible) override {
     if (!visible)
       base::MessageLoop::current()->Quit();
   }
 
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
 };
 
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test {
  public:
   KeyboardControllerTest() {}
   virtual ~KeyboardControllerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // The ContextFactory must exist before any Compositors are created.
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
         ui::InitializeContextFactoryForTests(enable_pixel_output);
 
     aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
     aura_test_helper_->SetUp(context_factory);
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
     ui::SetUpInputMethodFactoryForTesting();
     if (::switches::IsTextInputFocusManagerEnabled())
       ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(NULL);
     focus_controller_.reset(new TestFocusController(root_window()));
     proxy_ = new TestKeyboardControllerProxy();
     controller_.reset(new KeyboardController(proxy_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     controller_.reset();
     focus_controller_.reset();
     if (::switches::IsTextInputFocusManagerEnabled())
       ui::TextInputFocusManager::GetInstance()->FocusTextInputClient(NULL);
     aura_test_helper_->TearDown();
     ui::TerminateContextFactoryForTests();
   }
 
   aura::Window* root_window() { return aura_test_helper_->root_window(); }
   KeyboardControllerProxy* proxy() { return proxy_; }
@@ skipping 293 matching lines @@
   base::MessageLoop::current()->Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
 }
 
 class KeyboardControllerAnimationTest : public KeyboardControllerTest,
                                         public KeyboardControllerObserver {
  public:
   KeyboardControllerAnimationTest() {}
   virtual ~KeyboardControllerAnimationTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // We cannot short-circuit animations for this test.
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
     KeyboardControllerTest::SetUp();
 
     const gfx::Rect& root_bounds = root_window()->bounds();
     keyboard_container()->SetBounds(root_bounds);
     root_window()->AddChild(keyboard_container());
     controller()->AddObserver(this);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     controller()->RemoveObserver(this);
     KeyboardControllerTest::TearDown();
   }
 
  protected:
   // KeyboardControllerObserver overrides
-  virtual void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) OVERRIDE {
+  virtual void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override {
     notified_bounds_ = new_bounds;
   }
 
   const gfx::Rect& notified_bounds() { return notified_bounds_; }
 
   aura::Window* keyboard_container() {
     return controller()->GetContainerWindow();
   }
 
   aura::Window* keyboard_window() {
@@ skipping 63 matching lines @@
   // Before hide animation finishes, show keyboard again.
   ShowKeyboard();
   RunAnimationForLayer(layer);
   EXPECT_TRUE(keyboard_container()->IsVisible());
   EXPECT_TRUE(keyboard_window()->IsVisible());
   EXPECT_EQ(1.0, layer->opacity());
   EXPECT_EQ(gfx::Transform(), layer->transform());
 }
 
 }  // namespace keyboard