gpu benchmarking swipe for touchpad

content/renderer/gpu/gpu_benchmarking_extension.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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 319 matching lines @@
 }
 
 bool BeginSmoothScroll(v8::Isolate* isolate,
                        float pixels_to_scroll,
                        v8::Local<v8::Function> callback,
                        int gesture_source_type,
                        const std::string& direction,
                        float speed_in_pixels_s,
                        bool prevent_fling,
                        float start_x,
-                       float start_y) {
+                       float start_y,
+                       float velocity_x = 0,
+                       float velocity_y = 0) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
   // Convert coordinates from CSS pixels to density independent pixels (DIPs).
   float page_scale_factor = context.web_view()->pageScaleFactor();
 
   if (gesture_source_type == SyntheticGestureParams::MOUSE_INPUT) {
     // Ensure the mouse is centered and visible, in case it will
     // trigger any hover or mousemove effects.
@@ skipping 25 matching lines @@
       static_cast<SyntheticGestureParams::GestureSourceType>(
           gesture_source_type);
 
   gesture_params->speed_in_pixels_s = speed_in_pixels_s;
   gesture_params->prevent_fling = prevent_fling;
 
   gesture_params->anchor.SetPoint(start_x * page_scale_factor,
                                   start_y * page_scale_factor);
 
   float distance_length = pixels_to_scroll * page_scale_factor;
+
+  bool set_velocity =
+      gesture_source_type == SyntheticGestureParams::MOUSE_INPUT &&
+      !prevent_fling;
+
+  DCHECK(!set_velocity || velocity_x || velocity_y);
+  if (set_velocity && !velocity_x && !velocity_y)

[bokan, 2017/03/10 14:41:57]

Ditto here for the DCHECK and |if|

[sahel, 2017/03/10 21:51:41]

Done.

+    return false;
+
+  gfx::Vector2dF velocity;
   gfx::Vector2dF distance;
-  if (direction == "down")
+
+  if (direction == "down") {

[bokan, 2017/03/10 14:41:57]

Question: do we really need this direction parameter? Couldn't we just agree on
a convention that positive distance/velocity means "direction that causes
scrolling downwards" and use a pair of floats to represent the distance?

We used to do something similar in EventHandler way back and we've converted to
just use this convention. It's much simpler. (Not necessarily requesting it for
this patch)

[sahel, 2017/03/10 21:51:41]

I am not sure why we have it here, but one reason can be for scrolling both
horizontally and vertically. Instead of having deltas in x and y direction, here
we have pixels to scroll and direction.

     distance.set_y(-distance_length);
-  else if (direction == "up")
+    velocity.set_y(set_velocity ? -velocity_y : 0);
+  } else if (direction == "up") {
     distance.set_y(distance_length);
-  else if (direction == "right")
+    velocity.set_y(set_velocity ? velocity_y : 0);
+  } else if (direction == "right") {
     distance.set_x(-distance_length);
-  else if (direction == "left")
+    velocity.set_x(set_velocity ? -velocity_x : 0);
+  } else if (direction == "left") {
     distance.set_x(distance_length);
-  else if (direction == "upleft") {
+    velocity.set_x(set_velocity ? velocity_x : 0);
+  } else if (direction == "upleft") {
     distance.set_y(distance_length);
     distance.set_x(distance_length);
+    velocity.set_y(set_velocity ? velocity_y : 0);
+    velocity.set_x(set_velocity ? velocity_x : 0);
   } else if (direction == "upright") {
     distance.set_y(distance_length);
     distance.set_x(-distance_length);
+    velocity.set_y(set_velocity ? velocity_y : 0);
+    velocity.set_x(set_velocity ? -velocity_x : 0);
   } else if (direction == "downleft") {
     distance.set_y(-distance_length);
     distance.set_x(distance_length);
+    velocity.set_y(set_velocity ? -velocity_y : 0);
+    velocity.set_x(set_velocity ? velocity_x : 0);
   } else if (direction == "downright") {
     distance.set_y(-distance_length);
     distance.set_x(-distance_length);
+    velocity.set_y(set_velocity ? -velocity_y : 0);
+    velocity.set_x(set_velocity ? -velocity_x : 0);
   } else {
     return false;
   }
+
   gesture_params->distances.push_back(distance);
+  gesture_params->velocity = velocity;
 
   // TODO(678879): If the render_view_impl is destroyed while the gesture is in
   // progress, we will leak the callback and context. This needs to be fixed,
   // somehow, see https://crbug.com/678879.
   context.render_view_impl()->GetWidget()->QueueSyntheticGesture(
       std::move(gesture_params),
       base::Bind(&OnSyntheticGestureCompleted,
                  base::RetainedRef(callback_and_context)));
 
   return true;
@@ skipping 294 matching lines @@
 }
 
 bool GpuBenchmarking::Swipe(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
   float page_scale_factor = context.web_view()->pageScaleFactor();
   blink::WebRect rect = context.render_view_impl()->GetWidget()->viewRect();
 
-  std::string direction = "up";
+  std::string direction = "down";
   float pixels_to_scroll = 0;
   v8::Local<v8::Function> callback;
   float start_x = rect.width / (page_scale_factor * 2);
   float start_y = rect.height / (page_scale_factor * 2);
   float speed_in_pixels_s = 800;
+  int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
+  float velocity_x = 0;
+  float velocity_y = 0;
 
   if (!GetOptionalArg(args, &direction) ||
       !GetOptionalArg(args, &pixels_to_scroll) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &start_x) ||
       !GetOptionalArg(args, &start_y) ||
       !GetOptionalArg(args, &speed_in_pixels_s)) {
     return false;
   }
 
+  // If no gesture source type is provided, do a touch swipe by default.
+  if (!GetOptionalArg(args, &gesture_source_type)) {
+    gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  }
+
+  if (gesture_source_type == SyntheticGestureParams::MOUSE_INPUT &&
+      (!GetOptionalArg(args, &velocity_x) ||
+       !GetOptionalArg(args, &velocity_y))) {
+    return false;
+  }
+
+  float direction_adjustment = SyntheticGestureParams::TOUCH_INPUT ? 1 : -1;
   return BeginSmoothScroll(args->isolate(),
-                           -pixels_to_scroll,
-                           callback,
-                           1,  // TOUCH_INPUT
-                           direction,
-                           speed_in_pixels_s,
-                           false,
-                           start_x,
-                           start_y);
+                           direction_adjustment * pixels_to_scroll, callback,
+                           gesture_source_type, direction, speed_in_pixels_s,
+                           false, start_x, start_y, velocity_x, velocity_y);
 }
 
 bool GpuBenchmarking::ScrollBounce(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
   float page_scale_factor = context.web_view()->pageScaleFactor();
   blink::WebRect rect = context.render_view_impl()->GetWidget()->viewRect();
 
@@ skipping 340 matching lines @@
           &gpu_driver_bug_workarounds))) {
     return;
   }
 
   v8::Local<v8::Value> result;
   if (gin::TryConvertToV8(args->isolate(), gpu_driver_bug_workarounds, &result))
     args->Return(result);
 }
 
 }  // namespace content