Standardize usage of virtual/override/final specifiers.

content/browser/web_contents/aura/window_slider_unittest.cc

 // Copyright (c) 2013 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 "content/browser/web_contents/aura/window_slider.h"
 
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 54 matching lines @@
                                         ui::EventType type,
                                         const gfx::Vector2dF& delta) {
   EXPECT_FALSE(slider->IsSlideInProgress());
 }
 
 // The window delegate does not receive any events.
 class NoEventWindowDelegate : public aura::test::TestWindowDelegate {
  public:
   NoEventWindowDelegate() {
   }
-  virtual ~NoEventWindowDelegate() {}
+  ~NoEventWindowDelegate() override {}
 
  private:
   // Overridden from aura::WindowDelegate:
-  virtual bool HasHitTestMask() const override { return true; }
+  bool HasHitTestMask() const override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(NoEventWindowDelegate);
 };
 
 class WindowSliderDelegateTest : public WindowSlider::Delegate {
  public:
   WindowSliderDelegateTest()
       : can_create_layer_(true),
         created_back_layer_(false),
         created_front_layer_(false),
         slide_completing_(false),
         slide_completed_(false),
         slide_aborted_(false),
         slider_destroyed_(false) {
   }
-  virtual ~WindowSliderDelegateTest() {
+  ~WindowSliderDelegateTest() override {
     // Make sure slide_completed() gets called if slide_completing() was called.
     CHECK(!slide_completing_ || slide_completed_);
   }
 
   void Reset() {
     can_create_layer_ = true;
     created_back_layer_ = false;
     created_front_layer_ = false;
     slide_completing_ = false;
     slide_completed_ = false;
@@ skipping 14 matching lines @@
 
  protected:
   ui::Layer* CreateLayerForTest() {
     CHECK(can_create_layer_);
     ui::Layer* layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
     layer->SetColor(SK_ColorRED);
     return layer;
   }
 
   // Overridden from WindowSlider::Delegate:
-  virtual ui::Layer* CreateBackLayer() override {
+  ui::Layer* CreateBackLayer() override {
     if (!can_create_layer_)
       return NULL;
     created_back_layer_ = true;
     return CreateLayerForTest();
   }
 
-  virtual ui::Layer* CreateFrontLayer() override {
+  ui::Layer* CreateFrontLayer() override {
     if (!can_create_layer_)
       return NULL;
     created_front_layer_ = true;
     return CreateLayerForTest();
   }
 
-  virtual void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override {
+  void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override {
     slide_completed_ = true;
   }
 
-  virtual void OnWindowSlideCompleting() override {
-    slide_completing_ = true;
-  }
+  void OnWindowSlideCompleting() override { slide_completing_ = true; }
 
-  virtual void OnWindowSlideAborted() override {
-    slide_aborted_ = true;
-  }
+  void OnWindowSlideAborted() override { slide_aborted_ = true; }
 
-  virtual void OnWindowSliderDestroyed() override {
-    slider_destroyed_ = true;
-  }
+  void OnWindowSliderDestroyed() override { slider_destroyed_ = true; }
 
  private:
   bool can_create_layer_;
   bool created_back_layer_;
   bool created_front_layer_;
   bool slide_completing_;
   bool slide_completed_;
   bool slide_aborted_;
   bool slider_destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSliderDelegateTest);
 };
 
 // This delegate destroys the owner window when the slider is destroyed.
 class WindowSliderDeleteOwnerOnDestroy : public WindowSliderDelegateTest {
  public:
   explicit WindowSliderDeleteOwnerOnDestroy(aura::Window* owner)
       : owner_(owner) {
   }
-  virtual ~WindowSliderDeleteOwnerOnDestroy() {}
+  ~WindowSliderDeleteOwnerOnDestroy() override {}
 
  private:
   // Overridden from WindowSlider::Delegate:
-  virtual void OnWindowSliderDestroyed() override {
+  void OnWindowSliderDestroyed() override {
     WindowSliderDelegateTest::OnWindowSliderDestroyed();
     delete owner_;
   }
 
   aura::Window* owner_;
   DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnDestroy);
 };
 
 // This delegate destroyes the owner window when a slide is completed.
 class WindowSliderDeleteOwnerOnComplete : public WindowSliderDelegateTest {
  public:
   explicit WindowSliderDeleteOwnerOnComplete(aura::Window* owner)
       : owner_(owner) {
   }
-  virtual ~WindowSliderDeleteOwnerOnComplete() {}
+  ~WindowSliderDeleteOwnerOnComplete() override {}
 
  private:
   // Overridden from WindowSlider::Delegate:
-  virtual void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override {
+  void OnWindowSlideCompleted(scoped_ptr<ui::Layer> layer) override {
     WindowSliderDelegateTest::OnWindowSlideCompleted(layer.Pass());
     delete owner_;
   }
 
   aura::Window* owner_;
   DISALLOW_COPY_AND_ASSIGN(WindowSliderDeleteOwnerOnComplete);
 };
 
 typedef aura::test::AuraTestBase WindowSliderTest;
 
@@ skipping 427 matching lines @@
   animator->Step(start_time2 + duration);
   // The animation for the second slide should now be completed.
   EXPECT_TRUE(slider_delegate.slide_completed());
   slider_delegate.Reset();
 
   window.reset();
   EXPECT_TRUE(slider_delegate.slider_destroyed());
 }
 
 }  // namespace content