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

content/browser/renderer_host/input/input_router_impl.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/input_router_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 346 matching lines @@
   OfferToHandlers(input_event, latency_info);
 }
 
 void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
                                       const ui::LatencyInfo& latency_info) {
   output_stream_validator_.Validate(input_event);
 
   if (OfferToClient(input_event, latency_info))
     return;
 
-  OfferToRenderer(input_event, latency_info);
-
   // Touch events should always indicate in the event whether they are
   // cancelable (respect ACK disposition) or not except touchmove.
   bool needs_synthetic_ack =
-      !WebInputEventTraits::WillReceiveAckFromRenderer(input_event);
+      !WebInputEventTraits::ShouldBlockEventOnRenderer(input_event);

[tdresser, 2016/03/15 13:41:21]

I'd consider having two bools, "should_block" and "needs_synthetic_ack".

This logic (369-375) is a bit confusing, as you convert from whether or not it
blocks to whether the ack is synthetic, back to whether or not it blocks.

[dtapuska, 2016/03/15 19:46:04]

I changed it to should_block... I don't see how two bools would make it less
confusing since needs_synthetic_ack = !should_block.

[tdresser, 2016/03/16 15:34:47]

Acknowledged.

+
+  OfferToRenderer(input_event, latency_info,
+                  needs_synthetic_ack
+                      ? InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING
+                      : InputEventDispatchType::DISPATCH_TYPE_BLOCKING);
 
   if (WebInputEvent::isTouchEventType(input_event.type) &&
       input_event.type != WebInputEvent::TouchMove) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
     DCHECK_EQ(needs_synthetic_ack, !touch.cancelable);
   }
 
   // The synthetic acks are sent immediately.
   if (needs_synthetic_ack) {
     ProcessInputEventAck(
@@ skipping 25 matching lines @@
       consumed = true;
       break;
     default:
       break;
   }
 
   return consumed;
 }
 
 bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
-                                      const ui::LatencyInfo& latency_info) {
+                                      const ui::LatencyInfo& latency_info,
+                                      InputEventDispatchType dispatch_type) {
   // This conversion is temporary. WebInputEvent should be generated
   // directly from ui::Event with the viewport coordinates. See
   // crbug.com/563730.
   scoped_ptr<blink::WebInputEvent> event_in_viewport =
       ui::ScaleWebInputEvent(input_event, device_scale_factor_);
   const WebInputEvent* event_to_send =
       event_in_viewport ? event_in_viewport.get() : &input_event;
 
-  if (Send(new InputMsg_HandleInputEvent(
-          routing_id(), event_to_send, latency_info,
-          InputEventDispatchType::DISPATCH_TYPE_NORMAL))) {
+  if (Send(new InputMsg_HandleInputEvent(routing_id(), event_to_send,
+                                         latency_info, dispatch_type))) {
     // Ack messages for ignored ack event types should never be sent by the
     // renderer. Consequently, such event types should not affect event time
     // or in-flight event count metrics.
-    if (WebInputEventTraits::WillReceiveAckFromRenderer(*event_to_send)) {
+    if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_BLOCKING) {
       input_event_start_time_ = TimeTicks::Now();
       client_->IncrementInFlightEventCount();
     }
     return true;
   }
   return false;
 }
 
 void InputRouterImpl::OnInputEventAck(const InputEventAck& ack) {
   client_->DecrementInFlightEventCount();
@@ skipping 192 matching lines @@
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 void InputRouterImpl::SetFrameTreeNodeId(int frameTreeNodeId) {
   frame_tree_node_id_ = frameTreeNodeId;
 }
 
 }  // namespace content