Test synthetic pointer action on pointer event tests

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/memory/ptr_util.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_list_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/actions_runner.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
 #include "third_party/WebKit/public/web/WebKit.h"
@@ skipping 496 matching lines @@
 gin::ObjectTemplateBuilder GpuBenchmarking::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<GpuBenchmarking>::GetObjectTemplateBuilder(isolate)
       .SetMethod("setNeedsDisplayOnAllLayers",
                  &GpuBenchmarking::SetNeedsDisplayOnAllLayers)
       .SetMethod("setRasterizeOnlyVisibleContent",
                  &GpuBenchmarking::SetRasterizeOnlyVisibleContent)
       .SetMethod("printToSkPicture", &GpuBenchmarking::PrintToSkPicture)
       .SetMethod("printPagesToSkPictures",
                  &GpuBenchmarking::PrintPagesToSkPictures)
-      .SetMethod("printPagesToXPS",
-                 &GpuBenchmarking::PrintPagesToXPS)
+      .SetMethod("printPagesToXPS", &GpuBenchmarking::PrintPagesToXPS)
       .SetValue("DEFAULT_INPUT", 0)
       .SetValue("TOUCH_INPUT", 1)
       .SetValue("MOUSE_INPUT", 2)
       .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("pageScaleFactor", &GpuBenchmarking::PageScaleFactor)
       .SetMethod("visualViewportX", &GpuBenchmarking::VisualViewportX)
       .SetMethod("visualViewportY", &GpuBenchmarking::VisualViewportY)
       .SetMethod("visualViewportHeight", &GpuBenchmarking::VisualViewportHeight)
       .SetMethod("visualViewportWidth", &GpuBenchmarking::VisualViewportWidth)
       .SetMethod("tap", &GpuBenchmarking::Tap)
       .SetMethod("clearImageCache", &GpuBenchmarking::ClearImageCache)
       .SetMethod("runMicroBenchmark", &GpuBenchmarking::RunMicroBenchmark)
       .SetMethod("sendMessageToMicroBenchmark",
                  &GpuBenchmarking::SendMessageToMicroBenchmark)
       .SetMethod("hasGpuChannel", &GpuBenchmarking::HasGpuChannel)
       .SetMethod("hasGpuProcess", &GpuBenchmarking::HasGpuProcess)
       .SetMethod("getGpuDriverBugWorkarounds",
-                 &GpuBenchmarking::GetGpuDriverBugWorkarounds);
+                 &GpuBenchmarking::GetGpuDriverBugWorkarounds)
+      .SetMethod("pointerActionSequence",
+                 &GpuBenchmarking::PointerActionSequence);
 }
 
 void GpuBenchmarking::SetNeedsDisplayOnAllLayers() {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return;
 
   context.compositor()->SetNeedsDisplayOnAllLayers();
 }
 
@@ skipping 459 matching lines @@
       !gpu_channel->Send(new GpuChannelMsg_GetDriverBugWorkArounds(
           &gpu_driver_bug_workarounds))) {
     return;
   }
 
   v8::Local<v8::Value> result;
   if (gin::TryConvertToV8(args->isolate(), gpu_driver_bug_workarounds, &result))
     args->Return(result);
 }
 
+bool GpuBenchmarking::PointerActionSequence(gin::Arguments* args) {
+  GpuBenchmarkingContext context;
+  if (!context.Init(false))
+    return false;
+
+  v8::Local<v8::Function> callback;
+
+  v8::Local<v8::Object> obj;
+  if (!args->GetNext(&obj)) {
+    args->ThrowError();
+    return false;
+  }
+
+  std::unique_ptr<V8ValueConverter> converter =
+      base::WrapUnique(V8ValueConverter::create());
+  v8::Local<v8::Context> v8_context =
+      context.web_frame()->mainWorldScriptContext();
+  std::unique_ptr<base::Value> value = converter->FromV8Value(obj, v8_context);
+
+  // Get all the pointer actions from the user input and wrap them into a
+  // SyntheticPointerActionListParams object.
+  ActionsRunner actions_runner(value.get());
+  if (!actions_runner.ParseSources())
+    return false;
+
+  std::unique_ptr<SyntheticPointerActionListParams> gesture_params =
+      actions_runner.gesture_params();
+
+  if (!GetOptionalArg(args, &callback)) {
+    return false;
+  }
+
+  // At the end, we will send a 'FINISH' action and need a callback.
+  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),
+      base::Bind(&OnSyntheticGestureCompleted,
+                 base::RetainedRef(callback_and_context)));
+  return true;
+}
+
 }  // namespace content