Standardize usage of virtual/override/final in ui/

ui/events/gesture_detection/gesture_provider.cc

 // Copyright 2014 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 "ui/events/gesture_detection/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 176 matching lines @@
           return;
       default:
         break;
     };
 
     client_->OnGestureEvent(gesture);
     GestureTouchUMAHistogram::RecordGestureEvent(gesture);
   }
 
   // ScaleGestureListener implementation.
-  virtual bool OnScaleBegin(const ScaleGestureDetector& detector,
-                            const MotionEvent& e) override {
+  bool OnScaleBegin(const ScaleGestureDetector& detector,
+                    const MotionEvent& e) override {
     if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
     return true;
   }
 
-  virtual void OnScaleEnd(const ScaleGestureDetector& detector,
-                          const MotionEvent& e) override {
+  void OnScaleEnd(const ScaleGestureDetector& detector,
+                  const MotionEvent& e) override {
     if (!pinch_event_sent_)
       return;
     Send(CreateGesture(ET_GESTURE_PINCH_END, e));
   }
 
-  virtual bool OnScale(const ScaleGestureDetector& detector,
-                       const MotionEvent& e) override {
+  bool OnScale(const ScaleGestureDetector& detector,
+               const MotionEvent& e) override {
     if (ignore_multitouch_zoom_events_ && !detector.InDoubleTapMode())
       return false;
     if (!pinch_event_sent_) {
       Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
                          e.GetId(),
                          e.GetToolType(),
                          detector.GetEventTime(),
                          detector.GetFocusX(),
                          detector.GetFocusY(),
                          detector.GetFocusX() + e.GetRawOffsetX(),
@@ skipping 34 matching lines @@
                        detector.GetFocusY(),
                        detector.GetFocusX() + e.GetRawOffsetX(),
                        detector.GetFocusY() + e.GetRawOffsetY(),
                        e.GetPointerCount(),
                        GetBoundingBox(e, pinch_details.type()),
                        e.GetFlags()));
     return true;
   }
 
   // GestureListener implementation.
-  virtual bool OnDown(const MotionEvent& e) override {
+  bool OnDown(const MotionEvent& e) override {
     GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN);
     Send(CreateGesture(tap_details, e));
 
     // Return true to indicate that we want to handle touch.
     return true;
   }
 
-  virtual bool OnScroll(const MotionEvent& e1,
-                        const MotionEvent& e2,
-                        float raw_distance_x,
-                        float raw_distance_y) override {
+  bool OnScroll(const MotionEvent& e1,
+                const MotionEvent& e2,
+                float raw_distance_x,
+                float raw_distance_y) override {
     float distance_x = raw_distance_x;
     float distance_y = raw_distance_y;
     if (!scroll_event_sent_) {
       // Remove the touch slop region from the first scroll event to avoid a
       // jump.
       float distance =
           std::sqrt(distance_x * distance_x + distance_y * distance_y);
       float epsilon = 1e-3f;
       if (distance > epsilon) {
         float ratio =
@@ skipping 49 matching lines @@
                          raw_center.x(),
                          raw_center.y(),
                          e2.GetPointerCount(),
                          bounding_box,
                          e2.GetFlags()));
     }
 
     return true;
   }
 
-  virtual bool OnFling(const MotionEvent& e1,
-                       const MotionEvent& e2,
-                       float velocity_x,
-                       float velocity_y) override {
+  bool OnFling(const MotionEvent& e1,
+               const MotionEvent& e2,
+               float velocity_x,
+               float velocity_y) override {
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal()) {
         velocity_y = 0;
       } else {
         velocity_x = 0;
       }
     }
 
     if (!velocity_x && !velocity_y)
       return true;
 
     if (!scroll_event_sent_) {
       // The native side needs a ET_GESTURE_SCROLL_BEGIN before
       // ET_SCROLL_FLING_START to send the fling to the correct target.
       // The distance traveled in one second is a reasonable scroll start hint.
       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_BEGIN, velocity_x, velocity_y);
       Send(CreateGesture(scroll_details, e2));
     }
 
     GestureEventDetails fling_details(
         ET_SCROLL_FLING_START, velocity_x, velocity_y);
     Send(CreateGesture(fling_details, e2));
     return true;
   }
 
