Make synthesizeScrollGesture repetable and emit interaction markers

content/browser/devtools/protocol/input_handler.cc

Index: content/browser/devtools/protocol/input_handler.cc
diff --git a/content/browser/devtools/protocol/input_handler.cc b/content/browser/devtools/protocol/input_handler.cc
index fb24b021b3c44b0ca26a3568fbf91c8304c9edbb..abad68bfd7ba51059f573ed082d983f6e1c89b16 100644
--- a/content/browser/devtools/protocol/input_handler.cc
+++ b/content/browser/devtools/protocol/input_handler.cc
@@ -4,8 +4,10 @@
 
 #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"
@@ -346,6 +348,25 @@ Response InputHandler::SynthesizeScrollGesture(
     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");
 
@@ -378,12 +399,59 @@ Response InputHandler::SynthesizeScrollGesture(
     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",

[pfeldman, 2015/08/17 17:45:52]

This is weird, does it really rely on those? Can we remove the dependency?

[alex clarke (OOO till 29th), 2015/08/18 09:39:07]

Unfortunately yes.  Telemetry looks for events between interaction markers and
that's not an easy thing to change.   We could potentially move there these are
emitted (e.g. perhaps to the synthetic gesture code), although we'd need some
way of telling that code the |interaction_marker_name|.

I've added a TODO.

[Sami, 2015/08/18 09:59:12]

Right, telemetry needs these markers to find where in the timeline the
interesting interactions happened. Previously these were emitted by the JS in
the renderer, but since we're doing scrolling in the browser now we also need to
emit the records there to ensure that they fully enclose the individual scroll
events and rendered frames.

Like Alex also said, the other way I could imagine this being done would be for
the synthetic gesture controller to emit these events. It'd be a little
inconvenient for some of telemetry's actions which want to perform multiple
gestures inside a single interaction record. Having the trace event here might
be the best we can do for now.

[pfeldman, 2015/08/18 17:58:15]

Could we at least use a different category for this? This is clearly not
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 {
+    SendSynthesizeScrollGestureResponse(command_id, result);
+  }
 }
 
 Response InputHandler::SynthesizeTapGesture(