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

content/renderer/input/render_widget_input_handler.cc

 // Copyright 2015 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/render_widget_input_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 288 matching lines @@
   WebInputEventResult processed = prevent_default
                                       ? WebInputEventResult::HandledSuppressed
                                       : WebInputEventResult::NotHandled;
   if (input_event.type != WebInputEvent::Char || !suppress_next_char_events_) {
     suppress_next_char_events_ = false;
     if (processed == WebInputEventResult::NotHandled && widget_->webwidget())
       processed = widget_->webwidget()->handleInputEvent(input_event);
   }
 
   bool non_blocking =
+      dispatch_type ==
+          InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN ||
       dispatch_type == InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING;
   // TODO(dtapuska): Use the input_event.timeStampSeconds as the start
   // ideally this should be when the event was sent by the compositor to the
   // renderer. crbug.com/565348
   if (input_event.type == WebInputEvent::TouchStart ||
       input_event.type == WebInputEvent::TouchMove ||
       input_event.type == WebInputEvent::TouchEnd) {
     LogPassiveEventListenersUma(
         processed, non_blocking,
         static_cast<const WebTouchEvent&>(input_event).cancelable,
@@ skipping 71 matching lines @@
     total_input_handling_time_this_frame_ += (end_time - start_time);
     rate_limiting_wanted =
         total_input_handling_time_this_frame_.InMicroseconds() >
         kInputHandlingTimeThrottlingThresholdMicroseconds;
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
 
   // Note that we can't use handling_event_type_ here since it will be overriden
   // by reentrant calls for events after the paused one.
-  bool no_ack = ignore_ack_for_mouse_move_from_debugger_ &&
-                input_event.type == WebInputEvent::MouseMove;
-  if (non_blocking) {
+  bool can_send_ack = !(ignore_ack_for_mouse_move_from_debugger_ &&
+                        input_event.type == WebInputEvent::MouseMove);
+  if (dispatch_type == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN ||
+      dispatch_type == DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN) {
     // |non_blocking| means it was ack'd already by the InputHandlerProxy
     // so let the delegate know the event has been handled.
-    delegate_->NonBlockingInputEventHandled(input_event.type);
-  } else if (WebInputEventTraits::WillReceiveAckFromRenderer(input_event) &&
-             !no_ack) {
+    delegate_->NotifyInputEventHandled(input_event.type);
+  }
+
+  if ((dispatch_type == DISPATCH_TYPE_BLOCKING ||
+       dispatch_type == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN) &&
+      can_send_ack) {
     scoped_ptr<InputEventAck> response(new InputEventAck(
         input_event.type, ack_result, swap_latency_info,
         std::move(event_overscroll),
         WebInputEventTraits::GetUniqueTouchEventId(input_event)));
     if (rate_limiting_wanted && frame_pending && !widget_->is_hidden()) {
       // We want to rate limit the input events in this case, so we'll wait for
       // painting to finish before ACKing this message.
       TRACE_EVENT_INSTANT0(
           "renderer",
           "RenderWidgetInputHandler::OnHandleInputEvent ack throttled",
@@ skipping 12 matching lines @@
           "input", "RenderWidgetInputHandler::ThrottledInputEventAck",
           pending_input_event_ack_.get());
       if (widget_->compositor())
         widget_->compositor()->NotifyInputThrottledUntilCommit();
     } else {
       delegate_->OnInputEventAck(std::move(response));
     }
   } else {
     DCHECK(!event_overscroll) << "Unexpected overscroll for un-acked event";
   }
-  if (!no_ack && RenderThreadImpl::current()) {
+  if (can_send_ack && RenderThreadImpl::current()) {
     RenderThreadImpl::current()
         ->GetRendererScheduler()
         ->DidHandleInputEventOnMainThread(input_event);
   }
   if (input_event.type == WebInputEvent::MouseMove)
     ignore_ack_for_mouse_move_from_debugger_ = false;
 
 #if defined(OS_ANDROID)
   // Allow the IME to be shown when the focus changes as a consequence
   // of a processed touch end event.
@@ skipping 75 matching lines @@
   if (pending_input_event_ack_) {
     TRACE_EVENT_ASYNC_END0("input",
                            "RenderWidgetInputHandler::ThrottledInputEventAck",
                            pending_input_event_ack_.get());
     delegate_->OnInputEventAck(std::move(pending_input_event_ack_));
   }
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 }  // namespace content