Standardize usage of virtual/override/final specifiers.

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 32 matching lines @@
 }  // namespace
 
 class DisplayManagerTest : public test::AshTestBase,
                            public gfx::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false) {
   }
-  virtual ~DisplayManagerTest() {}
+  ~DisplayManagerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AshTestBase::SetUp();
     Shell::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
-  virtual void TearDown() override {
+  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 24 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 {
+  void OnDisplayMetricsChanged(const gfx::Display& display, uint32_t) override {
     changed_.push_back(display);
   }
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
+  void OnDisplayAdded(const gfx::Display& new_display) override {
     added_.push_back(new_display);
   }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
+  void OnDisplayRemoved(const gfx::Display& old_display) override {
     ++removed_count_;
   }
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  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 1047 matching lines @@
 
   // The native location is now outside, so move to the
   // center of closest display.
   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() {}
+  ~TestDisplayObserver() override {}
 
   // gfx::DisplayObserver overrides:
-  virtual void OnDisplayMetricsChanged(const gfx::Display&,uint32_t) override {}
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
+  void OnDisplayMetricsChanged(const gfx::Display&, uint32_t) override {}
+  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 {
+  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 204 matching lines @@
   EXPECT_EQ("100x200", host0->GetBounds().size().ToString());
   EXPECT_EQ("300,500", host1->GetBounds().origin().ToString());
   EXPECT_EQ("200x300", host1->GetBounds().size().ToString());
 }
 
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
-  virtual ~ScreenShutdownTest() {}
+  ~ScreenShutdownTest() override {}
 
-  virtual void TearDown() override {
+  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 108 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