Standardize usage of virtual/override/final specifiers.

ash/root_window_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/root_window_controller.h"
 
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 30 matching lines @@
 
 using aura::Window;
 using views::Widget;
 
 namespace ash {
 namespace {
 
 class TestDelegate : public views::WidgetDelegateView {
  public:
   explicit TestDelegate(bool system_modal) : system_modal_(system_modal) {}
-  virtual ~TestDelegate() {}
+  ~TestDelegate() override {}
 
   // Overridden from views::WidgetDelegate:
-  virtual views::View* GetContentsView() override {
-    return this;
-  }
+  views::View* GetContentsView() override { return this; }
 
-  virtual ui::ModalType GetModalType() const override {
+  ui::ModalType GetModalType() const override {
     return system_modal_ ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE;
   }
 
  private:
   bool system_modal_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate,
                              public aura::client::FocusChangeObserver {
  public:
   DeleteOnBlurDelegate() : window_(NULL) {}
-  virtual ~DeleteOnBlurDelegate() {}
+  ~DeleteOnBlurDelegate() override {}
 
   void SetWindow(aura::Window* window) {
     window_ = window;
     aura::client::SetFocusChangeObserver(window_, this);
   }
 
  private:
   // aura::test::TestWindowDelegate overrides:
-  virtual bool CanFocus() override {
-    return true;
-  }
+  bool CanFocus() override { return true; }
 
   // aura::client::FocusChangeObserver implementation:
-  virtual void OnWindowFocused(aura::Window* gained_focus,
-                               aura::Window* lost_focus) override {
+  void OnWindowFocused(aura::Window* gained_focus,
+                       aura::Window* lost_focus) override {
     if (window_ == lost_focus)
       delete window_;
   }
 
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteOnBlurDelegate);
 };
 
 }  // namespace
@@ skipping 421 matching lines @@
     session_window->Focus();
     EXPECT_FALSE(session_window->HasFocus());
     UnblockUserSession();
   }
 }
 
 // Tracks whether OnWindowDestroying() has been invoked.
 class DestroyedWindowObserver : public aura::WindowObserver {
  public:
   DestroyedWindowObserver() : destroyed_(false), window_(NULL) {}
-  virtual ~DestroyedWindowObserver() {
-    Shutdown();
-  }
+  ~DestroyedWindowObserver() override { Shutdown(); }
 
   void SetWindow(Window* window) {
     window_ = window;
     window->AddObserver(this);
   }
 
   bool destroyed() const { return destroyed_; }
 
   // WindowObserver overrides:
-  virtual void OnWindowDestroying(Window* window) override {
+  void OnWindowDestroying(Window* window) override {
     destroyed_ = true;
     Shutdown();
   }
 
  private:
   void Shutdown() {
     if (!window_)
       return;
     window_->RemoveObserver(this);
     window_ = NULL;
@@ skipping 56 matching lines @@
             root->GetEventHandlerForPoint(gfx::Point(0, size.height() - 1)));
   EXPECT_EQ(event_target,
             root->GetEventHandlerForPoint(
                 gfx::Point(size.width() - 1, size.height() - 1)));
 }
 
 class VirtualKeyboardRootWindowControllerTest
     : public RootWindowControllerTest {
  public:
   VirtualKeyboardRootWindowControllerTest() {};
-  virtual ~VirtualKeyboardRootWindowControllerTest() {};
+  ~VirtualKeyboardRootWindowControllerTest() override{};

[Daniel Erat, 2014/10/27 21:55:49]

nit: override {}

[dcheng, 2014/10/27 22:03:41]

Fixed this one too.

 
-  virtual void SetUp() override {
+  void SetUp() override {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         keyboard::switches::kEnableVirtualKeyboard);
     test::AshTestBase::SetUp();
     Shell::GetPrimaryRootWindowController()->ActivateKeyboard(
         keyboard::KeyboardController::GetInstance());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardRootWindowControllerTest);
 };
 
 class MockTextInputClient : public ui::DummyTextInputClient {
  public:
   MockTextInputClient() :
       ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
 
-  virtual void EnsureCaretInRect(const gfx::Rect& rect) override {
+  void EnsureCaretInRect(const gfx::Rect& rect) override {
     visible_rect_ = rect;
   }
 
   const gfx::Rect& visible_rect() const {
     return visible_rect_;
   }
 
  private:
   gfx::Rect visible_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 };
 
 class TargetHitTestEventHandler : public ui::test::TestEventHandler {
  public:
   TargetHitTestEventHandler() {}
 
   // ui::test::TestEventHandler overrides.
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_PRESSED)
       ui::test::TestEventHandler::OnMouseEvent(event);
     event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TargetHitTestEventHandler);
 };
 
 // Test for http://crbug.com/297858. Virtual keyboard container should only show
@@ skipping 294 matching lines @@
   ASSERT_TRUE(keyboard_container);
   keyboard_container->Show();
   EXPECT_EQ("0,0 800x600", keyboard_container->bounds().ToString());
 
   UpdateDisplay("600x800");
   EXPECT_EQ("0,0 600x800", keyboard_container->bounds().ToString());
 }
 
 }  // namespace test
 }  // namespace ash