Make synthesizeScrollGesture repetable and emit interaction markers

content/browser/devtools/protocol/input_handler.cc

 // Copyright 2014 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/browser/devtools/protocol/input_handler.h"
 
+#include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace content {
@@ skipping 320 matching lines @@
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* x_distance,
     const int* y_distance,
     const int* x_overscroll,
     const int* y_overscroll,
     const bool* prevent_fling,
     const int* speed,
     const std::string* gesture_source_type) {
+  return SynthesizeScrollGesture(
+      command_id, x, y, x_distance, y_distance, x_overscroll, y_overscroll,
+      prevent_fling, speed, gesture_source_type, nullptr, nullptr, nullptr);
+}
+
+Response InputHandler::SynthesizeScrollGesture(
+    DevToolsCommandId command_id,
+    int x,
+    int y,
+    const int* x_distance,
+    const int* y_distance,
+    const int* x_overscroll,
+    const int* y_overscroll,
+    const bool* prevent_fling,
+    const int* speed,
+    const std::string* gesture_source_type,
+    const int* repeat_count,
+    const int* repeat_delay_ms,
+    const std::string* interaction_marker_name) {
   if (!host_)
     return Response::ServerError("Could not connect to view");
 
   SyntheticSmoothScrollGestureParams gesture_params;
   const bool kDefaultPreventFling = true;
   const int kDefaultSpeed = 800;
 
   gesture_params.anchor = CssPixelsToPoint(x, y, page_scale_factor_);
   gesture_params.prevent_fling =
       prevent_fling ? *prevent_fling : kDefaultPreventFling;
@@ skipping 12 matching lines @@
                             y_overscroll ? -*y_overscroll : 0,
                             page_scale_factor_));
   }
 
   if (!StringToGestureSourceType(
       gesture_source_type ? *gesture_source_type : kGestureSourceTypeDefault,
       gesture_params.gesture_source_type)) {
     return Response::InvalidParams("gestureSourceType");
   }
 
+  SynthesizeRepeatingScroll(
+      gesture_params, repeat_count ? *repeat_count : 0,
+      base::TimeDelta::FromMilliseconds(repeat_delay_ms ? *repeat_delay_ms
+                                                        : 250),
+      interaction_marker_name ? *interaction_marker_name : "", command_id);
+
+  return Response::OK();
+}
+
+void InputHandler::SynthesizeRepeatingScroll(
+    SyntheticSmoothScrollGestureParams gesture_params,
+    int repeat_count,
+    base::TimeDelta repeat_delay,
+    std::string interaction_marker_name,
+    DevToolsCommandId command_id) {
+  if (!interaction_marker_name.empty()) {
+    // Telemetry expects the interaction markers to be in the blink.console
+    // category.
+    TRACE_EVENT_COPY_ASYNC_BEGIN0("blink.console",
+                                  interaction_marker_name.c_str(), command_id);
+  }
+
   host_->QueueSyntheticGesture(
       SyntheticGesture::Create(gesture_params),
-      base::Bind(&InputHandler::SendSynthesizeScrollGestureResponse,
-                 weak_factory_.GetWeakPtr(), command_id));
+      base::Bind(&InputHandler::OnScrollFinished, weak_factory_.GetWeakPtr(),
+                 gesture_params, repeat_count, repeat_delay,
+                 interaction_marker_name, command_id));
+}
 
-  return Response::OK();
+void InputHandler::OnScrollFinished(
+    SyntheticSmoothScrollGestureParams gesture_params,
+    int repeat_count,
+    base::TimeDelta repeat_delay,
+    std::string interaction_marker_name,
+    DevToolsCommandId command_id,
+    SyntheticGesture::Result result) {
+  if (!interaction_marker_name.empty()) {
+    // Telemetry expects the interaction markers to be in the blink.console
+    // category.
+    TRACE_EVENT_COPY_ASYNC_END0("blink.console",
+                                interaction_marker_name.c_str(), command_id);
+  }
+
+  if (repeat_count > 0) {
+    base::MessageLoop::current()->task_runner()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&InputHandler::SynthesizeRepeatingScroll,
+                   weak_factory_.GetWeakPtr(), gesture_params, repeat_count - 1,
+                   repeat_delay, interaction_marker_name, command_id),
+        repeat_delay);
+  } else {
+    SendSynthesizePinchGestureResponse(command_id, result);

[Sami, 2015/08/17 16:35:48]

Should this be a scroll gesture response instead?

[alex clarke (OOO till 29th), 2015/08/17 16:42:22]

Whoops.  Yes :)

+  }
 }
 
 Response InputHandler::SynthesizeTapGesture(
     DevToolsCommandId command_id,
     int x,
     int y,
     const int* duration,
     const int* tap_count,
     const std::string* gesture_source_type) {
   if (!host_)
@@ skipping 66 matching lines @@
   } else {
     client_->SendError(command_id,
                        Response::InternalError(base::StringPrintf(
                            "Synthetic tap failed, result was %d", result)));
   }
 }
 
 }  // namespace input
 }  // namespace devtools
 }  // namespace content