replace OVERRIDE and FINAL with override and final in ash/

ash/display/display_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/display/display_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
@@ skipping 34 matching lines @@
 class DisplayManagerTest : public test::AshTestBase,
                            public gfx::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false) {
   }
   virtual ~DisplayManagerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AshTestBase::SetUp();
     Shell::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     Shell::GetScreen()->RemoveObserver(this);
     AshTestBase::TearDown();
   }
 
   DisplayManager* display_manager() {
     return Shell::GetInstance()->display_manager();
   }
   const vector<gfx::Display>& changed() const { return changed_; }
   const vector<gfx::Display>& added() const { return added_; }
@@ skipping 25 matching lines @@
   const gfx::Display& GetDisplayForId(int64 id) {
     return display_manager()->GetDisplayForId(id);
   }
 
   const DisplayInfo& GetDisplayInfoForId(int64 id) {
     return GetDisplayInfo(display_manager()->GetDisplayForId(id));
   }
 
   // aura::DisplayObserver overrides:
   virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t) OVERRIDE {
+                                       uint32_t) override {
     changed_.push_back(display);
   }
-  virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE {
+  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
     added_.push_back(new_display);
   }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE {
+  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
     ++removed_count_;
   }
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     ASSERT_EQ(Shell::GetPrimaryRootWindow(), window);
     root_window_destroyed_ = true;
   }
 
  private:
   vector<gfx::Display> changed_;
   vector<gfx::Display> added_;
   size_t removed_count_;
   bool root_window_destroyed_;
 
@@ skipping 1020 matching lines @@
   UpdateDisplay("600x400,400x200*2@1.5");
   EXPECT_EQ("750,75", env->last_mouse_location().ToString());
 }
 
 class TestDisplayObserver : public gfx::DisplayObserver {
  public:
   TestDisplayObserver() : changed_(false) {}
   virtual ~TestDisplayObserver() {}
 
   // gfx::DisplayObserver overrides:
-  virtual void OnDisplayMetricsChanged(const gfx::Display&,uint32_t) OVERRIDE {}
-  virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE {
+  virtual void OnDisplayMetricsChanged(const gfx::Display&,uint32_t) override {}
+  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
     // Mirror window should already be delete before restoring
     // the external display.
     EXPECT_FALSE(test_api.GetHost());
     changed_ = true;
   }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE {
+  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
     // Mirror window should not be created until the external display
     // is removed.
     EXPECT_FALSE(test_api.GetHost());
     changed_ = true;
   }
 
   bool changed_and_reset() {
     bool changed = changed_;
     changed_ = false;
     return changed;
@@ skipping 206 matching lines @@
   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
 }
 
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
   virtual ~ScreenShutdownTest() {}
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     gfx::Screen* orig_screen =
         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
     AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
     gfx::Screen* screen =
         gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
     EXPECT_NE(orig_screen, screen);
     EXPECT_EQ(2, screen->GetNumDisplays());
     EXPECT_EQ("500x300", screen->GetPrimaryDisplay().size().ToString());
@@ skipping 34 matching lines @@
     command_line->AppendSwitchASCII(switches::kAshHostWindowBounds,
                                     StringPrintf("1000x800*%f", scale));
     SetUp();
   }
 
   virtual ~FontTestHelper() {
     TearDown();
   }
 
   // test::AshTestBase:
-  virtual void TestBody() OVERRIDE {
+  virtual void TestBody() override {
     NOTREACHED();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FontTestHelper);
 };
 
 
 bool IsTextSubpixelPositioningEnabled() {
   gfx::FontRenderParams params =
@@ skipping 53 matching lines @@
   FontTestHelper helper(1.25f, FontTestHelper::INTERNAL);
   ASSERT_DOUBLE_EQ(
       1.0f, Shell::GetScreen()->GetPrimaryDisplay().device_scale_factor());
   EXPECT_FALSE(IsTextSubpixelPositioningEnabled());
   DisplayInfo::SetUse125DSFForUIScaling(false);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash