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

A problem with the design in that blocking touch events could get
ahead of the non-blocking events was revealed in discussions. Change
the queue so that it processes all events going to the main thread.
It may elect to put blocking events in queues that it maintains so that
events are not re-ordered when dispatched to the main thread.

Force the ack behavior in the renderer to match the disposition
of the event. The benefit of this is uncancelable touch events
now can be coalesced if the main thread is behind.

BUG=489802

Review URL: https://codereview.chromium.org/1780953003

Cr-Commit-Position: refs/heads/master@{#381821}

13 files changed, 409 insertions, 226 deletions

diff --git a/content/renderer/input/input_event_filter.cc b/content/renderer/input/input_event_filter.cc
index eede217..543e62a 100644
--- a/content/renderer/input/input_event_filter.cc
+++ b/content/renderer/input/input_event_filter.cc
@@ -61,7 +61,7 @@ void InputEventFilter::SetBoundHandler(const Handler& handler) {
 void InputEventFilter::DidAddInputHandler(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
-  route_queues_[routing_id].reset(new NonBlockingEventQueue(routing_id, this));
+  route_queues_[routing_id].reset(new MainThreadEventQueue(routing_id, this));
 }
 
 void InputEventFilter::DidRemoveInputHandler(int routing_id) {
@@ -85,7 +85,7 @@ void InputEventFilter::DidStopFlinging(int routing_id) {
   SendMessage(make_scoped_ptr(new InputHostMsg_DidStopFlinging(routing_id)));
 }
 
-void InputEventFilter::NonBlockingInputEventHandled(
+void InputEventFilter::NotifyInputEventHandled(
     int routing_id,
     blink::WebInputEvent::Type type) {
   DCHECK(target_task_runner_->BelongsToCurrentThread());
@@ -163,9 +163,10 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
   ui::LatencyInfo latency_info = base::get<1>(params);
   InputEventDispatchType dispatch_type = base::get<2>(params);
   DCHECK(event);
-  DCHECK_EQ(DISPATCH_TYPE_NORMAL, dispatch_type);
+  DCHECK(dispatch_type == DISPATCH_TYPE_BLOCKING ||
+         dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
 
-  bool send_ack = WebInputEventTraits::WillReceiveAckFromRenderer(*event);
+  bool send_ack = dispatch_type == DISPATCH_TYPE_BLOCKING;
 
   // Intercept |DidOverscroll| notifications, bundling any triggered overscroll
   // response with the input event ack.
@@ -176,21 +177,13 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
 
   InputEventAckState ack_state = handler_.Run(routing_id, event, &latency_info);
 
-  if (ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING) {
+  if (ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
+      ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
     DCHECK(!overscroll_params);
     RouteQueueMap::iterator iter = route_queues_.find(routing_id);
     if (iter != route_queues_.end())
-      iter->second->HandleEvent(event, latency_info);
-  } else if (ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
-    DCHECK(!overscroll_params);
-    TRACE_EVENT_INSTANT0(
-        "input", "InputEventFilter::ForwardToHandler::ForwardToMainListener",
-        TRACE_EVENT_SCOPE_THREAD);
-    IPC::Message new_msg =
-        InputMsg_HandleInputEvent(routing_id, event, latency_info,
-                                  InputEventDispatchType::DISPATCH_TYPE_NORMAL);
-    main_task_runner_->PostTask(FROM_HERE, base::Bind(main_listener_, new_msg));
-    send_ack = false;
+      send_ack &= iter->second->HandleEvent(event, latency_info, dispatch_type,
+                                            ack_state);
   }
 
   if (!send_ack)
@@ -220,14 +213,16 @@ void InputEventFilter::SendMessageOnIOThread(scoped_ptr<IPC::Message> message) {
   sender_->Send(message.release());
 }
 
-void InputEventFilter::SendNonBlockingEvent(int routing_id,
-                                            const blink::WebInputEvent* event,
-                                            const ui::LatencyInfo& latency) {
-  TRACE_EVENT_INSTANT0("input", "InputEventFilter::SendNonBlockingEvent",
-                       TRACE_EVENT_SCOPE_THREAD);
-  IPC::Message new_msg = InputMsg_HandleInputEvent(
-      routing_id, event, latency,
-      InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING);
+void InputEventFilter::SendEventToMainThread(
+    int routing_id,
+    const blink::WebInputEvent* event,
+    const ui::LatencyInfo& latency_info,
+    InputEventDispatchType dispatch_type) {
+  TRACE_EVENT_INSTANT0(
+      "input", "InputEventFilter::ForwardToHandler::SendEventToMainThread",
+      TRACE_EVENT_SCOPE_THREAD);
+  IPC::Message new_msg =
+      InputMsg_HandleInputEvent(routing_id, event, latency_info, dispatch_type);
   main_task_runner_->PostTask(FROM_HERE, base::Bind(main_listener_, new_msg));
 }
 
diff --git a/content/renderer/input/input_event_filter.h b/content/renderer/input/input_event_filter.h
index b1e888d..ed93fa4 100644
--- a/content/renderer/input/input_event_filter.h
+++ b/content/renderer/input/input_event_filter.h
@@ -14,7 +14,7 @@
 #include "content/common/content_export.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/renderer/input/input_handler_manager_client.h"
-#include "content/renderer/input/non_blocking_event_queue.h"
+#include "content/renderer/input/main_thread_event_queue.h"
 #include "ipc/message_filter.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
@@ -43,7 +43,7 @@ namespace content {
 
 class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
                                         public IPC::MessageFilter,
-                                        public NonBlockingEventQueueClient {
+                                        public MainThreadEventQueueClient {
  public:
   InputEventFilter(
       const base::Callback<void(const IPC::Message&)>& main_listener,
@@ -66,8 +66,8 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
   void DidOverscroll(int routing_id,
                      const DidOverscrollParams& params) override;
   void DidStopFlinging(int routing_id) override;
-  void NonBlockingInputEventHandled(int routing_id,
-                                    blink::WebInputEvent::Type type) override;
+  void NotifyInputEventHandled(int routing_id,
+                               blink::WebInputEvent::Type type) override;
 
   // IPC::MessageFilter methods:
   void OnFilterAdded(IPC::Sender* sender) override;
@@ -75,10 +75,11 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
   void OnChannelClosing() override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
-  // NonBlockingEventQueueClient methods:
-  void SendNonBlockingEvent(int routing_id,
-                            const blink::WebInputEvent* event,
-                            const ui::LatencyInfo& latency) override;
+  // MainThreadEventQueueClient methods:
+  void SendEventToMainThread(int routing_id,
+                             const blink::WebInputEvent* event,
+                             const ui::LatencyInfo& latency,
+                             InputEventDispatchType dispatch_type) override;
 
  private:
   ~InputEventFilter() override;
@@ -105,7 +106,7 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
   std::set<int> routes_;
 
   using RouteQueueMap =
-      std::unordered_map<int, scoped_ptr<NonBlockingEventQueue>>;
+      std::unordered_map<int, scoped_ptr<MainThreadEventQueue>>;
   RouteQueueMap route_queues_;
 
   // Used to intercept overscroll notifications while an event is being
diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc
index 4520228..c20bd9c 100644
--- a/content/renderer/input/input_event_filter_unittest.cc
+++ b/content/renderer/input/input_event_filter_unittest.cc
@@ -59,9 +59,7 @@ class InputEventRecorder {
                                       const WebInputEvent* event,
                                       ui::LatencyInfo* latency_info) {
     DCHECK_EQ(kTestRoutingID, routing_id);
-
     records_.push_back(Record(event));
-
     if (handle_events_) {
       return INPUT_EVENT_ACK_STATE_CONSUMED;
     } else if (send_to_widget_) {
@@ -113,9 +111,8 @@ class IPCMessageRecorder : public IPC::Listener {
 
 void AddMessagesToFilter(IPC::MessageFilter* message_filter,
                          const std::vector<IPC::Message>& events) {
-  for (size_t i = 0; i < events.size(); ++i) {
+  for (size_t i = 0; i < events.size(); ++i)
     message_filter->OnMessageReceived(events[i]);
-  }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
@@ -128,7 +125,9 @@ void AddEventsToFilter(IPC::MessageFilter* message_filter,
   for (size_t i = 0; i < count; ++i) {
     messages.push_back(InputMsg_HandleInputEvent(
         kTestRoutingID, &events[i], ui::LatencyInfo(),
-        InputEventDispatchType::DISPATCH_TYPE_NORMAL));
+        WebInputEventTraits::ShouldBlockEventStream(events[i])
+            ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
+            : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
   }
 
   AddMessagesToFilter(message_filter, messages);
@@ -264,9 +263,11 @@ TEST_F(InputEventFilterTest, PreserveRelativeOrder) {
       SyntheticWebMouseEventBuilder::Build(WebMouseEvent::MouseUp);
 
   std::vector<IPC::Message> messages;
-  messages.push_back(
-      InputMsg_HandleInputEvent(kTestRoutingID, &mouse_down, ui::LatencyInfo(),
-                                InputEventDispatchType::DISPATCH_TYPE_NORMAL));
+  messages.push_back(InputMsg_HandleInputEvent(
+      kTestRoutingID, &mouse_down, ui::LatencyInfo(),
+      WebInputEventTraits::ShouldBlockEventStream(mouse_down)
+          ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
+          : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
   // Control where input events are delivered.
   messages.push_back(InputMsg_MouseCaptureLost(kTestRoutingID));
   messages.push_back(InputMsg_SetFocus(kTestRoutingID, true));
@@ -292,9 +293,11 @@ TEST_F(InputEventFilterTest, PreserveRelativeOrder) {
                                          gfx::Point(), gfx::Point()));
   messages.push_back(InputMsg_MoveCaret(kTestRoutingID, gfx::Point()));
 
-  messages.push_back(
-      InputMsg_HandleInputEvent(kTestRoutingID, &mouse_up, ui::LatencyInfo(),
-                                InputEventDispatchType::DISPATCH_TYPE_NORMAL));
+  messages.push_back(InputMsg_HandleInputEvent(
+      kTestRoutingID, &mouse_up, ui::LatencyInfo(),
+      WebInputEventTraits::ShouldBlockEventStream(mouse_up)
+          ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
+          : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING));
   AddMessagesToFilter(filter_.get(), messages);
 
   // We should have sent all messages back to the main thread and preserved
@@ -325,22 +328,19 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
   EXPECT_EQ(1u, message_recorder_.message_count());
 
   // Second event was queued; ack the first.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(4u, ipc_sink_.message_count());
   EXPECT_EQ(2u, message_recorder_.message_count());
 
   // Third event won't be coalesced into the second because modifiers are
   // different.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // The last events will be coalesced.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
@@ -356,7 +356,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 
@@ -374,7 +374,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
     EXPECT_EQ(kEvents[2].size, event->size);
     EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX);
     EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 }
@@ -402,22 +402,19 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
   EXPECT_EQ(1u, message_recorder_.message_count());
 
   // Second event was queued; ack the first.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchStart);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart);
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(4u, ipc_sink_.message_count());
   EXPECT_EQ(2u, message_recorder_.message_count());
 
   // Third event won't be coalesced into the second because modifiers are
   // different.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchMove);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // The last events will be coalesced.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchMove);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
@@ -433,7 +430,7 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 
@@ -452,7 +449,83 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
     EXPECT_EQ(1u, kEvents[3].touchesLength);
     EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x);
     EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+}
+
+TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) {
+  SyntheticWebTouchEvent kEvents[2];
+  kEvents[0].PressPoint(10, 10);
+  kEvents[1].PressPoint(10, 10);
+  kEvents[1].ReleasePoint(0);
+  SyntheticWebTouchEvent kBlockingEvents[1];
+  kBlockingEvents[0].PressPoint(10, 10);
+
+  filter_->DidAddInputHandler(kTestRoutingID);
+  event_recorder_.set_send_to_widget(true);
+  event_recorder_.set_passive(true);
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
+  EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count());
+
+  event_recorder_.set_passive(false);
+  AddEventsToFilter(filter_.get(), kBlockingEvents, arraysize(kBlockingEvents));
+  EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents),
+            event_recorder_.record_count());
+  ASSERT_EQ(3u, event_recorder_.record_count());
+
+  {
+    // First event is sent right away.
+    EXPECT_EQ(1u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(0);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kEvents[0].size, event->size);
+    EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+
+  {
+    // Second event was queued; ack the first.
+    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart);
+    base::MessageLoop::current()->RunUntilIdle();
+    EXPECT_EQ(2u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(1);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kEvents[1].size, event->size);
+    EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+
+  {
+    // Third event should be put in the queue.
+    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd);
+    base::MessageLoop::current()->RunUntilIdle();
+    EXPECT_EQ(3u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(2);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kBlockingEvents[0].size, event->size);
+    EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 }
diff --git a/content/renderer/input/input_handler_manager.cc b/content/renderer/input/input_handler_manager.cc
index b249a64..092e428 100644
--- a/content/renderer/input/input_handler_manager.cc
+++ b/content/renderer/input/input_handler_manager.cc
@@ -181,17 +181,17 @@ void InputHandlerManager::ObserveGestureEventAndResultOnCompositorThread(
       gesture_event, scroll_result);
 }
 
-void InputHandlerManager::NonBlockingInputEventHandledOnMainThread(
+void InputHandlerManager::NotifyInputEventHandledOnMainThread(
     int routing_id,
     blink::WebInputEvent::Type type) {
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
-          &InputHandlerManager::NonBlockingInputEventHandledOnCompositorThread,
+          &InputHandlerManager::NotifyInputEventHandledOnCompositorThread,
           base::Unretained(this), routing_id, type));
 }
 
-void InputHandlerManager::NonBlockingInputEventHandledOnCompositorThread(
+void InputHandlerManager::NotifyInputEventHandledOnCompositorThread(
     int routing_id,
     blink::WebInputEvent::Type handled_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ -199,7 +199,7 @@ void InputHandlerManager::NonBlockingInputEventHandledOnCompositorThread(
   if (it == input_handlers_.end())
     return;
 
-  client_->NonBlockingInputEventHandled(routing_id, handled_type);
+  client_->NotifyInputEventHandled(routing_id, handled_type);
 }
 
 InputEventAckState InputHandlerManager::HandleInputEvent(
diff --git a/content/renderer/input/input_handler_manager.h b/content/renderer/input/input_handler_manager.h
index b5311b7..948759c 100644
--- a/content/renderer/input/input_handler_manager.h
+++ b/content/renderer/input/input_handler_manager.h
@@ -69,8 +69,8 @@ class CONTENT_EXPORT InputHandlerManager {
       const blink::WebGestureEvent& gesture_event,
       const cc::InputHandlerScrollResult& scroll_result);
 
-  void NonBlockingInputEventHandledOnMainThread(int routing_id,
-                                                blink::WebInputEvent::Type);
+  void NotifyInputEventHandledOnMainThread(int routing_id,
+                                           blink::WebInputEvent::Type);
 
   // Callback only from the compositor's thread.
   void RemoveInputHandler(int routing_id);
@@ -110,9 +110,8 @@ class CONTENT_EXPORT InputHandlerManager {
       const blink::WebGestureEvent& gesture_event,
       const cc::InputHandlerScrollResult& scroll_result);
 
-  void NonBlockingInputEventHandledOnCompositorThread(
-      int routing_id,
-      blink::WebInputEvent::Type);
+  void NotifyInputEventHandledOnCompositorThread(int routing_id,
+                                                 blink::WebInputEvent::Type);
 
   typedef base::ScopedPtrHashMap<int,  // routing_id
                                  scoped_ptr<InputHandlerWrapper>>
diff --git a/content/renderer/input/input_handler_manager_client.h b/content/renderer/input/input_handler_manager_client.h
index 71dc3e9..7400afe 100644
--- a/content/renderer/input/input_handler_manager_client.h
+++ b/content/renderer/input/input_handler_manager_client.h
@@ -49,9 +49,8 @@ class CONTENT_EXPORT InputHandlerManagerClient {
   virtual void DidOverscroll(int routing_id,
                              const DidOverscrollParams& params) = 0;
   virtual void DidStopFlinging(int routing_id) = 0;
-  virtual void NonBlockingInputEventHandled(
-      int routing_id,
-      blink::WebInputEvent::Type type) = 0;
+  virtual void NotifyInputEventHandled(int routing_id,
+                                       blink::WebInputEvent::Type type) = 0;
 
  protected:
   InputHandlerManagerClient() {}
diff --git a/content/renderer/input/main_thread_event_queue.cc b/content/renderer/input/main_thread_event_queue.cc
new file mode 100644
index 0000000..d57e69c
--- /dev/null
+++ b/content/renderer/input/main_thread_event_queue.cc
@@ -0,0 +1,99 @@
+// 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,
+    InputEventDispatchType original_dispatch_type,
+    InputEventAckState ack_result) {
+  DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
+         original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
+  DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
+         ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+
+  bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
+                      ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
+
+  InputEventDispatchType dispatch_type =
+      non_blocking ? DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN
+                   : DISPATCH_TYPE_BLOCKING_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,
+          dispatch_type));
+    } else {
+      if (non_blocking) {
+        wheel_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       dispatch_type);
+      } else {
+        // If there is nothing in the event queue and the event is
+        // blocking pass the |original_dispatch_type| to avoid
+        // having the main thread call us back as an optimization.
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       original_dispatch_type);
+      }
+    }
+  } 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, dispatch_type));
+    } else {
+      if (non_blocking) {
+        touch_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       dispatch_type);
+      } else {
+        // If there is nothing in the event queue and the event is
+        // blocking pass the |original_dispatch_type| to avoid
+        // having the main thread call us back as an optimization.
+        client_->SendEventToMainThread(routing_id_, event, latency,
+                                       original_dispatch_type);
+      }
+    }
+  } 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) {
+  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
diff --git a/content/renderer/input/main_thread_event_queue.h b/content/renderer/input/main_thread_event_queue.h
new file mode 100644
index 0000000..0eb2d14
--- /dev/null
+++ b/content/renderer/input/main_thread_event_queue.h
@@ -0,0 +1,121 @@
+// 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.
+
+#ifndef CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
+#define CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
+
+#include <deque>
+#include "content/common/content_export.h"
+#include "content/common/input/event_with_latency_info.h"
+#include "content/common/input/input_event_ack_state.h"
+#include "content/common/input/input_event_dispatch_type.h"
+#include "content/common/input/web_input_event_queue.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/latency_info.h"
+
+namespace content {
+
+template <typename BaseClass, typename BaseType>
+class EventWithDispatchType : public BaseClass {
+ public:
+  EventWithDispatchType(const BaseType& e,
+                        const ui::LatencyInfo& l,
+                        InputEventDispatchType t)
+      : BaseClass(e, l), type(t) {}
+
+  InputEventDispatchType type;
+
+  bool CanCoalesceWith(const EventWithDispatchType& other) const
+      WARN_UNUSED_RESULT {
+    return other.type == type && BaseClass::CanCoalesceWith(other);
+  }
+
+  void CoalesceWith(const EventWithDispatchType& other) {
+    BaseClass::CoalesceWith(other);
+  }
+};
+
+using PendingMouseWheelEvent =
+    EventWithDispatchType<MouseWheelEventWithLatencyInfo,
+                          blink::WebMouseWheelEvent>;
+
+using PendingTouchEvent =
+    EventWithDispatchType<TouchEventWithLatencyInfo, blink::WebTouchEvent>;
+
+class CONTENT_EXPORT MainThreadEventQueueClient {
+ public:
+  // Send an |event| that was previously queued (possibly
+  // coalesced with another event) to the |routing_id|'s
+  // channel. Implementors must implement this callback.
+  virtual void SendEventToMainThread(int routing_id,
+                                     const blink::WebInputEvent* event,
+                                     const ui::LatencyInfo& latency,
+                                     InputEventDispatchType dispatch_type) = 0;
+};
+
+// MainThreadEventQueue implements a series of queues (one touch
+// and one mouse wheel) for events that need to be queued between
+// the compositor and main threads. When an event is sent
+// from the compositor to main it can either be sent directly if no
+// outstanding events of that type are in flight; or it needs to
+// wait in a queue until the main thread has finished processing
+// the in-flight event. This class tracks the state and queues
+// for the event types. Methods on this class should only be called
+// from the compositor thread.
+//
+// Below some example flows are how the code behaves.
+// Legend: B=Browser, C=Compositor, M=Main Thread, NB=Non-blocking
+//         BL=Blocking, PT=Post Task, ACK=Acknowledgement
+//
+// Normal blocking event sent to main thread.
+//   B        C        M
+//   ---(BL)-->
+//            ---(PT)-->
+//   <-------(ACK)------
+//
+// Non-blocking event sent to main thread.
+//   B        C        M
+//   ---(NB)-->
+//            ---(PT)-->
+//            <--(PT)---
+//
+// Non-blocking followed by blocking event sent to main thread.
+//   B        C        M
+//   ---(NB)-->
+//            ---(PT)-->
+//   ---(BL)-->
+//            <--(PT)---     // Notify from NB event.
+//            ---(PT)-->     // Release blocking event.
+//            <--(PT)---     // Notify from BL event.
+//   <-------(ACK)------
+//
+class CONTENT_EXPORT MainThreadEventQueue {
+ public:
+  MainThreadEventQueue(int routing_id, MainThreadEventQueueClient* client);
+  ~MainThreadEventQueue();
+
+  // Called once the compositor has handled |event| and indicated that it is
+  // a non-blocking event to be queued to the main thread.
+  bool HandleEvent(const blink::WebInputEvent* event,
+                   const ui::LatencyInfo& latency,
+                   InputEventDispatchType dispatch_type,
+                   InputEventAckState ack_result);
+
+  // Call once the main thread has handled an outstanding |type| event
+  // in flight.
+  void EventHandled(blink::WebInputEvent::Type type);
+
+ private:
+  friend class MainThreadEventQueueTest;
+  int routing_id_;
+  MainThreadEventQueueClient* client_;
+  WebInputEventQueue<PendingMouseWheelEvent> wheel_events_;
+  WebInputEventQueue<PendingTouchEvent> touch_events_;
+
+  DISALLOW_COPY_AND_ASSIGN(MainThreadEventQueue);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
diff --git a/content/renderer/input/non_blocking_event_queue_unittest.cc b/content/renderer/input/main_thread_event_queue_unittest.cc
index 8953d85..cd67057 100644
--- a/content/renderer/input/non_blocking_event_queue_unittest.cc
+++ b/content/renderer/input/main_thread_event_queue_unittest.cc
@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
-#include "content/renderer/input/non_blocking_event_queue.h"
+#include "content/renderer/input/main_thread_event_queue.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using blink::WebInputEvent;
@@ -25,34 +25,35 @@ namespace {
 const int kTestRoutingID = 13;
 }
 
-class NonBlockingEventQueueTest : public testing::Test,
-                                  public NonBlockingEventQueueClient {
+class MainThreadEventQueueTest : public testing::Test,
+                                 public MainThreadEventQueueClient {
  public:
-  NonBlockingEventQueueTest() : queue_(kTestRoutingID, this) {}
+  MainThreadEventQueueTest() : queue_(kTestRoutingID, this) {}
 
-  void SendNonBlockingEvent(int routing_id,
-                            const blink::WebInputEvent* event,
-                            const ui::LatencyInfo& latency) override {
+  void SendEventToMainThread(int routing_id,
+                             const blink::WebInputEvent* event,
+                             const ui::LatencyInfo& latency,
+                             InputEventDispatchType type) override {
     ASSERT_EQ(kTestRoutingID, routing_id);
     const unsigned char* eventPtr =
         reinterpret_cast<const unsigned char*>(event);
     last_event_.assign(eventPtr, eventPtr + event->size);
   }
 
-  WebInputEventQueue<MouseWheelEventWithLatencyInfo>& wheel_event_queue() {
+  WebInputEventQueue<PendingMouseWheelEvent>& wheel_event_queue() {
     return queue_.wheel_events_;
   }
 
-  WebInputEventQueue<TouchEventWithLatencyInfo>& touch_event_queue() {
+  WebInputEventQueue<PendingTouchEvent>& touch_event_queue() {
     return queue_.touch_events_;
   }
 
  protected:
-  NonBlockingEventQueue queue_;
+  MainThreadEventQueue queue_;
   std::vector<unsigned char> last_event_;
 };
 
-TEST_F(NonBlockingEventQueueTest, NonBlockingWheel) {
+TEST_F(MainThreadEventQueueTest, NonBlockingWheel) {
   WebMouseWheelEvent kEvents[4] = {
       SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false),
@@ -62,9 +63,11 @@ TEST_F(NonBlockingEventQueueTest, NonBlockingWheel) {
 
   ASSERT_EQ(WebInputEventQueueState::ITEM_NOT_PENDING,
             wheel_event_queue().state());
-  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(WebInputEventQueueState::ITEM_PENDING, wheel_event_queue().state());
-  queue_.HandleEvent(&kEvents[1], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(kEvents[0].size, last_event_.size());
   ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[0], kEvents[0].size) == 0);
   queue_.EventHandled(blink::WebInputEvent::MouseWheel);
@@ -76,14 +79,17 @@ TEST_F(NonBlockingEventQueueTest, NonBlockingWheel) {
             wheel_event_queue().state());
 
   // Ensure that coalescing takes place.
-  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo());
-  queue_.HandleEvent(&kEvents[2], ui::LatencyInfo());
-  queue_.HandleEvent(&kEvents[3], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(1u, wheel_event_queue().size());
   ASSERT_EQ(WebInputEventQueueState::ITEM_PENDING, wheel_event_queue().state());
 }
 
-TEST_F(NonBlockingEventQueueTest, NonBlockingTouch) {
+TEST_F(MainThreadEventQueueTest, NonBlockingTouch) {
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
@@ -96,9 +102,11 @@ TEST_F(NonBlockingEventQueueTest, NonBlockingTouch) {
 
   ASSERT_EQ(WebInputEventQueueState::ITEM_NOT_PENDING,
             touch_event_queue().state());
-  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(WebInputEventQueueState::ITEM_PENDING, touch_event_queue().state());
-  queue_.HandleEvent(&kEvents[1], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(kEvents[0].size, last_event_.size());
   ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[0], kEvents[0].size) == 0);
   queue_.EventHandled(blink::WebInputEvent::TouchStart);
@@ -110,9 +118,12 @@ TEST_F(NonBlockingEventQueueTest, NonBlockingTouch) {
             touch_event_queue().state());
 
   // Ensure that coalescing takes place.
-  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo());
-  queue_.HandleEvent(&kEvents[2], ui::LatencyInfo());
-  queue_.HandleEvent(&kEvents[3], ui::LatencyInfo());
+  queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
+                     INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   ASSERT_EQ(1u, touch_event_queue().size());
   ASSERT_EQ(WebInputEventQueueState::ITEM_PENDING, touch_event_queue().state());
 }
diff --git a/content/renderer/input/non_blocking_event_queue.cc b/content/renderer/input/non_blocking_event_queue.cc
deleted file mode 100644
index 4fc5d11..0000000
--- a/content/renderer/input/non_blocking_event_queue.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-// 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/non_blocking_event_queue.h"
-
-namespace content {
-
-NonBlockingEventQueue::NonBlockingEventQueue(
-    int routing_id,
-    NonBlockingEventQueueClient* client)
-    : routing_id_(routing_id), client_(client) {}
-
-NonBlockingEventQueue::~NonBlockingEventQueue() {}
-
-void NonBlockingEventQueue::HandleEvent(const blink::WebInputEvent* event,
-                                        const ui::LatencyInfo& latency) {
-  if (event->type == blink::WebInputEvent::MouseWheel) {
-    if (wheel_events_.state() == WebInputEventQueueState::ITEM_PENDING) {
-      wheel_events_.Queue(MouseWheelEventWithLatencyInfo(
-          *static_cast<const blink::WebMouseWheelEvent*>(event), latency));
-    } else {
-      wheel_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
-      client_->SendNonBlockingEvent(routing_id_, event, latency);
-    }
-  } else if (blink::WebInputEvent::isTouchEventType(event->type)) {
-    if (touch_events_.state() == WebInputEventQueueState::ITEM_PENDING) {
-      touch_events_.Queue(TouchEventWithLatencyInfo(
-          *static_cast<const blink::WebTouchEvent*>(event), latency));
-    } else {
-      touch_events_.set_state(WebInputEventQueueState::ITEM_PENDING);
-      client_->SendNonBlockingEvent(routing_id_, event, latency);
-    }
-  } else {
-    NOTREACHED() << "Invalid passive event type";
-  }
-}
-
-void NonBlockingEventQueue::EventHandled(blink::WebInputEvent::Type type) {
-  if (type == blink::WebInputEvent::MouseWheel) {
-    if (!wheel_events_.empty()) {
-      scoped_ptr<MouseWheelEventWithLatencyInfo> event = wheel_events_.Pop();
-
-      client_->SendNonBlockingEvent(routing_id_, &event->event, event->latency);
-    } else {
-      wheel_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
-    }
-  } else if (blink::WebInputEvent::isTouchEventType(type)) {
-    if (!touch_events_.empty()) {
-      scoped_ptr<TouchEventWithLatencyInfo> event = touch_events_.Pop();
-      client_->SendNonBlockingEvent(routing_id_, &event->event, event->latency);
-    } else {
-      touch_events_.set_state(WebInputEventQueueState::ITEM_NOT_PENDING);
-    }
-  } else {
-    NOTREACHED() << "Invalid passive event type";
-  }
-}
-
-}  // namespace content
diff --git a/content/renderer/input/non_blocking_event_queue.h b/content/renderer/input/non_blocking_event_queue.h
deleted file mode 100644
index 14b99fd..0000000
--- a/content/renderer/input/non_blocking_event_queue.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// 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.
-
-#ifndef CONTENT_RENDERER_INPUT_NON_BLOCKING_EVENT_QUEUE_H_
-#define CONTENT_RENDERER_INPUT_NON_BLOCKING_EVENT_QUEUE_H_
-
-#include <deque>
-#include "content/common/content_export.h"
-#include "content/common/input/event_with_latency_info.h"
-#include "content/common/input/web_input_event_queue.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
-#include "ui/events/latency_info.h"
-
-namespace content {
-
-class CONTENT_EXPORT NonBlockingEventQueueClient {
- public:
-  // Send an |event| that was previously queued (possibly
-  // coalesced with another event) to the |routing_id|'s
-  // channel. Implementors must implement this callback.
-  virtual void SendNonBlockingEvent(int routing_id,
-                                    const blink::WebInputEvent* event,
-                                    const ui::LatencyInfo& latency) = 0;
-};
-
-// NonBlockingEventQueue implements a series of queues (one touch
-// and one mouse wheel) for events that need to be queued between
-// the compositor and main threads. When a non-blocking event is sent
-// from the compositor to main it can either be sent directly if no
-// outstanding events of that type are in flight; or it needs to
-// wait in a queue until the main thread has finished processing
-// the in-flight event. This class tracks the state and queues
-// for the event types. Methods on this class should only be called
-// from the compositor thread.
-//
-class CONTENT_EXPORT NonBlockingEventQueue {
- public:
-  NonBlockingEventQueue(int routing_id, NonBlockingEventQueueClient* client);
-  ~NonBlockingEventQueue();
-
-  // Called once compositor has handled |event| and indicated that it is
-  // a non-blocking event to be queued to the main thread.
-  void HandleEvent(const blink::WebInputEvent* event,
-                   const ui::LatencyInfo& latency);
-
-  // Call once main thread has handled outstanding |type| event in flight.
-  void EventHandled(blink::WebInputEvent::Type type);
-
- private:
-  friend class NonBlockingEventQueueTest;
-  int routing_id_;
-  NonBlockingEventQueueClient* client_;
-  WebInputEventQueue<MouseWheelEventWithLatencyInfo> wheel_events_;
-  WebInputEventQueue<TouchEventWithLatencyInfo> touch_events_;
-
-  DISALLOW_COPY_AND_ASSIGN(NonBlockingEventQueue);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_RENDERER_INPUT_NON_BLOCKING_EVENT_QUEUE_H_
diff --git a/content/renderer/input/render_widget_input_handler.cc b/content/renderer/input/render_widget_input_handler.cc
index 6a0a652..9073437 100644
--- a/content/renderer/input/render_widget_input_handler.cc
+++ b/content/renderer/input/render_widget_input_handler.cc
@@ -306,6 +306,8 @@ void RenderWidgetInputHandler::HandleInputEvent(
   }
 
   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
@@ -397,14 +399,18 @@ void RenderWidgetInputHandler::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),
@@ -437,7 +443,7 @@ void RenderWidgetInputHandler::HandleInputEvent(
   } 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);
diff --git a/content/renderer/input/render_widget_input_handler_delegate.h b/content/renderer/input/render_widget_input_handler_delegate.h
index 0676b50..9f49294 100644
--- a/content/renderer/input/render_widget_input_handler_delegate.h
+++ b/content/renderer/input/render_widget_input_handler_delegate.h
@@ -65,9 +65,10 @@ class CONTENT_EXPORT RenderWidgetInputHandlerDelegate {
   // Called when an ACK is ready to be sent to the input event provider.
   virtual void OnInputEventAck(scoped_ptr<InputEventAck> input_event_ack) = 0;
 
-  // Called when a non-blocking event (DISPATCH_TYPE_NON_BLOCKING) of
-  // |handled_type| has been processed by the main thread.
-  virtual void NonBlockingInputEventHandled(
+  // Called when an event with a notify dispatch type
+  // (DISPATCH_TYPE_*_NOTIFY_MAIN) of |handled_type| has been processed
+  // by the main thread.
+  virtual void NotifyInputEventHandled(
       blink::WebInputEvent::Type handled_type) = 0;
 
   // Notifies the delegate of the |input_handler| managing it.