Standardize usage of virtual/override/final specifiers.

ash/wm/workspace/workspace_layout_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/wm/workspace/workspace_layout_manager.h"
 
 #include <string>
 
 #include "ash/display/display_layout.h"
 #include "ash/display/display_manager.h"
@@ skipping 28 matching lines @@
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
 class MaximizeDelegateView : public views::WidgetDelegateView {
  public:
   explicit MaximizeDelegateView(const gfx::Rect& initial_bounds)
       : initial_bounds_(initial_bounds) {
   }
-  virtual ~MaximizeDelegateView() {}
+  ~MaximizeDelegateView() override {}
 
-  virtual bool GetSavedWindowPlacement(
-      const views::Widget* widget,
-      gfx::Rect* bounds,
-      ui::WindowShowState* show_state) const override {
+  bool GetSavedWindowPlacement(const views::Widget* widget,
+                               gfx::Rect* bounds,
+                               ui::WindowShowState* show_state) const override {
     *bounds = initial_bounds_;
     *show_state = ui::SHOW_STATE_MAXIMIZED;
     return true;
   }
 
  private:
   const gfx::Rect initial_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
 };
 
 class TestShellObserver : public ShellObserver {
  public:
   TestShellObserver() : call_count_(0),
                         is_fullscreen_(false) {
     Shell::GetInstance()->AddShellObserver(this);
   }
 
-  virtual ~TestShellObserver() {
+  ~TestShellObserver() override {
     Shell::GetInstance()->RemoveShellObserver(this);
   }
 
-  virtual void OnFullscreenStateChanged(bool is_fullscreen,
-                                        aura::Window* root_window) override {
+  void OnFullscreenStateChanged(bool is_fullscreen,
+                                aura::Window* root_window) override {
     call_count_++;
     is_fullscreen_ = is_fullscreen;
   }
 
   int call_count() const {
     return call_count_;
   }
 
   bool is_fullscreen() const {
     return is_fullscreen_;
@@ skipping 217 matching lines @@
 // WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
 // This code mirrors what BrowserFrameAsh does. In particular when this code
 // sees the window was maximized it changes the bounds of a secondary
 // window. The secondary window mirrors the status window.
 class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
  public:
   DontClobberRestoreBoundsWindowObserver() : window_(NULL) {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
-  virtual void OnWindowPropertyChanged(aura::Window* window,
-                                       const void* key,
-                                       intptr_t old) override {
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override {
     if (!window_)
       return;
 
     if (wm::GetWindowState(window)->IsMaximized()) {
       aura::Window* w = window_;
       window_ = NULL;
 
       gfx::Rect shelf_bounds(Shell::GetPrimaryRootWindowController()->
                              GetShelfLayoutManager()->GetIdealBounds());
       const gfx::Rect& window_bounds(w->bounds());
@@ skipping 193 matching lines @@
   EXPECT_EQ(6, observer.call_count());
   EXPECT_FALSE(observer.is_fullscreen());
 }
 
 // Following "Solo" tests were originally written for BaseLayoutManager.
 namespace {
 
 class WorkspaceLayoutManagerSoloTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerSoloTest() {}
-  virtual ~WorkspaceLayoutManagerSoloTest() {}
+  ~WorkspaceLayoutManagerSoloTest() override {}
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerSoloTest);
 };
 
 }  // namespace
@@ skipping 24 matching lines @@
 }
 
 // A WindowDelegate which sets the focus when the window
 // becomes visible.
 class FocusDelegate : public aura::test::TestWindowDelegate {
  public:
   FocusDelegate()
       : window_(NULL),
         show_state_(ui::SHOW_STATE_END) {
   }
-  virtual ~FocusDelegate() {}
+  ~FocusDelegate() override {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
   // aura::test::TestWindowDelegate overrides:
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
+  void OnWindowTargetVisibilityChanged(bool visible) override {
     if (window_) {
       if (visible)
         window_->Focus();
       show_state_ = window_->GetProperty(aura::client::kShowStateKey);
     }
   }
 
   ui::WindowShowState GetShowStateAndReset() {
     ui::WindowShowState ret = show_state_;
     show_state_ = ui::SHOW_STATE_END;
@@ skipping 188 matching lines @@
   EXPECT_EQ(window_bounds.ToString(), window->bounds().ToString());
 }
 
 // Following tests are written to test the backdrop functionality.
 
 namespace {
 
 class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerBackdropTest() {}
-  virtual ~WorkspaceLayoutManagerBackdropTest() {}
+  ~WorkspaceLayoutManagerBackdropTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     default_container_ = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                              kShellWindowId_DefaultContainer);
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithBounds(bounds);
     return window;
   }
@@ skipping 165 matching lines @@
   shelf_layout_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
   shelf_layout_manager->UpdateVisibilityState();
 
   EXPECT_GT(default_container()->children()[0]->bounds().height(),
             reduced_bounds.height());
 }
 
 class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerKeyboardTest() {}
-  virtual ~WorkspaceLayoutManagerKeyboardTest() {}
+  ~WorkspaceLayoutManagerKeyboardTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     aura::Window* default_container = Shell::GetContainer(
         Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer);
     layout_manager_ = static_cast<WorkspaceLayoutManager*>(
         default_container->layout_manager());
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
@@ skipping 49 matching lines @@
   gfx::Insets restore_work_area_insets_;
   gfx::Rect keyboard_bounds_;
   WorkspaceLayoutManager* layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerKeyboardTest);
 };
 
 class FakeTextInputClient : public ui::DummyTextInputClient {
  public:
   explicit FakeTextInputClient(gfx::NativeWindow window) : window_(window) {}
-  virtual ~FakeTextInputClient() {}
+  ~FakeTextInputClient() override {}
 
-  virtual gfx::NativeWindow GetAttachedWindow() const override {
-    return window_;
-  }
+  gfx::NativeWindow GetAttachedWindow() const override { return window_; }
 
  private:
   gfx::NativeWindow window_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeTextInputClient);
 };
 
 // Tests that when a child window gains focus the top level window containing it
 // is resized to fit the remaining workspace area.
 TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) {
@@ skipping 85 matching lines @@
                       occluded_window_bounds.width(),
                       occluded_window_bounds.height()).ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
 
   Blur(&text_input_client);
 }
 
 }  // namespace ash