Standardize usage of virtual/override/final specifiers.

ui/aura/gestures/gesture_recognizer_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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 81 matching lines @@
         scroll_velocity_x_(0),
         scroll_velocity_y_(0),
         velocity_x_(0),
         velocity_y_(0),
         scroll_x_hint_(0),
         scroll_y_hint_(0),
         tap_count_(0),
         flags_(0),
         wait_until_event_(ui::ET_UNKNOWN) {}
 
-  virtual ~GestureEventConsumeDelegate() {}
+  ~GestureEventConsumeDelegate() override {}
 
   void Reset() {
     events_.clear();
     tap_ = false;
     tap_down_ = false;
     tap_cancel_ = false;
     begin_ = false;
     end_ = false;
     scroll_begin_ = false;
     scroll_update_ = false;
@@ skipping 76 matching lines @@
   int tap_count() const { return tap_count_; }
   int flags() const { return flags_; }
   const ui::LatencyInfo& latency_info() const { return latency_info_; }
 
   void WaitUntilReceivedGesture(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
+  void OnGestureEvent(ui::GestureEvent* gesture) override {
     events_.push_back(gesture->type());
     bounding_box_ = gesture->details().bounding_box();
     flags_ = gesture->flags();
     latency_info_ = *gesture->latency();
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
         tap_location_ = gesture->location();
         tap_count_ = gesture->details().tap_count();
         tap_ = true;
         break;
@@ skipping 122 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
       : window_(NULL),
         dispatcher_(dispatcher),
         queue_events_(true) {
   }
-  virtual ~QueueTouchEventDelegate() {
+  ~QueueTouchEventDelegate() override {
     while(!queue_.empty()) {
       delete queue_.front();
       queue_.pop();
     }
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     if (queue_events_) {
       queue_.push(new ui::TouchEvent(*event, window_, window_));
       event->StopPropagation();
     }
   }
 
   void ReceivedAck() {
     ReceivedAckImpl(false);
   }
 
@@ skipping 42 matching lines @@
     double_click_ = false;
   }
 
   bool mouse_enter() const { return mouse_enter_; }
   bool mouse_exit() const { return mouse_exit_; }
   bool mouse_press() const { return mouse_press_; }
   bool mouse_move() const { return mouse_move_; }
   bool mouse_release() const { return mouse_release_; }
   bool double_click() const { return double_click_; }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     switch (event->type()) {
       case ui::ET_MOUSE_PRESSED:
         double_click_ = event->flags() & ui::EF_IS_DOUBLE_CLICK;
         mouse_press_ = true;
         break;
       case ui::ET_MOUSE_RELEASED:
         mouse_release_ = true;
         break;
       case ui::ET_MOUSE_MOVED:
         mouse_move_ = true;
@@ skipping 106 matching lines @@
 };
 
 // An event handler to keep track of events.
 class TestEventHandler : public ui::EventHandler {
  public:
   TestEventHandler()
       : touch_released_count_(0),
         touch_pressed_count_(0),
         touch_moved_count_(0) {}
 
-  virtual ~TestEventHandler() {}
+  ~TestEventHandler() override {}
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     switch (event->type()) {
       case ui::ET_TOUCH_RELEASED:
         touch_released_count_++;
         break;
       case ui::ET_TOUCH_PRESSED:
         touch_pressed_count_++;
         break;
       case ui::ET_TOUCH_MOVED:
         touch_moved_count_++;
         break;
@@ skipping 29 matching lines @@
   std::vector<gfx::PointF> cancelled_touch_points_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
 // Removes the target window from its parent when it receives a touch-cancel
 // event.
 class RemoveOnTouchCancelHandler : public TestEventHandler {
  public:
   RemoveOnTouchCancelHandler() {}
-  virtual ~RemoveOnTouchCancelHandler() {}
+  ~RemoveOnTouchCancelHandler() override {}
 
  private:
   // ui::EventHandler:
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     TestEventHandler::OnTouchEvent(event);
     if (event->type() == ui::ET_TOUCH_CANCELLED) {
       Window* target = static_cast<Window*>(event->target());
       // This is tiptoeing around crbug.com/310172. If this event handler isn't
       // removed, we enter an infinite loop.
       target->RemovePreTargetHandler(this);
       target->parent()->RemoveChild(target);
     }
   }
 
@@ skipping 20 matching lines @@
   run_loop.Run();
 }
 
 }  // namespace
 
 class GestureRecognizerTest : public AuraTestBase,
                               public ::testing::WithParamInterface<bool> {
  public:
   GestureRecognizerTest() {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     ui::GestureConfiguration::set_show_press_delay_in_ms(2);
     ui::GestureConfiguration::set_long_press_time_in_ms(3);
   }
 
   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerTest);
 };
 
 // Check that appropriate touch events generate tap gesture events.
 TEST_F(GestureRecognizerTest, GestureEventTap) {
@@ skipping 2323 matching lines @@
 
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(delegate->long_press());
 }
 
 // Same as GestureEventConsumeDelegate, but consumes all the touch-move events.
 class ConsumesTouchMovesDelegate : public GestureEventConsumeDelegate {
  public:
   ConsumesTouchMovesDelegate() : consume_touch_move_(true) {}
-  virtual ~ConsumesTouchMovesDelegate() {}
+  ~ConsumesTouchMovesDelegate() override {}
 
   void set_consume_touch_move(bool consume) { consume_touch_move_ = consume; }
 
  private:
-  virtual void OnTouchEvent(ui::TouchEvent* touch) override {
+  void OnTouchEvent(ui::TouchEvent* touch) override {
     if (consume_touch_move_ && touch->type() == ui::ET_TOUCH_MOVED)
       touch->SetHandled();
     else
       GestureEventConsumeDelegate::OnTouchEvent(touch);
   }
 
   bool consume_touch_move_;
 
   DISALLOW_COPY_AND_ASSIGN(ConsumesTouchMovesDelegate);
 };
@@ skipping 1105 matching lines @@
 }
 
 // A delegate that deletes a window on long press.
 class GestureEventDeleteWindowOnLongPress : public GestureEventConsumeDelegate {
  public:
   GestureEventDeleteWindowOnLongPress()
       : window_(NULL) {}
 
   void set_window(aura::Window** window) { window_ = window; }
 
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
+  void OnGestureEvent(ui::GestureEvent* gesture) override {
     GestureEventConsumeDelegate::OnGestureEvent(gesture);
     if (gesture->type() != ui::ET_GESTURE_LONG_PRESS)
       return;
     ui::GestureRecognizer::Get()->CleanupStateForConsumer(*window_);
     delete *window_;
     *window_ = NULL;
   }
 
  private:
   aura::Window** window_;
@@ skipping 184 matching lines @@
   ui::TouchEvent move3(
       ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
 
   delegate->ReceivedAck();
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 }  // namespace test
 }  // namespace aura