Add wheel scroll options to GpuBenchmarking

In GpuBenchmarking, for mouse wheel and touchpad scroll, we want to add
"has_precise_scrolling_deltas" scroll option to
GpuBenchmarking::SmoothScrollBy.


Bug: 871970
Change-Id: I456db492e2a7fdab35263efe931d089b400a9e3d
Reviewed-on: https://chromium-review.googlesource.com/1166165Reviewed-by: Fady Samuel <fsamuel@chromium.org>
Reviewed-by: Navid Zolghadr <nzolghadr@chromium.org>
Reviewed-by: Sahel Sharify <sahel@chromium.org>
Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Commit-Queue: Lan Wei <lanwei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#583249}

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

@@ -188,7 +188,8 @@ class MockSyntheticGestureTarget : public SyntheticGestureTarget {
 
 class MockMoveGestureTarget : public MockSyntheticGestureTarget {
  public:
-  MockMoveGestureTarget() : total_abs_move_distance_length_(0) {}
+  MockMoveGestureTarget()
+      : total_abs_move_distance_length_(0), precise_scrolling_deltas_(false) {}
   ~MockMoveGestureTarget() override {}
 
   gfx::Vector2dF start_to_end_distance() const {
@@ -197,10 +198,12 @@ class MockMoveGestureTarget : public MockSyntheticGestureTarget {
   float total_abs_move_distance_length() const {
     return total_abs_move_distance_length_;
   }
+  bool precise_scrolling_deltas() const { return precise_scrolling_deltas_; }
 
  protected:
   gfx::Vector2dF start_to_end_distance_;
   float total_abs_move_distance_length_;
+  bool precise_scrolling_deltas_;
 };
 
 class MockScrollMouseTarget : public MockMoveGestureTarget {
@@ -215,6 +218,7 @@ class MockScrollMouseTarget : public MockMoveGestureTarget {
     gfx::Vector2dF delta(mouse_wheel_event.delta_x, mouse_wheel_event.delta_y);
     start_to_end_distance_ += delta;
     total_abs_move_distance_length_ += delta.Length();
+    precise_scrolling_deltas_ = mouse_wheel_event.has_precise_scrolling_deltas;
   }
 };
 
@@ -1186,6 +1190,28 @@ TEST_F(SyntheticGestureControllerTest, MultiScrollGestureMouseHorizontal) {
                   scroll_target->start_to_end_distance().x());
 }
 
+TEST_F(SyntheticGestureControllerTest, SingleScrollGestureMousePreciseScroll) {
+  CreateControllerAndTarget<MockScrollMouseTarget>();
+
+  SyntheticSmoothMoveGestureParams params;
+  params.input_type = SyntheticSmoothMoveGestureParams::MOUSE_WHEEL_INPUT;
+  params.start_point.SetPoint(39, 86);
+  params.distances.push_back(gfx::Vector2d(0, -132));
+  params.precise_scrolling_deltas = true;
+
+  std::unique_ptr<SyntheticSmoothMoveGesture> gesture(
+      new SyntheticSmoothMoveGesture(params));
+  QueueSyntheticGesture(std::move(gesture));
+  FlushInputUntilComplete();
+
+  MockMoveGestureTarget* scroll_target =
+      static_cast<MockMoveGestureTarget*>(target_);
+  EXPECT_EQ(1, num_success_);
+  EXPECT_EQ(0, num_failure_);
+  EXPECT_EQ(params.precise_scrolling_deltas,
+            scroll_target->precise_scrolling_deltas());
+}
+
 void CheckIsWithinRangeMulti(float scroll_distance,
                              int target_distance,
                              SyntheticGestureTarget* target) {

content/browser/renderer_host/input/synthetic_gesture_target_aura.cc

@@ -81,9 +81,12 @@ void SyntheticGestureTargetAura::DispatchWebMouseWheelEventToPlatform(
     return;
   }
   base::TimeTicks timestamp = web_wheel.TimeStamp();
+  int modifiers = web_wheel.has_precise_scrolling_deltas
+                      ? ui::EF_PRECISION_SCROLLING_DELTA
+                      : ui::EF_NONE;
   ui::MouseWheelEvent wheel_event(
       gfx::Vector2d(web_wheel.delta_x, web_wheel.delta_y), gfx::Point(),
-      gfx::Point(), timestamp, ui::EF_NONE, ui::EF_NONE);
+      gfx::Point(), timestamp, modifiers, ui::EF_NONE);
   gfx::PointF location(web_wheel.PositionInWidget().x * device_scale_factor_,
                        web_wheel.PositionInWidget().y * device_scale_factor_);
   wheel_event.set_location_f(location);

content/browser/renderer_host/input/synthetic_smooth_move_gesture.cc

@@ -30,7 +30,8 @@ const int kDefaultSpeedInPixelsPerSec = 800;
 SyntheticSmoothMoveGestureParams::SyntheticSmoothMoveGestureParams()
     : speed_in_pixels_s(kDefaultSpeedInPixelsPerSec),
       prevent_fling(true),
-      add_slop(true) {}
+      add_slop(true),
+      precise_scrolling_deltas(false) {}
 
 SyntheticSmoothMoveGestureParams::SyntheticSmoothMoveGestureParams(
     const SyntheticSmoothMoveGestureParams& other) = default;
@@ -258,8 +259,8 @@ void SyntheticSmoothMoveGesture::ForwardMouseWheelEvent(
     const blink::WebMouseWheelEvent::Phase phase,
     const base::TimeTicks& timestamp) const {
   blink::WebMouseWheelEvent mouse_wheel_event =
-      SyntheticWebMouseWheelEventBuilder::Build(0, 0, delta.x(), delta.y(), 0,
-                                                false);
+      SyntheticWebMouseWheelEventBuilder::Build(
+          0, 0, delta.x(), delta.y(), 0, params_.precise_scrolling_deltas);
 
   mouse_wheel_event.SetPositionInWidget(
       current_move_segment_start_position_.x(),

content/browser/renderer_host/input/synthetic_smooth_move_gesture.h

@@ -36,6 +36,7 @@ class CONTENT_EXPORT SyntheticSmoothMoveGestureParams {
   int speed_in_pixels_s;
   bool prevent_fling;
   bool add_slop;
+  bool precise_scrolling_deltas;
 };
 
 // This class is used as helper class for simulation of scroll and drag.

content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.cc

@@ -48,6 +48,7 @@ bool SyntheticSmoothScrollGesture::InitializeMoveGesture(
     move_params.prevent_fling = params_.prevent_fling;
     move_params.input_type = GetInputSourceType(gesture_type);
     move_params.add_slop = true;
+    move_params.precise_scrolling_deltas = params_.precise_scrolling_deltas;
     move_gesture_.reset(new SyntheticSmoothMoveGesture(move_params));
     return true;
   }

content/common/input/synthetic_smooth_scroll_gesture_params.cc

@@ -14,15 +14,18 @@ const float kDefaultSpeedInPixelsS = 800;
 }  // namespace
 
 SyntheticSmoothScrollGestureParams::SyntheticSmoothScrollGestureParams()
-    : prevent_fling(true), speed_in_pixels_s(kDefaultSpeedInPixelsS) {}
+    : prevent_fling(true),
+      speed_in_pixels_s(kDefaultSpeedInPixelsS),
+      precise_scrolling_deltas(false) {}
 
 SyntheticSmoothScrollGestureParams::SyntheticSmoothScrollGestureParams(
-      const SyntheticSmoothScrollGestureParams& other)
+    const SyntheticSmoothScrollGestureParams& other)
     : SyntheticGestureParams(other),
       anchor(other.anchor),
       distances(other.distances),
       prevent_fling(other.prevent_fling),
-      speed_in_pixels_s(other.speed_in_pixels_s) {}
+      speed_in_pixels_s(other.speed_in_pixels_s),
+      precise_scrolling_deltas(other.precise_scrolling_deltas) {}
 
 SyntheticSmoothScrollGestureParams::~SyntheticSmoothScrollGestureParams() {}
 

content/common/input/synthetic_smooth_scroll_gesture_params.h

@@ -28,6 +28,7 @@ struct CONTENT_EXPORT SyntheticSmoothScrollGestureParams
   std::vector<gfx::Vector2dF> distances;  // Positive X/Y to scroll left/up.
   bool prevent_fling;  // Defaults to true.
   float speed_in_pixels_s;
+  bool precise_scrolling_deltas;
 
   static const SyntheticSmoothScrollGestureParams* Cast(
       const SyntheticGestureParams* gesture_params);

content/renderer/gpu/gpu_benchmarking_extension.cc

@@ -287,7 +287,8 @@ bool BeginSmoothScroll(GpuBenchmarkingContext* context,
                        float speed_in_pixels_s,
                        bool prevent_fling,
                        float start_x,
-                       float start_y) {
+                       float start_y,
+                       bool precise_scrolling_deltas) {
   gfx::Rect rect = context->render_view_impl()->GetWidget()->ViewRect();
   rect -= rect.OffsetFromOrigin();
   if (!rect.Contains(start_x, start_y)) {
@@ -324,6 +325,7 @@ bool BeginSmoothScroll(GpuBenchmarkingContext* context,
 
   gesture_params.speed_in_pixels_s = speed_in_pixels_s;
   gesture_params.prevent_fling = prevent_fling;
+  gesture_params.precise_scrolling_deltas = precise_scrolling_deltas;
 
   gesture_params.anchor.SetPoint(start_x, start_y);
 
@@ -641,21 +643,25 @@ bool GpuBenchmarking::SmoothScrollBy(gin::Arguments* args) {
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
   std::string direction = "down";
   float speed_in_pixels_s = 800;
+  bool precise_scrolling_deltas = true;
 
   if (!GetOptionalArg(args, &pixels_to_scroll) ||
-      !GetOptionalArg(args, &callback) ||
-      !GetOptionalArg(args, &start_x) ||
+      !GetOptionalArg(args, &callback) || !GetOptionalArg(args, &start_x) ||
       !GetOptionalArg(args, &start_y) ||
       !GetOptionalArg(args, &gesture_source_type) ||
       !GetOptionalArg(args, &direction) ||
-      !GetOptionalArg(args, &speed_in_pixels_s)) {
+      !GetOptionalArg(args, &speed_in_pixels_s) ||
+      !GetOptionalArg(args, &precise_scrolling_deltas)) {
     return false;
   }
 
+  DCHECK(gesture_source_type != SyntheticGestureParams::TOUCH_INPUT ||
+         precise_scrolling_deltas);
   EnsureRemoteInterface();
   return BeginSmoothScroll(&context, args, input_injector_, pixels_to_scroll,
                            callback, gesture_source_type, direction,
-                           speed_in_pixels_s, true, start_x, start_y);
+                           speed_in_pixels_s, true, start_x, start_y,
+                           precise_scrolling_deltas);
 }
 
 bool GpuBenchmarking::SmoothDrag(gin::Arguments* args) {
@@ -714,7 +720,7 @@ bool GpuBenchmarking::Swipe(gin::Arguments* args) {
   return BeginSmoothScroll(
       &context, args, input_injector_, -pixels_to_scroll, callback,
       1,  // TOUCH_INPUT
-      direction, speed_in_pixels_s, false, start_x, start_y);
+      direction, speed_in_pixels_s, false, start_x, start_y, true);
 }
 
 bool GpuBenchmarking::ScrollBounce(gin::Arguments* args) {