Plumb firing passive event listeners.

content/renderer/input/passive_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/passive_event_queue.h"
+
+namespace content {
+
+PassiveEventQueue::PassiveEventQueue(int routing_id,
+                                     PassiveEventQueueClient* client)
+    : routing_id_(routing_id), client_(client) {}
+
+PassiveEventQueue::~PassiveEventQueue() {}
+
+void PassiveEventQueue::HandleNonBlockingEvent(
+    const blink::WebInputEvent* event,
+    const ui::LatencyInfo& latency) {
+  if (event->type == blink::WebInputEvent::MouseWheel) {
+    if (wheel_events_.state() ==
+        WebInputEventQueue<
+            MouseWheelEventWithLatencyInfo>::State::ITEM_PENDING) {
+      wheel_events_.Queue(MouseWheelEventWithLatencyInfo(

[Rick Byers, 2016/01/26 19:17:21]

I think you'll need to coalesce events somewhere just like the browser-side
touch and mouse event queues do.  We don't want to accrue an arbitrary backlog
of movement events when the main thread is slow.

[Rick Byers, 2016/01/26 19:20:52]

Oh, I see it now in WebInputEventQueue.  That class was so simple I somehow
missed the coalescing :-)

Perhaps it's worth adding a class-level comment about the purpose of
WebInputEventQueue (including that it does event coalescing).

+          *static_cast<const blink::WebMouseWheelEvent*>(event), latency));
+    } else {
+      wheel_events_.set_state(
+          WebInputEventQueue<
+              MouseWheelEventWithLatencyInfo>::State::ITEM_PENDING);
+      client_->SendPassiveEvent(routing_id_, event, latency);
+    }
+  } else if (blink::WebInputEvent::isTouchEventType(event->type)) {
+    if (touch_events_.state() ==
+        WebInputEventQueue<TouchEventWithLatencyInfo>::State::ITEM_PENDING) {
+      touch_events_.Queue(TouchEventWithLatencyInfo(
+          *static_cast<const blink::WebTouchEvent*>(event), latency));
+    } else {
+      touch_events_.set_state(
+          WebInputEventQueue<TouchEventWithLatencyInfo>::State::ITEM_PENDING);
+      client_->SendPassiveEvent(routing_id_, event, latency);
+    }
+  } else {
+    NOTREACHED() << "Invalid passive event type";
+  }
+}
+
+void PassiveEventQueue::EventHandled(blink::WebInputEvent::Type type) {
+  if (type == blink::WebInputEvent::MouseWheel) {
+    if (!wheel_events_.empty()) {
+      scoped_ptr<MouseWheelEventWithLatencyInfo> event = wheel_events_.Deque();
+
+      client_->SendPassiveEvent(routing_id_, &event->event, event->latency);
+    } else {
+      wheel_events_.set_state(
+          WebInputEventQueue<
+              MouseWheelEventWithLatencyInfo>::State::ITEM_NOT_PENDING);
+    }
+  } else if (blink::WebInputEvent::isTouchEventType(type)) {
+    if (!touch_events_.empty()) {
+      scoped_ptr<TouchEventWithLatencyInfo> event = touch_events_.Deque();
+      client_->SendPassiveEvent(routing_id_, &event->event, event->latency);
+    } else {
+      touch_events_.set_state(
+          WebInputEventQueue<
+              TouchEventWithLatencyInfo>::State::ITEM_NOT_PENDING);
+    }
+  } else {
+    NOTREACHED() << "Invalid passive event type";
+  }
+}
+
+}  // namespace content