Re-enable Eager Gesture Recognition on Aura

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 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/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 1995 matching lines @@
 
 void RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnTouchEvent");
   if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
     return;
 
   // Update the touch event first.
   blink::WebTouchPoint* point = UpdateWebTouchEventFromUIEvent(*event,
                                                                 &touch_event_);
 
-  // Forward the touch event only if a touch point was updated, and there's a
-  // touch-event handler in the page, and no other touch-event is in the queue.
-  // It is important to always consume the event if there is a touch-event
-  // handler in the page, or some touch-event is already in the queue, even if
-  // no point has been updated, to make sure that this event does not get
-  // processed by the gesture recognizer before the events in the queue.
-  if (host_->ShouldForwardTouchEvent())
-    event->StopPropagation();
+  // Forward the touch event only if a touch point was updated, and

[jdduke (slow), 2014/11/17 16:57:13]

Would it make any sense to split out the point is null case here?

if (!point) {
  Do whatever.
  return;
}

[tdresser, 2014/11/17 22:00:36]

Done.
Feels about 1% worse this way to me - what do you think?

[jdduke (slow), 2014/11/17 22:23:15]

I was hoping we could get rid of the |DisableSynchronousHandling();| if point is
null, so maybe the old way is better...

+  // there's a touch-event handler in the page, and no other
+  // touch-event is in the queue. It is important to always mark
+  // events as being handled asynchronously if there is a touch-event
+  // handler in the page, or some touch-event is already in the queue,
+  // even if no point has been updated. This ensures that this event
+  // does not get processed by the gesture recognizer before events
+  // currently awaiting dispatch in the touch queue.
+  if (host_->ShouldForwardTouchEvent()) {
+    event->DisableSynchronousHandling();
+    if (point) {
+      host_->ForwardTouchEventWithLatencyInfo(touch_event_, *event->latency());
+    } else {
+      // Fake an ack for the invalid touch event.
+      DCHECK(window_->GetHost());
+      window_->GetHost()->dispatcher()->ProcessedTouchEvent(event, window_,

[jdduke (slow), 2014/11/17 16:57:13]

It seems like this could cause us to get some out-of-order acks if |point| is
null. Is that intentional?

[tdresser, 2014/11/17 22:00:36]

Gah, you're right, that could potentially break things.

I'm having a hard time coming up with any solution to this that isn't
horrendously complicated - for instance, telling the GR "The touch event that
you received most recently should be marked consumed. When it gets to the top of
the queue, just act as though you received an ack indicating that the event was
consumed."

Do you have any thoughts?

[jdduke (slow), 2014/11/17 22:23:15]

Well, ideally this method would be: |OnTouchEvent(const ui::MotionEvent)|, then
we don't have to keep any intermediate state and we can just convert the
MotionEvent to a WebTouchEvent directly.  How difficult would it be to wire that
up?

Short of that, shouldn't these ui::TouchEvents already be validated by the eager
pipeline? So shouldn't we be DCHECK'ing? Or are there cases where
extra/redundant events might be received (like an extra cancel)?

+                                                            ui::ER_HANDLED);
+    }
+  }
 
-  if (point) {
-    if (host_->ShouldForwardTouchEvent())
-      host_->ForwardTouchEventWithLatencyInfo(touch_event_, *event->latency());
+  if (point)
     UpdateWebTouchEventAfterDispatch(&touch_event_, point);
-  }
 }
 
 void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnGestureEvent");
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !pinch_zoom_enabled_) {
     event->SetHandled();
     return;
   }
@@ skipping 511 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content