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

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 117 matching lines @@
 class MockSyntheticGestureTarget : public SyntheticGestureTarget {
  public:
   MockSyntheticGestureTarget()
       : flush_requested_(false),
         pointer_assumed_stopped_time_ms_(kPointerAssumedStoppedTimeMs) {}
   ~MockSyntheticGestureTarget() override {}
 
   // SyntheticGestureTarget:
   void DispatchInputEventToPlatform(const WebInputEvent& event) override {}
 
-  void SetNeedsFlush() override { flush_requested_ = true; }
-
   SyntheticGestureParams::GestureSourceType
   GetDefaultSyntheticGestureSourceType() const override {
     return SyntheticGestureParams::TOUCH_INPUT;
   }
 
   base::TimeDelta PointerAssumedStoppedTime() const override {
     return base::TimeDelta::FromMilliseconds(pointer_assumed_stopped_time_ms_);
   }
 
   void set_pointer_assumed_stopped_time_ms(int time_ms) {
@@ skipping 514 matching lines @@
 
 class SyntheticGestureControllerTestBase {
  public:
   SyntheticGestureControllerTestBase() {}
   ~SyntheticGestureControllerTestBase() {}
 
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
     target_ = new MockGestureTarget();
-    controller_.reset(new SyntheticGestureController(
-        std::unique_ptr<SyntheticGestureTarget>(target_)));
+    controller_ = base::MakeUnique<SyntheticGestureController>(
+        std::unique_ptr<SyntheticGestureTarget>(target_),
+        base::Bind([](base::OnceClosure callback) {}));
   }
 
   void QueueSyntheticGesture(std::unique_ptr<SyntheticGesture> gesture) {
     controller_->QueueSyntheticGesture(
         std::move(gesture),
         base::Bind(
             &SyntheticGestureControllerTestBase::OnSyntheticGestureCompleted,
             base::Unretained(this)));
   }
 
   void FlushInputUntilComplete() {
-    while (target_->flush_requested()) {
-      while (target_->flush_requested()) {
-        target_->ClearFlushRequest();
-        time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
-        controller_->Flush(time_);
-      }
-      controller_->OnDidFlushInput();
-    }
+    do
+      time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
+    while (controller_->DispatchNextEvent(time_));
   }
 
   void OnSyntheticGestureCompleted(SyntheticGesture::Result result) {
     DCHECK_NE(result, SyntheticGesture::GESTURE_RUNNING);
     if (result == SyntheticGesture::GESTURE_FINISHED)
       num_success_++;
     else
       num_failure_++;
   }
 
@@ skipping 124 matching lines @@
 
   bool finished_1, finished_2;
   std::unique_ptr<MockSyntheticGesture> gesture_1(
       new MockSyntheticGesture(&finished_1, 2));
   std::unique_ptr<MockSyntheticGesture> gesture_2(
       new MockSyntheticGesture(&finished_2, 4));
 
   QueueSyntheticGesture(std::move(gesture_1));
   QueueSyntheticGesture(std::move(gesture_2));
 
-  while (target_->flush_requested()) {
-    target_->ClearFlushRequest();
+  do {
     time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
-    controller_->Flush(time_);
-  }
-  EXPECT_EQ(0, num_success_);
-  controller_->OnDidFlushInput();
-  EXPECT_EQ(1, num_success_);
-
-  while (target_->flush_requested()) {
-    target_->ClearFlushRequest();
-    time_ += base::TimeDelta::FromMilliseconds(kFlushInputRateInMs);
-    controller_->Flush(time_);
-  }
-  EXPECT_EQ(1, num_success_);
-  controller_->OnDidFlushInput();
+  } while (controller_->DispatchNextEvent(time_));
   EXPECT_EQ(2, num_success_);
 }
 
 gfx::Vector2d AddTouchSlopToVector(const gfx::Vector2dF& vector,
                                    SyntheticGestureTarget* target) {
   const int kTouchSlop = target->GetTouchSlopInDips();
 
   int x = vector.x();
   if (x > 0)
     x += kTouchSlop;
@@ skipping 896 matching lines @@
   EXPECT_EQ(4, num_success_);
   EXPECT_EQ(0, num_failure_);
   EXPECT_EQ(pointer_mouse_target->num_actions_dispatched(), 4);
   EXPECT_TRUE(
       pointer_mouse_target->SyntheticMouseActionDispatchedCorrectly(param, 1));
 }
 
 }  // namespace
 
 }  // namespace content