Standardize usage of virtual/override/final specifiers.

ash/shelf/shelf_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/shelf/shelf_layout_manager.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 58 matching lines @@
 // counts the number of animation steps.
 class ShelfAnimationWaiter : views::WidgetObserver {
  public:
   explicit ShelfAnimationWaiter(const gfx::Rect& target_bounds)
       : target_bounds_(target_bounds),
         animation_steps_(0),
         done_waiting_(false) {
     GetShelfWidget()->AddObserver(this);
   }
 
-  virtual ~ShelfAnimationWaiter() {
-    GetShelfWidget()->RemoveObserver(this);
-  }
+  ~ShelfAnimationWaiter() override { GetShelfWidget()->RemoveObserver(this); }
 
   // Wait till the shelf finishes animating to its expected bounds.
   void WaitTillDoneAnimating() {
     if (IsDoneAnimating())
       done_waiting_ = true;
     else
       base::MessageLoop::current()->Run();
   }
 
   // Returns true if the animation has completed and it was valid.
   bool WasValidAnimation() const {
     return done_waiting_ && animation_steps_ > 0;
   }
 
  private:
   // Returns true if shelf has finished animating to the target size.
   bool IsDoneAnimating() const {
     ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
     gfx::Rect current_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
     int size = layout_manager->PrimaryAxisValue(current_bounds.height(),
         current_bounds.width());
     int desired_size = layout_manager->PrimaryAxisValue(target_bounds_.height(),
         target_bounds_.width());
     return (size == desired_size);
   }
 
   // views::WidgetObserver override.
-  virtual void OnWidgetBoundsChanged(views::Widget* widget,
-                                     const gfx::Rect& new_bounds) override {
+  void OnWidgetBoundsChanged(views::Widget* widget,
+                             const gfx::Rect& new_bounds) override {
     if (done_waiting_)
       return;
 
     ++animation_steps_;
     if (IsDoneAnimating()) {
       done_waiting_ = true;
       base::MessageLoop::current()->Quit();
     }
   }
 
@@ skipping 108 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShelfDragCallback);
 };
 
 class ShelfLayoutObserverTest : public ShelfLayoutManagerObserver {
  public:
   ShelfLayoutObserverTest()
       : changed_auto_hide_state_(false) {
   }
 
-  virtual ~ShelfLayoutObserverTest() {}
+  ~ShelfLayoutObserverTest() override {}
 
   bool changed_auto_hide_state() const { return changed_auto_hide_state_; }
 
  private:
-  virtual void OnAutoHideStateChanged(
-      ShelfAutoHideState new_state) override {
+  void OnAutoHideStateChanged(ShelfAutoHideState new_state) override {
     changed_auto_hide_state_ = true;
   }
 
   bool changed_auto_hide_state_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutObserverTest);
 };
 
 // Trivial item implementation that tracks its views for testing.
 class TestItem : public SystemTrayItem {
  public:
   TestItem()
       : SystemTrayItem(GetSystemTray()),
         tray_view_(NULL),
         default_view_(NULL),
         detailed_view_(NULL),
         notification_view_(NULL) {}
 
-  virtual views::View* CreateTrayView(user::LoginStatus status) override {
+  views::View* CreateTrayView(user::LoginStatus status) override {
     tray_view_ = new views::View;
     // Add a label so it has non-zero width.
     tray_view_->SetLayoutManager(new views::FillLayout);
     tray_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Tray")));
     return tray_view_;
   }
 
-  virtual views::View* CreateDefaultView(user::LoginStatus status) override {
+  views::View* CreateDefaultView(user::LoginStatus status) override {
     default_view_ = new views::View;
     default_view_->SetLayoutManager(new views::FillLayout);
     default_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Default")));
     return default_view_;
   }
 
-  virtual views::View* CreateDetailedView(user::LoginStatus status) override {
+  views::View* CreateDetailedView(user::LoginStatus status) override {
     detailed_view_ = new views::View;
     detailed_view_->SetLayoutManager(new views::FillLayout);
     detailed_view_->AddChildView(
         new views::Label(base::UTF8ToUTF16("Detailed")));
     return detailed_view_;
   }
 
-  virtual views::View* CreateNotificationView(
-      user::LoginStatus status) override {
+  views::View* CreateNotificationView(user::LoginStatus status) override {
     notification_view_ = new views::View;
     return notification_view_;
   }
 
-  virtual void DestroyTrayView() override {
-    tray_view_ = NULL;
-  }
+  void DestroyTrayView() override { tray_view_ = NULL; }
 
-  virtual void DestroyDefaultView() override {
-    default_view_ = NULL;
-  }
+  void DestroyDefaultView() override { default_view_ = NULL; }
 
-  virtual void DestroyDetailedView() override {
-    detailed_view_ = NULL;
-  }
+  void DestroyDetailedView() override { detailed_view_ = NULL; }
 
-  virtual void DestroyNotificationView() override {
-    notification_view_ = NULL;
-  }
+  void DestroyNotificationView() override { notification_view_ = NULL; }
 
-  virtual void UpdateAfterLoginStatusChange(
-      user::LoginStatus status) override {}
+  void UpdateAfterLoginStatusChange(user::LoginStatus status) override {}
 
   views::View* tray_view() const { return tray_view_; }
   views::View* default_view() const { return default_view_; }
   views::View* detailed_view() const { return detailed_view_; }
   views::View* notification_view() const { return notification_view_; }
 
  private:
   views::View* tray_view_;
   views::View* default_view_;
   views::View* detailed_view_;
@@ skipping 37 matching lines @@
   // Create a simple widget attached to the current context (will
   // delete on TearDown).
   views::Widget* CreateTestWidget() {
     views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     params.context = CurrentContext();
     return CreateTestWidgetWithParams(params);
   }
 
   // Overridden from AshTestBase:
-  virtual void SetUp() override {
+  void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         ash::switches::kAshEnableTrayDragging);
     test::AshTestBase::SetUp();
   }
 
   void RunGestureDragTests(gfx::Vector2d);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManagerTest);
 };
@@ skipping 1644 matching lines @@
   shelf_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
   gfx::Rect hide_target_bounds =  status_window->GetTargetBounds();
   EXPECT_GT(hide_target_bounds.y(), initial_bounds.y());
 
   shelf_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   gfx::Rect reshow_target_bounds = status_window->GetTargetBounds();
   EXPECT_EQ(initial_bounds, reshow_target_bounds);
 }
 
 }  // namespace ash