Ensure acks are sent for all blocking events.

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)
@@ skipping 80 matching lines @@
     }
   } else {
     client_->SendEventToMainThread(routing_id_, event, latency,
                                    original_dispatch_type);
   }
 
   // send an ack when we are non-blocking.
   return non_blocking;
 }
 
-void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type) {
+void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
+                                        InputEventAckState ack_result) {
   if (type == blink::WebInputEvent::MouseWheel) {
+    if (in_flight_wheel_event_) {
+      // Send acks for blocking wheel events.
+      for (const auto id : in_flight_wheel_event_->eventsToAck)

[tdresser, 2016/06/28 14:04:49]

eventsToAck is just a list of zeroes, which is pretty confusing?

Maybe just loop on the length, to make it clear that you're ignoring the id?

[dtapuska, 2016/06/28 17:30:21]

Changed to be a dcheck.

+        client_->SendInputEventAck(routing_id_, type, ack_result, id);
+    }
+
     if (!wheel_events_.empty()) {
-      std::unique_ptr<PendingMouseWheelEvent> event = wheel_events_.Pop();
-      client_->SendEventToMainThread(routing_id_, &event->event, event->latency,
-                                     event->type);
+      in_flight_wheel_event_ = wheel_events_.Pop();
+      client_->SendEventToMainThread(
+          routing_id_, &in_flight_wheel_event_->event,
+          in_flight_wheel_event_->latency, in_flight_wheel_event_->type);
     } else {
+      in_flight_wheel_event_.reset();
       wheel_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
     }
   } else if (blink::WebInputEvent::isTouchEventType(type)) {
+    if (in_flight_touch_event_) {
+      // Send acks for blocking touch events.
+      for (const auto id : in_flight_touch_event_->eventsToAck)
+        client_->SendInputEventAck(routing_id_, type, ack_result, id);
+    }
+
     if (!touch_events_.empty()) {
-      std::unique_ptr<PendingTouchEvent> event = touch_events_.Pop();
-      client_->SendEventToMainThread(routing_id_, &event->event, event->latency,
-                                     event->type);
+      in_flight_touch_event_ = touch_events_.Pop();
+      client_->SendEventToMainThread(
+          routing_id_, &in_flight_touch_event_->event,
+          in_flight_touch_event_->latency, in_flight_touch_event_->type);
     } else {
+      in_flight_touch_event_.reset();
       touch_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
     }
   } else {
     NOTREACHED() << "Invalid passive event type";
   }
 }
 
 }  // namespace content