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;
+
+  if (set_velocity && !velocity_x && !velocity_y)
+    return false;
+
+  gfx::Vector2dF velocity(0, 0);
   gfx::Vector2dF distance;
-  if (direction == "down")
+
+  if (direction == "down") {
     distance.set_y(-distance_length);
-  else if (direction == "up")
+    velocity.set_y(-velocity_y);
+  } else if (direction == "up") {
     distance.set_y(distance_length);
-  else if (direction == "right")
+    velocity.set_y(velocity_y);
+  } else if (direction == "right") {
     distance.set_x(-distance_length);
-  else if (direction == "left")
+    velocity.set_x(-velocity_x);
+  } else if (direction == "left") {
     distance.set_x(distance_length);
-  else if (direction == "upleft") {
+    velocity.set_x(velocity_x);
+  } else if (direction == "upleft") {
     distance.set_y(distance_length);
     distance.set_x(distance_length);
+    velocity.set_y(velocity_y);
+    velocity.set_x(velocity_x);
   } else if (direction == "upright") {
     distance.set_y(distance_length);
     distance.set_x(-distance_length);
+    velocity.set_y(velocity_y);
+    velocity.set_x(-velocity_x);
   } else if (direction == "downleft") {
     distance.set_y(-distance_length);
     distance.set_x(distance_length);
+    velocity.set_y(-velocity_y);
+    velocity.set_x(velocity_x);
   } else if (direction == "downright") {
     distance.set_y(-distance_length);
     distance.set_x(-distance_length);
+    velocity.set_y(-velocity_y);
+    velocity.set_x(-velocity_x);
   } else {
     return false;
   }
+
   gesture_params->distances.push_back(distance);
 
+  if (set_velocity)

[tdresser, 2017/03/23 15:47:33]

I suppose we don't even need the condition here, seeing as velocity will be 0,0
if set_velocity is false.

[sahel, 2017/03/24 20:21:57]

Done.

+    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 293 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;
   }
 
-  return BeginSmoothScroll(args->isolate(),
-                           -pixels_to_scroll,
-                           callback,
-                           1,  // TOUCH_INPUT
-                           direction,
-                           speed_in_pixels_s,
-                           false,
-                           start_x,
-                           start_y);
+  // 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;
+  }
+
+  return BeginSmoothScroll(args->isolate(), 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