replace OVERRIDE and FINAL with override and final in ash/

ash/wm/window_manager_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/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_activation_delegate.h"
 #include "ash/wm/window_util.h"
@@ skipping 21 matching lines @@
 class TestingCursorClientObserver : public aura::client::CursorClientObserver {
  public:
   TestingCursorClientObserver()
       : cursor_visibility_(false),
         did_visibility_change_(false) {}
   void reset() { cursor_visibility_ = did_visibility_change_ = false; }
   bool is_cursor_visible() const { return cursor_visibility_; }
   bool did_visibility_change() const { return did_visibility_change_; }
 
   // Overridden from aura::client::CursorClientObserver:
-  virtual void OnCursorVisibilityChanged(bool is_visible) OVERRIDE {
+  virtual void OnCursorVisibilityChanged(bool is_visible) override {
     cursor_visibility_ = is_visible;
     did_visibility_change_ = true;
   }
 
  private:
   bool cursor_visibility_;
   bool did_visibility_change_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingCursorClientObserver);
 };
@@ skipping 15 matching lines @@
 
   void set_key_event_handling_result(ui::EventResult result) {
     key_result_ = result;
   }
 
   void set_mouse_event_handling_result(ui::EventResult result) {
     mouse_result_ = result;
   }
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     ui::test::TestEventHandler::OnKeyEvent(event);
     if (key_result_ & ui::ER_HANDLED)
       event->SetHandled();
     if (key_result_ & ui::ER_CONSUMED)
       event->StopPropagation();
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     ui::test::TestEventHandler::OnMouseEvent(event);
     if (mouse_result_ & ui::ER_HANDLED)
       event->SetHandled();
     if (mouse_result_ & ui::ER_CONSUMED)
       event->StopPropagation();
   }
 
  private:
   ui::EventResult key_result_;
   ui::EventResult mouse_result_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomEventHandler);
 };
 
 }  // namespace
 
 namespace ash {
 
 typedef test::AshTestBase WindowManagerTest;
 
 class NonFocusableDelegate : public aura::test::TestWindowDelegate {
  public:
   NonFocusableDelegate() {}
 
  private:
-  virtual bool CanFocus() OVERRIDE {
+  virtual bool CanFocus() override {
     return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(NonFocusableDelegate);
 };
 
 class HitTestWindowDelegate : public aura::test::TestWindowDelegate {
  public:
   HitTestWindowDelegate()
       : hittest_code_(HTNOWHERE) {
   }
   virtual ~HitTestWindowDelegate() {}
   void set_hittest_code(int hittest_code) { hittest_code_ = hittest_code; }
 
  private:
   // Overridden from TestWindowDelegate:
-  virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
+  virtual int GetNonClientComponent(const gfx::Point& point) const override {
     return hittest_code_;
   }
 
   int hittest_code_;
 
   DISALLOW_COPY_AND_ASSIGN(HitTestWindowDelegate);
 };
 
 TEST_F(WindowManagerTest, Focus) {
   // The IME event filter interferes with the basic key event propagation we
@@ skipping 691 matching lines @@
   observer_a.reset();
   observer_b.reset();
   generator.MoveMouseTo(50, 50);
   EXPECT_TRUE(observer_a.did_visibility_change());
   EXPECT_FALSE(observer_b.did_visibility_change());
   EXPECT_TRUE(observer_a.is_cursor_visible());
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace ash