-  virtual bool OnSwipe(const MotionEvent& e1,
-                       const MotionEvent& e2,
-                       float velocity_x,
-                       float velocity_y) override {
+  bool OnSwipe(const MotionEvent& e1,
+               const MotionEvent& e2,
+               float velocity_x,
+               float velocity_y) override {
     GestureEventDetails swipe_details(ET_GESTURE_SWIPE, velocity_x, velocity_y);
     Send(CreateGesture(swipe_details, e2));
     return true;
   }
 
-  virtual bool OnTwoFingerTap(const MotionEvent& e1,
-                              const MotionEvent& e2) override {
+  bool OnTwoFingerTap(const MotionEvent& e1, const MotionEvent& e2) override {
     // The location of the two finger tap event should be the location of the
     // primary pointer.
     GestureEventDetails two_finger_tap_details(
         ET_GESTURE_TWO_FINGER_TAP, e1.GetTouchMajor(), e1.GetTouchMajor());
     Send(CreateGesture(two_finger_tap_details,
                        e2.GetId(),
                        e2.GetToolType(),
                        e2.GetEventTime(),
                        e1.GetX(),
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
                        GetBoundingBox(e2, two_finger_tap_details.type()),
                        e2.GetFlags()));
     return true;
   }
 
-  virtual void OnShowPress(const MotionEvent& e) override {
+  void OnShowPress(const MotionEvent& e) override {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS);
     show_press_event_sent_ = true;
     Send(CreateGesture(show_press_details, e));
   }
 
-  virtual bool OnSingleTapUp(const MotionEvent& e) override {
+  bool OnSingleTapUp(const MotionEvent& e) override {
     // This is a hack to address the issue where user hovers
     // over a link for longer than double_tap_timeout_, then
     // OnSingleTapConfirmed() is not triggered. But we still
     // want to trigger the tap event at UP. So we override
     // OnSingleTapUp() in this case. This assumes singleTapUp
     // gets always called before singleTapConfirmed.
     if (!ignore_single_tap_) {
       if (e.GetEventTime() - current_down_time_ >
           config_.gesture_detector_config.double_tap_timeout) {
         return OnSingleTapConfirmed(e);
@@ skipping 13 matching lines @@
         !IsScaleGestureDetectionInProgress()) {
       GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP);
       Send(CreateGesture(long_tap_details, e));
       return true;
     }
 
     return false;
   }
 
   // DoubleTapListener implementation.
-  virtual bool OnSingleTapConfirmed(const MotionEvent& e) override {
+  bool OnSingleTapConfirmed(const MotionEvent& e) override {
     // Long taps in the edges of the screen have their events delayed by
     // ContentViewHolder for tab swipe operations. As a consequence of the delay
     // this method might be called after receiving the up event.
     // These corner cases should be ignored.
     if (ignore_single_tap_)
       return true;
 
     ignore_single_tap_ = true;
 
     Send(CreateTapGesture(ET_GESTURE_TAP, e));
     return true;
   }
 
-  virtual bool OnDoubleTap(const MotionEvent& e) override {
+  bool OnDoubleTap(const MotionEvent& e) override {
     return scale_gesture_detector_.OnDoubleTap(e);
   }
 
-  virtual bool OnDoubleTapEvent(const MotionEvent& e) override {
+  bool OnDoubleTapEvent(const MotionEvent& e) override {
     switch (e.GetAction()) {
       case MotionEvent::ACTION_DOWN:
         gesture_detector_.set_longpress_enabled(false);
         break;
 
       case MotionEvent::ACTION_UP:
         if (!IsPinchInProgress() && !IsScrollInProgress()) {
           Send(CreateTapGesture(ET_GESTURE_DOUBLE_TAP, e));
           return true;
         }
         break;
 
       default:
         break;
     }
     return false;
   }
 
-  virtual void OnLongPress(const MotionEvent& e) override {
+  void OnLongPress(const MotionEvent& e) override {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
     GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS);
     Send(CreateGesture(long_press_details, e));
   }
 
   GestureEventData CreateGesture(const GestureEventDetails& details,
                                  int motion_event_id,
                                  MotionEvent::ToolType primary_tool_type,
                                  base::TimeTicks time,
@@ skipping 318 matching lines @@
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled =
       double_tap_support_for_page_ && double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui