Revert of Fix unit tests to enable them testing with the rAF aligned touch input.

content/renderer/input/input_event_filter_unittest.cc

Index: content/renderer/input/input_event_filter_unittest.cc
diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc
index fdcce0209266290d2903cfe24d9b2a3d6be9191b..1076f628248a809bdbe34532684e4f99eadedbfe 100644
--- a/content/renderer/input/input_event_filter_unittest.cc
+++ b/content/renderer/input/input_event_filter_unittest.cc
@@ -13,7 +13,6 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
-#include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
@@ -37,17 +36,13 @@
 
 const int kTestRoutingID = 13;
 
-// Simulate a 16ms frame signal.
-const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16);
-
 class InputEventRecorder : public content::InputHandlerManager {
  public:
   InputEventRecorder(InputEventFilter* filter)
       : InputHandlerManager(nullptr, filter, nullptr, nullptr),
         handle_events_(false),
         send_to_widget_(false),
-        passive_(false),
-        needs_main_frame_(false) {}
+        passive_(false) {}
 
   ~InputEventRecorder() override {}
 
@@ -56,9 +51,6 @@
   void set_passive(bool value) { passive_ = value; }
 
   size_t record_count() const { return records_.size(); }
-
-  bool needs_main_frame() const { return needs_main_frame_; }
-  void reset_needs_main_frame() { needs_main_frame_ = false; }
 
   const WebInputEvent* record_at(size_t i) const {
     const Record& record = records_[i];
@@ -92,11 +84,6 @@
     }
   }
 
-  void NeedsMainFrame(int routing_id) override {
-    DCHECK_EQ(kTestRoutingID, routing_id);
-    needs_main_frame_ = true;
-  }
-
  private:
   struct Record {
     Record(const WebInputEvent* event) {
@@ -109,7 +96,6 @@
   bool handle_events_;
   bool send_to_widget_;
   bool passive_;
-  bool needs_main_frame_;
   std::vector<Record> records_;
 };
 
@@ -134,60 +120,47 @@
   std::vector<IPC::Message> messages_;
 };
 
+void AddMessagesToFilter(IPC::MessageFilter* message_filter,
+                         const std::vector<IPC::Message>& events) {
+  for (size_t i = 0; i < events.size(); ++i)
+    message_filter->OnMessageReceived(events[i]);
+
+  base::RunLoop().RunUntilIdle();
+}
+
+template <typename T>
+void AddEventsToFilter(IPC::MessageFilter* message_filter,
+                       const T events[],
+                       size_t count) {
+  std::vector<IPC::Message> messages;
+  for (size_t i = 0; i < count; ++i) {
+    messages.push_back(InputMsg_HandleInputEvent(
+        kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(),
+        ui::LatencyInfo(),
+        ui::WebInputEventTraits::ShouldBlockEventStream(events[i])
+            ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
+            : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
+  }
+
+  AddMessagesToFilter(message_filter, messages);
+}
+
 }  // namespace
 
 class InputEventFilterTest : public testing::Test {
  public:
-  InputEventFilterTest()
-      : main_task_runner_(new base::TestSimpleTaskRunner()) {}
-
   void SetUp() override {
     filter_ = new InputEventFilter(
         base::Bind(base::IgnoreResult(&IPCMessageRecorder::OnMessageReceived),
                    base::Unretained(&message_recorder_)),
-        main_task_runner_, main_task_runner_);
+        base::ThreadTaskRunnerHandle::Get(), message_loop_.task_runner());
     event_recorder_ = base::MakeUnique<InputEventRecorder>(filter_.get());
     filter_->SetInputHandlerManager(event_recorder_.get());
     filter_->OnFilterAdded(&ipc_sink_);
   }
 
-  void AddMessagesToFilter(const std::vector<IPC::Message>& events) {
-    for (size_t i = 0; i < events.size(); ++i)
-      filter_->OnMessageReceived(events[i]);
-
-    // base::RunLoop is the "IO Thread".
-    base::RunLoop().RunUntilIdle();
-
-    while (event_recorder_->needs_main_frame() ||
-           main_task_runner_->HasPendingTask()) {
-      main_task_runner_->RunUntilIdle();
-      frame_time_ += kFrameInterval;
-      event_recorder_->reset_needs_main_frame();
-      filter_->ProcessRafAlignedInput(kTestRoutingID, frame_time_);
-
-      // Run queued io thread tasks.
-      base::RunLoop().RunUntilIdle();
-    }
-  }
-
-  template <typename T>
-  void AddEventsToFilter(const T events[], size_t count) {
-    std::vector<IPC::Message> messages;
-    for (size_t i = 0; i < count; ++i) {
-      messages.push_back(InputMsg_HandleInputEvent(
-          kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(),
-          ui::LatencyInfo(),
-          ui::WebInputEventTraits::ShouldBlockEventStream(events[i])
-              ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
-              : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
-    }
-
-    AddMessagesToFilter(messages);
-  }
-
  protected:
   base::MessageLoop message_loop_;
-  scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
 
   // Used to record IPCs sent by the filter to the RenderWidgetHost.
   IPC::TestSink ipc_sink_;
@@ -199,8 +172,6 @@
 
   // Used to record WebInputEvents delivered to the handler.
   std::unique_ptr<InputEventRecorder> event_recorder_;
-
-  base::TimeTicks frame_time_;
 };
 
 TEST_F(InputEventFilterTest, Basic) {
@@ -210,14 +181,14 @@
     SyntheticWebMouseEventBuilder::Build(WebMouseEvent::MouseMove, 30, 30, 0)
   };
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(0U, ipc_sink_.message_count());
   EXPECT_EQ(0U, event_recorder_->record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   filter_->RegisterRoutingID(kTestRoutingID);
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   ASSERT_EQ(arraysize(kEvents), event_recorder_->record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
@@ -244,7 +215,7 @@
 
   event_recorder_->set_send_to_widget(true);
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(2 * arraysize(kEvents), event_recorder_->record_count());
   EXPECT_EQ(1u, message_recorder_.message_count());
@@ -269,7 +240,7 @@
 
   event_recorder_->set_handle_events(true);
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
@@ -337,7 +308,7 @@
       ui::WebInputEventTraits::ShouldBlockEventStream(mouse_up)
           ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
           : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
-  AddMessagesToFilter(messages);
+  AddMessagesToFilter(filter_.get(), messages);
 
   // We should have sent all messages back to the main thread and preserved
   // their relative order.
@@ -359,7 +330,7 @@
   event_recorder_->set_send_to_widget(true);
   event_recorder_->set_passive(true);
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count());
   ASSERT_EQ(4u, ipc_sink_.message_count());
 
@@ -420,7 +391,7 @@
   event_recorder_->set_send_to_widget(true);
   event_recorder_->set_passive(true);
 
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count());
   ASSERT_EQ(4u, ipc_sink_.message_count());
 
@@ -476,11 +447,11 @@
   filter_->RegisterRoutingID(kTestRoutingID);
   event_recorder_->set_send_to_widget(true);
   event_recorder_->set_passive(true);
-  AddEventsToFilter(kEvents, arraysize(kEvents));
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count());
 
   event_recorder_->set_passive(false);
-  AddEventsToFilter(kBlockingEvents, arraysize(kBlockingEvents));
+  AddEventsToFilter(filter_.get(), kBlockingEvents, arraysize(kBlockingEvents));
   EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents),
             event_recorder_->record_count());
   ASSERT_EQ(3u, event_recorder_->record_count());