Change the non-blocking event queue to the main thread event queue.

content/renderer/input/main_thread_event_queue.cc

+// Copyright 2016 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/renderer/input/main_thread_event_queue.h"
+
+namespace content {
+
+MainThreadEventQueue::MainThreadEventQueue(int routing_id,
+                                           MainThreadEventQueueClient* client)
+    : routing_id_(routing_id), client_(client) {}
+
+MainThreadEventQueue::~MainThreadEventQueue() {}
+
+bool MainThreadEventQueue::HandleEvent(const blink::WebInputEvent* event,
+                                       const ui::LatencyInfo& latency,
+                                       InputEventAckState ack_result) {
+  DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
+         ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  bool non_blocking = ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
+
+  InputEventDispatchType type = non_blocking
+                                    ? DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN
+                                    : DISPATCH_TYPE_NORMAL_NOTIFY_MAIN;
+  if (event->type == blink::WebInputEvent::MouseWheel) {
+    if (wheel_events_.state() == WebInputEventQueueState::ITEM_PENDING) {
+      wheel_events_.Queue(PendingMouseWheelEvent(
+          *static_cast<const blink::WebMouseWheelEvent*>(event), latency,
+          type));
+    } else {
+      // If there is nothing in the event queue and the event is
+      // blocking we can avoid having the main thread call us
+      // back when it handled the event as an optimization.
+      if (non_blocking) {
+        wheel_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
+        client_->SendEventToMainThread(routing_id_, event, latency, type);
+      } else {
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       DISPATCH_TYPE_NORMAL);
+      }
+    }
+  } else if (blink::WebInputEvent::isTouchEventType(event->type)) {
+
+    if (touch_events_.state() == WebInputEventQueueState::ITEM_PENDING) {
+      touch_events_.Queue(PendingTouchEvent(
+          *static_cast<const blink::WebTouchEvent*>(event), latency, type));
+    } else {
+      // If there is nothing in the event queue and the event is
+      // blocking we can avoid having the main thread call us
+      // back when it handled the event as an optimization.
+      if (non_blocking) {
+        touch_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
+        client_->SendEventToMainThread(routing_id_, event, latency, type);
+      } else {
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       DISPATCH_TYPE_NORMAL);
+      }
+    }
+  } else {
+    client_->SendEventToMainThread(routing_id_, event, latency,
+                                   DISPATCH_TYPE_NORMAL);
+  }
+
+  // send an ack when we are non-blocking.
+  return non_blocking;
+}
+
+void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type) {
+  if (type == blink::WebInputEvent::MouseWheel) {
+    if (!wheel_events_.empty()) {
+      scoped_ptr<PendingMouseWheelEvent> event = wheel_events_.Pop();
+      client_->SendEventToMainThread(routing_id_, &event->event, event->latency,
+                                     event->type);
+    } else {
+      wheel_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
+    }
+  } else if (blink::WebInputEvent::isTouchEventType(type)) {
+    if (!touch_events_.empty()) {
+      scoped_ptr<PendingTouchEvent> event = touch_events_.Pop();
+      client_->SendEventToMainThread(routing_id_, &event->event, event->latency,
+                                     event->type);
+    } else {
+      touch_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
+    }
+  } else {
+    NOTREACHED() << "Invalid passive event type";
+  }
+}
+
+}  // namespace content