Make tapDown async.

content/browser/renderer_host/input/immediate_input_router.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/immediate_input_router.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
@@ skipping 525 matching lines @@
   if (!coalesced_mouse_wheel_events_.empty()) {
     MouseWheelEventWithLatencyInfo next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void ImmediateInputRouter::ProcessGestureAck(int type,
                                              InputEventAckState ack_result) {
+  if (GestureEventFilter::IsGestureEventTypeAsync(type))
+    return;

[jdduke (slow), 2013/09/30 15:42:56]

Are we sure that the |ack_handler_| will never be interested in the ack for an
async event type?

I also wonder if we could shift this logic into the GEF... perhaps reverse the
order of the two calls below, so we start with something like

if (gesture_event_filter_->ProcessGestureAck(processed, type)) {
  ack_handler_->OnGestureEventAck(
      gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
}

It needn't be a bool return value, perhaps an enum like 

enum GestureAckResult {
  FORWARD,
  DROP
}

Either way, we'd need to make sure the order of the ack processing (between
filter and client) isn't important here, but it would be nice to have the logic
self-contained in the GEF if possible. 

[tdresser, 2013/09/30 18:05:03]

I believe this is true. Acks for async event types could come back completely
out of order, so depending on them seems dangerous. I think eventually we should
stop the renderer from even firing acks for async events. Can you think of any
instance where we'd want to pay attention to an ack from an async event?
The order of the ack processing does matter, so unfortunately I don't think we
can centralize that logic.

   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
   ack_handler_->OnGestureEventAck(
       gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void ImmediateInputRouter::ProcessTouchAck(
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
 }
 
 void ImmediateInputRouter::HandleGestureScroll(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (!enable_no_touch_to_renderer_while_scrolling_)
     return;
 
   // Once scrolling is started stop forwarding touch move events to renderer.
   if (gesture_event.event.type == WebInputEvent::GestureScrollBegin)
     touch_event_queue_->set_no_touch_move_to_renderer(true);
 
   if (gesture_event.event.type == WebInputEvent::GestureScrollEnd ||
       gesture_event.event.type == WebInputEvent::GestureFlingStart) {
     touch_event_queue_->set_no_touch_move_to_renderer(false);
   }
 }
 
 }  // namespace content