Standardize usage of virtual/override/final specifiers.

content/browser/renderer_host/input/tap_suppression_controller_unittest.cc

 // Copyright 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 "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/input/tap_suppression_controller.h"
 #include "content/browser/renderer_host/input/tap_suppression_controller_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 21 matching lines @@
     TAP_CANCEL_FORWARDED                 = 1 << 6,
     STASHED_TAP_DOWN_FORWARDED           = 1 << 7,
   };
 
   MockTapSuppressionController(const TapSuppressionController::Config& config)
       : TapSuppressionController(this, config),
         last_actions_(NONE),
         time_(),
         timer_started_(false) {}
 
-  virtual ~MockTapSuppressionController() {}
+  ~MockTapSuppressionController() override {}
 
   void SendGestureFlingCancel() {
     last_actions_ = NONE;
     GestureFlingCancel();
   }
 
   void SendGestureFlingCancelAck(bool processed) {
     last_actions_ = NONE;
     GestureFlingCancelAck(processed);
   }
@@ skipping 29 matching lines @@
       timer_started_ = false;
       TapDownTimerExpired();
     }
   }
 
   State state() { return state_; }
 
   int last_actions() { return last_actions_; }
 
  protected:
-  virtual base::TimeTicks Now() override {
-    return time_;
-  }
+  base::TimeTicks Now() override { return time_; }
 
-  virtual void StartTapDownTimer(const base::TimeDelta& delay) override {
+  void StartTapDownTimer(const base::TimeDelta& delay) override {
     timer_expiry_time_ = time_ + delay;
     timer_started_ = true;
   }
 
-  virtual void StopTapDownTimer() override {
-    timer_started_ = false;
-  }
+  void StopTapDownTimer() override { timer_started_ = false; }
 
  private:
   // TapSuppressionControllerClient implementation
-  virtual void DropStashedTapDown() override {
-    last_actions_ |= TAP_DOWN_DROPPED;
-  }
+  void DropStashedTapDown() override { last_actions_ |= TAP_DOWN_DROPPED; }
 
-  virtual void ForwardStashedTapDown() override {
+  void ForwardStashedTapDown() override {
     last_actions_ |= STASHED_TAP_DOWN_FORWARDED;
   }
 
   // Hiding some derived public methods
   using TapSuppressionController::GestureFlingCancel;
   using TapSuppressionController::GestureFlingCancelAck;
   using TapSuppressionController::ShouldDeferTapDown;
   using TapSuppressionController::ShouldSuppressTapEnd;
 
   int last_actions_;
 
   base::TimeTicks time_;
   bool timer_started_;
   base::TimeTicks timer_expiry_time_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTapSuppressionController);
 };
 
 class TapSuppressionControllerTest : public testing::Test {
  public:
   TapSuppressionControllerTest() {
   }
-  virtual ~TapSuppressionControllerTest() {
-  }
+  ~TapSuppressionControllerTest() override {}
 
  protected:
   // testing::Test
-  virtual void SetUp() {
+  void SetUp() override {
     tap_suppression_controller_.reset(
         new MockTapSuppressionController(GetConfig()));
   }
 
-  virtual void TearDown() {
-    tap_suppression_controller_.reset();
-  }
+  void TearDown() override { tap_suppression_controller_.reset(); }
 
   static TapSuppressionController::Config GetConfig() {
     TapSuppressionController::Config config;
     config.enabled = true;
     config.max_cancel_to_down_time = base::TimeDelta::FromMilliseconds(10);
     config.max_tap_gap_time = base::TimeDelta::FromMilliseconds(10);
     return config;
   }
 
   scoped_ptr<MockTapSuppressionController> tap_suppression_controller_;
@@ skipping 371 matching lines @@
 
   // Send TapUp. This TapUp should not be suppressed.
   tap_suppression_controller_->SendTapUp();
   EXPECT_EQ(MockTapSuppressionController::TAP_UP_FORWARDED,
             tap_suppression_controller_->last_actions());
   EXPECT_EQ(MockTapSuppressionController::DISABLED,
             tap_suppression_controller_->state());
 }
 
 }  // namespace content