Standardize usage of virtual/override/final specifiers.

ash/display/display_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/display/display_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
@@ skipping 62 matching lines @@
         focus_changed_count_(0),
         activation_changed_count_(0) {
     Shell::GetInstance()->display_controller()->AddObserver(this);
     Shell::GetScreen()->AddObserver(this);
     aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())->
         AddObserver(this);
     aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
         AddObserver(this);
   }
 
-  virtual ~TestObserver() {
+  ~TestObserver() override {
     Shell::GetInstance()->display_controller()->RemoveObserver(this);
     Shell::GetScreen()->RemoveObserver(this);
     aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())->
         RemoveObserver(this);
     aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
         RemoveObserver(this);
   }
 
   // Overridden from DisplayController::Observer
-  virtual void OnDisplayConfigurationChanging() override {
-    ++changing_count_;
-  }
-  virtual void OnDisplayConfigurationChanged() override {
-    ++changed_count_;
-  }
+  void OnDisplayConfigurationChanging() override { ++changing_count_; }
+  void OnDisplayConfigurationChanged() override { ++changed_count_; }
 
   // Overrideen from gfx::DisplayObserver
-  virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) override {
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t metrics) override {
     changed_display_id_ = display.id();
     if (metrics & DISPLAY_METRIC_BOUNDS)
       ++bounds_changed_count_;
     if (metrics & DISPLAY_METRIC_ROTATION)
       ++rotation_changed_count_;
     if (metrics & DISPLAY_METRIC_WORK_AREA)
       ++workarea_changed_count_;
   }
-  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
-  }
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
-  }
+  void OnDisplayAdded(const gfx::Display& new_display) override {}
+  void OnDisplayRemoved(const gfx::Display& old_display) override {}
 
   // Overridden from aura::client::FocusChangeObserver
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     focus_changed_count_++;
   }
 
   // Overridden from aura::client::ActivationChangeObserver
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) override {
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override {
     activation_changed_count_++;
   }
-  virtual void OnAttemptToReactivateWindow(
-      aura::Window* request_active,
-      aura::Window* actual_active) override {
-  }
+  void OnAttemptToReactivateWindow(aura::Window* request_active,
+                                   aura::Window* actual_active) override {}
 
   int CountAndReset() {
     EXPECT_EQ(changing_count_, changed_count_);
     changed_count_ = 0;
     return Resetter<int>(&changing_count_).value();
   }
 
   int64 GetBoundsChangedCountAndReset() {
     return Resetter<int>(&bounds_changed_count_).value();
   }
@@ skipping 56 matching lines @@
 }
 
 void SetDefaultDisplayLayout(DisplayLayout::Position position) {
   Shell::GetInstance()->display_manager()->layout_store()->
       SetDefaultDisplayLayout(DisplayLayout(position, 0));
 }
 
 class DisplayControllerShutdownTest : public test::AshTestBase {
  public:
   DisplayControllerShutdownTest() {}
-  virtual ~DisplayControllerShutdownTest() {}
+  ~DisplayControllerShutdownTest() override {}
 
-  virtual void TearDown() override {
+  void TearDown() override {
     test::AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
 
     // Make sure that primary display is accessible after shutdown.
     gfx::Display primary = Shell::GetScreen()->GetPrimaryDisplay();
     EXPECT_EQ("0,0 444x333", primary.bounds().ToString());
     EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayControllerShutdownTest);
 };
 
 class StartupHelper : public test::TestShellDelegate,
                       public DisplayController::Observer {
  public:
   StartupHelper() : displays_initialized_(false) {}
-  virtual ~StartupHelper() {}
+  ~StartupHelper() override {}
 
   // ash::ShellSelegate:
-  virtual void PreInit() override {
+  void PreInit() override {
     Shell::GetInstance()->display_controller()->AddObserver(this);
   }
 
   // ash::DisplayController::Observer:
-  virtual void OnDisplaysInitialized() override {
+  void OnDisplaysInitialized() override {
     DCHECK(!displays_initialized_);
     displays_initialized_ = true;
   }
 
   bool displays_initialized() const {
     return displays_initialized_;
   }
 
  private:
   bool displays_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(StartupHelper);
 };
 
 class DisplayControllerStartupTest : public test::AshTestBase {
  public:
   DisplayControllerStartupTest() : startup_helper_(new StartupHelper) {}
-  virtual ~DisplayControllerStartupTest() {}
+  ~DisplayControllerStartupTest() override {}
 
   // ash::test::AshTestBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     ash_test_helper()->set_test_shell_delegate(startup_helper_);
     test::AshTestBase::SetUp();
   }
-  virtual void TearDown() override {
+  void TearDown() override {
     Shell::GetInstance()->display_controller()->RemoveObserver(startup_helper_);
     test::AshTestBase::TearDown();
   }
 
   const StartupHelper* startup_helper() const { return startup_helper_; }
 
  private:
   StartupHelper* startup_helper_;  // Owned by ash::Shell.
 
   DISALLOW_COPY_AND_ASSIGN(DisplayControllerStartupTest);
 };
 
 class TestEventHandler : public ui::EventHandler {
  public:
   TestEventHandler() : target_root_(NULL),
                        touch_radius_x_(0.0),
                        touch_radius_y_(0.0),
                        scroll_x_offset_(0.0),
                        scroll_y_offset_(0.0),
                        scroll_x_offset_ordinal_(0.0),
                        scroll_y_offset_ordinal_(0.0) {}
-  virtual ~TestEventHandler() {}
+  ~TestEventHandler() override {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->flags() & ui::EF_IS_SYNTHESIZED &&
         event->type() != ui::ET_MOUSE_EXITED &&
         event->type() != ui::ET_MOUSE_ENTERED) {
       return;
     }
     aura::Window* target = static_cast<aura::Window*>(event->target());
     mouse_location_ = event->root_location();
     target_root_ = target->GetRootWindow();
     event->StopPropagation();
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.
     if (target->name() != kDesktopBackgroundView)
       return;
     touch_radius_x_ = event->radius_x();
     touch_radius_y_ = event->radius_y();
     event->StopPropagation();
   }
 
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
+  void OnScrollEvent(ui::ScrollEvent* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     // Only record when the target is the background which covers
     // entire root window.
     if (target->name() != kDesktopBackgroundView)
       return;
 
     if (event->type() == ui::ET_SCROLL) {
       scroll_x_offset_ = event->x_offset();
       scroll_y_offset_ = event->y_offset();
       scroll_x_offset_ordinal_ = event->x_offset_ordinal();
@@ skipping 1016 matching lines @@
   EXPECT_EQ("aura_root_x", GetXWindowName(secondary->GetHost()));
 
   // Switching back to single display.
   UpdateDisplay("300x400");
   EXPECT_EQ("aura_root_0", GetXWindowName(
       Shell::GetPrimaryRootWindow()->GetHost()));
 }
 #endif
 
 }  // namespace ash