Prepare SyntheticPointerAction to handle touch actions for multiple fingers

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>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/layer.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
+#include "content/common/input/synthetic_pointer_action_params.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/chrome_object_extensions_utils.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
@@ skipping 461 matching lines @@
       .SetMethod("gestureSourceTypeSupported",
                  &GpuBenchmarking::GestureSourceTypeSupported)
       .SetMethod("smoothScrollBy", &GpuBenchmarking::SmoothScrollBy)
       .SetMethod("smoothDrag", &GpuBenchmarking::SmoothDrag)
       .SetMethod("swipe", &GpuBenchmarking::Swipe)
       .SetMethod("scrollBounce", &GpuBenchmarking::ScrollBounce)
       .SetMethod("pinchBy", &GpuBenchmarking::PinchBy)
       .SetMethod("visualViewportHeight", &GpuBenchmarking::VisualViewportHeight)
       .SetMethod("visualViewportWidth", &GpuBenchmarking::VisualViewportWidth)
       .SetMethod("tap", &GpuBenchmarking::Tap)
+      .SetMethod("touchActionSequence", &GpuBenchmarking::TouchActionSequence)
       .SetMethod("clearImageCache", &GpuBenchmarking::ClearImageCache)
       .SetMethod("runMicroBenchmark", &GpuBenchmarking::RunMicroBenchmark)
       .SetMethod("sendMessageToMicroBenchmark",
                  &GpuBenchmarking::SendMessageToMicroBenchmark)
       .SetMethod("hasGpuChannel", &GpuBenchmarking::HasGpuChannel)
       .SetMethod("hasGpuProcess", &GpuBenchmarking::HasGpuProcess)
       .SetMethod("getGpuDriverBugWorkarounds",
                  &GpuBenchmarking::GetGpuDriverBugWorkarounds);
 }
 
@@ skipping 287 matching lines @@
 }
 
 float GpuBenchmarking::VisualViewportWidth() {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return 0.0;
   return context.web_view()->visualViewportSize().width;
 }
 
 bool GpuBenchmarking::Tap(gin::Arguments* args) {
+  LOG(ERROR) << "GpuBenchmarking::Tap";
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
   float position_x;
   float position_y;
   v8::Local<v8::Function> callback;
   int duration_ms = 50;
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
 
@@ skipping 32 matching lines @@
   // progress, we will leak the callback and context. This needs to be fixed,
   // somehow.
   context.render_view_impl()->GetWidget()->QueueSyntheticGesture(
       std::move(gesture_params),
       base::Bind(&OnSyntheticGestureCompleted,
                  base::RetainedRef(callback_and_context)));
 
   return true;
 }
 
+bool GpuBenchmarking::TouchActionSequence(gin::Arguments* args) {
+  GpuBenchmarkingContext context;
+  if (!context.Init(false))
+    return false;
+
+  v8::Local<v8::Function> callback;
+
+  // pass a two-dimensional list of actions.

[tdresser, 2016/04/18 15:24:39]

pass -> Pass

Is this supposed to be currently passing a 2D list of actions? If so, I'm a bit
confused.

[lanwei, 2016/04/19 19:05:32]

Yes, it should be 2D array. I am not sure how to carry this 2D array and extract
it from gin::Arguments. I will confirm with Sam and add this part, and I will
add a todo for this for now.

+
+  int pointer_action_type_int;
+  int index;
+  float position_x;
+  float position_y;
+  int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
+  SyntheticPointerActionParams::PointerActionType pointer_action_type;
+  if (!GetArg(args, &pointer_action_type_int)) {
+    return false;
+  }
+  pointer_action_type =
+      static_cast<SyntheticPointerActionParams::PointerActionType>(
+          pointer_action_type_int);
+  LOG(ERROR) << "GpuBenchmarking::TouchActionSequence "
+             << pointer_action_type_int;
+  scoped_ptr<SyntheticPointerActionParams> gesture_params(
+      new SyntheticPointerActionParams(pointer_action_type));
+
+  if (pointer_action_type !=
+      SyntheticPointerActionParams::PointerActionType::PROCESS) {
+    if (!GetArg(args, &index)) {
+      return false;
+    }
+    gesture_params->set_index(index);
+    if (pointer_action_type ==
+            SyntheticPointerActionParams::PointerActionType::PRESS ||
+        pointer_action_type ==
+            SyntheticPointerActionParams::PointerActionType::MOVE) {
+      if (!GetArg(args, &position_x) || !GetArg(args, &position_y)) {
+        return false;
+      }
+      gesture_params->set_position(gfx::PointF(position_x, position_y));
+    }
+  }
+
+  if (!GetOptionalArg(args, &gesture_source_type)) {
+    return false;
+  }
+
+  // We do not need a callback everytime sending an action?
+  scoped_refptr<CallbackAndContext> callback_and_context =
+      new CallbackAndContext(args->isolate(), callback,
+                             context.web_frame()->mainWorldScriptContext());
+
+  // TODO(nduca): 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.
+  context.render_view_impl()->GetWidget()->QueueSyntheticGesture(
+      std::move(gesture_params));
+
+  // At the end, ask for call back?
+  // context.render_view_impl()->GetWidget()->QueueSyntheticGesture(
+  //     std::move(gesture_params),
+  //     base::Bind(&OnSyntheticGestureCompleted,
+  //                base::RetainedRef(callback_and_context)));
+
+  return true;
+}
+
 void GpuBenchmarking::ClearImageCache() {
   WebImageCache::clear();
 }
 
 int GpuBenchmarking::RunMicroBenchmark(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return 0;
 
   std::string name;
@@ skipping 63 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