input: Fix running the completion callback for telemetry gesture.

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 642 matching lines @@
     }
     return testing::AssertionSuccess();
   }
 
  private:
   gfx::PointF position_;
   int clickCount_;
   WebMouseEvent::Button button_;
 };
 
+class DummySyntheticGestureControllerDelegate
+    : public SyntheticGestureController::Delegate {
+ public:
+  DummySyntheticGestureControllerDelegate() {}
+  ~DummySyntheticGestureControllerDelegate() override {}
+
+ private:
+  // SyntheticGestureController::Delegate:
+  void RequestBeginFrameForSynthesizedInput(
+      base::OnceClosure callback) override {}
+  bool HasGestureStopped() override { return true; }
+
+  DISALLOW_COPY_AND_ASSIGN(DummySyntheticGestureControllerDelegate);
+};
+
 class SyntheticGestureControllerTestBase {
  public:
   SyntheticGestureControllerTestBase() {}
   ~SyntheticGestureControllerTestBase() {}
 
  protected:
   template<typename MockGestureTarget>
   void CreateControllerAndTarget() {
     target_ = new MockGestureTarget();
     controller_ = base::MakeUnique<SyntheticGestureController>(
-        std::unique_ptr<SyntheticGestureTarget>(target_),
-        base::Bind([](base::OnceClosure callback) {}));
+        &delegate_, std::unique_ptr<SyntheticGestureTarget>(target_));
   }
 
   void QueueSyntheticGesture(std::unique_ptr<SyntheticGesture> gesture) {
     controller_->QueueSyntheticGesture(
         std::move(gesture),
         base::Bind(
             &SyntheticGestureControllerTestBase::OnSyntheticGestureCompleted,
             base::Unretained(this)));
   }
 
   void FlushInputUntilComplete() {
     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_++;
   }
 
   base::TimeDelta GetTotalTime() const { return time_ - start_time_; }
 
   MockSyntheticGestureTarget* target_;
+  DummySyntheticGestureControllerDelegate delegate_;
   std::unique_ptr<SyntheticGestureController> controller_;
   base::TimeTicks start_time_;
   base::TimeTicks time_;
   int num_success_;
   int num_failure_;
 };
 
 class SyntheticGestureControllerTest
     : public SyntheticGestureControllerTestBase,
       public testing::Test {
@@ skipping 1030 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