gpu benchmarking swipe for touchpad

content/browser/renderer_host/input/synthetic_smooth_move_gesture.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 "content/browser/renderer_host/input/synthetic_smooth_move_gesture.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/point_f.h"
@@ skipping 20 matching lines @@
 
 double ConvertTimestampToSeconds(const base::TimeTicks& timestamp) {
   return (timestamp - base::TimeTicks()).InSecondsF();
 }
 
 const int kDefaultSpeedInPixelsPerSec = 800;
 
 }  // namespace
 
 SyntheticSmoothMoveGestureParams::SyntheticSmoothMoveGestureParams()
-    : speed_in_pixels_s(kDefaultSpeedInPixelsPerSec),
+    : velocity(gfx::Vector2dF(0, 0)),
+      speed_in_pixels_s(kDefaultSpeedInPixelsPerSec),
       prevent_fling(true),
       add_slop(true) {}
 
 SyntheticSmoothMoveGestureParams::SyntheticSmoothMoveGestureParams(
     const SyntheticSmoothMoveGestureParams& other) = default;
 
 SyntheticSmoothMoveGestureParams::~SyntheticSmoothMoveGestureParams() {}
 
 SyntheticSmoothMoveGesture::SyntheticSmoothMoveGesture(
     SyntheticSmoothMoveGestureParams params)
@@ skipping 118 matching lines @@
       gfx::Vector2d delta_discrete =
           FloorTowardZero(current_move_segment_total_delta -
                           current_move_segment_total_delta_discrete_);
       ForwardMouseWheelEvent(target, delta_discrete, event_timestamp);
       current_move_segment_total_delta_discrete_ += delta_discrete;
 
       if (FinishedCurrentMoveSegment(event_timestamp)) {
         if (!IsLastMoveSegment()) {
           current_move_segment_total_delta_discrete_ = gfx::Vector2d();
           ComputeNextMoveSegment();
-          ForwardMouseWheelInputEvents(timestamp, target);
+        } else if (params_.prevent_fling) {
+          state_ = DONE;
         } else {
-          state_ = DONE;
+          state_ = STOPPING;
         }
       }
     } break;
+    case STOPPING: {
+      gfx::Vector2d velocity_discrete = FloorTowardZero(params_.velocity);
+      ForwardTouchpadFlingEvent(target, velocity_discrete, timestamp);
+      state_ = DONE;
+    } break;
     case SETUP:
       NOTREACHED() << "State SETUP invalid for synthetic scroll using mouse "
                       "wheel input.";
-    case STOPPING:
-      NOTREACHED() << "State STOPPING invalid for synthetic scroll using mouse "
-                      "wheel input.";
     case DONE:
       NOTREACHED()
           << "State DONE invalid for synthetic scroll using mouse wheel input.";
   }
 }
 
 void SyntheticSmoothMoveGesture::ForwardMouseClickInputEvents(
     const base::TimeTicks& timestamp,
     SyntheticGestureTarget* target) {
   base::TimeTicks event_timestamp = timestamp;
@@ skipping 45 matching lines @@
 
   mouse_wheel_event.SetPositionInWidget(
       current_move_segment_start_position_.x(),
       current_move_segment_start_position_.y());
 
   mouse_wheel_event.SetTimeStampSeconds(ConvertTimestampToSeconds(timestamp));
 
   target->DispatchInputEventToPlatform(mouse_wheel_event);
 }
 
+void SyntheticSmoothMoveGesture::ForwardTouchpadFlingEvent(
+    SyntheticGestureTarget* target,
+    const gfx::Vector2dF& velocity,
+    const base::TimeTicks& timestamp) const {
+  blink::WebGestureEvent fling_event =
+      SyntheticWebGestureEventBuilder::BuildFling(
+          velocity.x(), velocity.y(),
+          blink::WebGestureDevice::kWebGestureDeviceTouchpad);
+
+  fling_event.x = current_move_segment_start_position_.x();
+  fling_event.y = current_move_segment_start_position_.y();
+
+  fling_event.SetTimeStampSeconds(ConvertTimestampToSeconds(timestamp));
+
+  target->DispatchInputEventToPlatform(fling_event);
+}
+
 void SyntheticSmoothMoveGesture::PressPoint(SyntheticGestureTarget* target,
                                             const base::TimeTicks& timestamp) {
   DCHECK_EQ(current_move_segment_, 0);
   synthetic_pointer_driver_->Press(current_move_segment_start_position_.x(),
                                    current_move_segment_start_position_.y());
   synthetic_pointer_driver_->DispatchEvent(target, timestamp);
 }
 
 void SyntheticSmoothMoveGesture::MovePoint(SyntheticGestureTarget* target,
                                            const gfx::Vector2dF& delta,
@@ skipping 70 matching lines @@
   DCHECK_LT(current_move_segment_, static_cast<int>(params_.distances.size()));
   return current_move_segment_ ==
          static_cast<int>(params_.distances.size()) - 1;
 }
 
 bool SyntheticSmoothMoveGesture::MoveIsNoOp() const {
   return params_.distances.size() == 0 || params_.distances[0].IsZero();
 }
 
 }  // namespace content