input: Change how synthesized events are dispatched in telemetry tests.

content/browser/renderer_host/input/synthetic_gesture_controller.cc

 // Copyright 2013 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/renderer_host/input/synthetic_gesture_controller.h"
 
 #include <utility>
 
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input_messages.h"
 #include "content/public/browser/render_widget_host.h"
 
 namespace content {
 
 SyntheticGestureController::SyntheticGestureController(
-    std::unique_ptr<SyntheticGestureTarget> gesture_target)
-    : gesture_target_(std::move(gesture_target)) {}
+    std::unique_ptr<SyntheticGestureTarget> gesture_target,
+    BeginFrameRequestCallback begin_frame_callback)
+    : gesture_target_(std::move(gesture_target)),
+      begin_frame_callback_(std::move(begin_frame_callback)),
+      weak_ptr_factory_(this) {}
 
 SyntheticGestureController::~SyntheticGestureController() {}
 
 void SyntheticGestureController::QueueSyntheticGesture(
     std::unique_ptr<SyntheticGesture> synthetic_gesture,
     const OnGestureCompleteCallback& completion_callback) {
   DCHECK(synthetic_gesture);
 
   bool was_empty = pending_gesture_queue_.IsEmpty();
 
   pending_gesture_queue_.Push(std::move(synthetic_gesture),
                               completion_callback);
 
   if (was_empty)
     StartGesture(*pending_gesture_queue_.FrontGesture());
 }
 
-void SyntheticGestureController::Flush(base::TimeTicks timestamp) {
+void SyntheticGestureController::OnBeginFrame() {
+  // TODO(sad): Instead of dispatching the events immediately, dispatch after an
+  // offset.
+  DispatchNextEvent();
+}
+
+bool SyntheticGestureController::DispatchNextEvent(base::TimeTicks timestamp) {
   TRACE_EVENT0("input", "SyntheticGestureController::Flush");
   if (pending_gesture_queue_.IsEmpty())
-    return;
-
-  if (pending_gesture_result_)

[dtapuska, 2017/05/16 14:39:41]

Doesn't removing the pending_gesture_result_ not change the behavior of this
method? Should pending_gesture_result_ be checked in OnBeginFrame() ?

I'm wondering about the case where a gesture has been sent.

[dtapuska, 2017/05/16 14:40:52]

Ugh; no this submitted the wrong comment.  I looked over it more; disregard that
comment by my new one was: Can pending_gesture_result_ be removed?

[sadrul, 2017/05/16 17:35:05]

Yep, done.

-    return;
+    return false;
 
   SyntheticGesture* gesture = pending_gesture_queue_.FrontGesture();

[dtapuska, 2017/05/16 14:39:41]

Do we need this variable on the stack? I feel someone might want to use it after
its storage is removed. Looks to only be used in one spot so we should be able
to just get rid of the variable reference.

[sadrul, 2017/05/16 17:35:05]

Done.

   SyntheticGesture::Result result =
       gesture->ForwardInputEvents(timestamp, gesture_target_.get());
 
   if (result == SyntheticGesture::GESTURE_RUNNING) {
-    gesture_target_->SetNeedsFlush();
-    return;
+    begin_frame_callback_.Run(
+        base::BindOnce(&SyntheticGestureController::OnBeginFrame,
+                       weak_ptr_factory_.GetWeakPtr()));
+    return true;
   }
 
-  // It's possible that all events generated by the gesture have been fully
-  // dispatched at this point, in which case |OnDidFlushInput()| was called
-  // before |pending_gesture_result_| was initialized. Requesting another flush
-  // will trigger the necessary gesture-ending call to |OnDidFlushInput()|.
-  pending_gesture_result_.reset(new SyntheticGesture::Result(result));
-  gesture_target_->SetNeedsFlush();
-}
-
-void SyntheticGestureController::OnDidFlushInput() {
-  if (!pending_gesture_result_)
-    return;
-
-  DCHECK(!pending_gesture_queue_.IsEmpty());
-  auto pending_gesture_result = std::move(pending_gesture_result_);
   StopGesture(*pending_gesture_queue_.FrontGesture(),
-              pending_gesture_queue_.FrontCallback(),
-              *pending_gesture_result);
+              pending_gesture_queue_.FrontCallback(), result);
   pending_gesture_queue_.Pop();
-
-  if (!pending_gesture_queue_.IsEmpty())
-    StartGesture(*pending_gesture_queue_.FrontGesture());
+  if (pending_gesture_queue_.IsEmpty())
+    return false;
+  StartGesture(*pending_gesture_queue_.FrontGesture());
+  return true;
 }
 
 void SyntheticGestureController::StartGesture(const SyntheticGesture& gesture) {
   TRACE_EVENT_ASYNC_BEGIN0("input,benchmark",
                            "SyntheticGestureController::running",
                            &gesture);
-  gesture_target_->SetNeedsFlush();
+  begin_frame_callback_.Run(
+      base::BindOnce(&SyntheticGestureController::OnBeginFrame,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SyntheticGestureController::StopGesture(
     const SyntheticGesture& gesture,
     const OnGestureCompleteCallback& completion_callback,
     SyntheticGesture::Result result) {
   DCHECK_NE(result, SyntheticGesture::GESTURE_RUNNING);
   TRACE_EVENT_ASYNC_END0("input,benchmark",
                          "SyntheticGestureController::running",
                          &gesture);
 
   completion_callback.Run(result);
 }
 
 SyntheticGestureController::GestureAndCallbackQueue::GestureAndCallbackQueue() {
 }
 
 SyntheticGestureController::GestureAndCallbackQueue::
     ~GestureAndCallbackQueue() {
 }
 
 }  // namespace content