Don't send touch move to renderer while scrolling

content/browser/renderer_host/input/immediate_input_router.cc

Index: content/browser/renderer_host/input/immediate_input_router.cc
diff --git a/content/browser/renderer_host/input/immediate_input_router.cc b/content/browser/renderer_host/input/immediate_input_router.cc
index b2a4e9234a556a86ea5b5af77af75a4eff518800..21b7d9a2e615cdc365a53321b165a0a8134690c3 100644
--- a/content/browser/renderer_host/input/immediate_input_router.cc
+++ b/content/browser/renderer_host/input/immediate_input_router.cc
@@ -83,6 +83,7 @@ ImmediateInputRouter::ImmediateInputRouter(
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       has_touch_handler_(false),
+      no_touch_to_renderer_while_scrolling_(false),
       touch_event_queue_(new TouchEventQueue(this)),
       gesture_event_filter_(new GestureEventFilter(this)) {
   DCHECK(process);
@@ -199,6 +200,7 @@ void ImmediateInputRouter::SendKeyboardEvent(
 
 void ImmediateInputRouter::SendGestureEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
+  HandleGestureScroll(gesture_event);
   if (!client_->OnSendGestureEvent(gesture_event))
     return;
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
@@ -252,6 +254,7 @@ void ImmediateInputRouter::SendTouchEventImmediately(
 
 void ImmediateInputRouter::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
+  HandleGestureScroll(gesture_event);
   if (!client_->OnSendGestureEventImmediately(gesture_event))
     return;
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
@@ -265,11 +268,15 @@ const NativeWebKeyboardEvent*
 }
 
 bool ImmediateInputRouter::ShouldForwardTouchEvent() const {
+  // 1. Scroll update is in progress:
+  // Don't send any touch events to the renderer
+  // 2. Scroll update is not in progress:
   // Always send a touch event if the renderer has a touch-event handler. It is
   // possible that a renderer stops listening to touch-events while there are
   // still events in the touch-queue. In such cases, the new events should still
   // get into the queue.
-  return has_touch_handler_ || !touch_event_queue_->empty();
+  return (has_touch_handler_ || !touch_event_queue_->empty()) &&
+      !no_touch_to_renderer_while_scrolling_;

[Rick Byers, 2013/08/07 14:01:33]

This will queue the event rather than discard it, right?  That's not what you
want.

 }
 
 bool ImmediateInputRouter::ShouldForwardGestureEvent(
@@ -549,4 +556,26 @@ void ImmediateInputRouter::ProcessTouchAck(InputEventAckState ack_result) {
   touch_event_queue_->ProcessTouchAck(ack_result);
 }
 
+void ImmediateInputRouter::HandleGestureScroll(

[Rick Byers, 2013/08/07 14:01:33]

It does seem unfortunate to have the input router have to understand this stuff
here.

Here's another potential idea (which I haven't fully considered the implications
of): what if we give the gesture recognizer the option to consume touch events
before they're sent anywhere (analogous to how web applications can 'capture'
events).  Then the GR can use it's own state to decide that certain touchmove
events should be handled directly by the GR (generating scroll update events)
rather than being sent anywhere else.

I suspect we may want to do something similar for pinch, so I think it makes
sense to let the GR decide when it will swallow events.

On the down side however, that will probably require duplicate code for Aura and
Android (since we don't share a GR).  So maybe filtering downstream of the GR
somewhere is better to keep the platforms consistent.

+    const GestureEventWithLatencyInfo& gesture_event) {
+  if (CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kNoTouchToRendererWhileScrolling) == "1") {

[sadrul, 2013/08/06 19:34:19]

Can you use a static bool here?
  static bool stop_touch_while_scrolling = CommandLine::...() == "1";
  if (!stop_touch_while_scrolling)
    return;
  ....

+    // Once scrolling is started stop forwarding touch events to renderer.
+    if (gesture_event.event.type == WebInputEvent::GestureScrollUpdate &&
+        ShouldForwardTouchEvent() &&
+        !no_touch_to_renderer_while_scrolling_) {

[sadrul, 2013/08/06 19:34:19]

ShouldForwardTouchEvent() already implies !no_touch_to_renderer_while_scrolling_

+      no_touch_to_renderer_while_scrolling_ = true;

[sadrul, 2013/08/06 19:34:19]

What happens to the touch-events that may already be in the queue when this
happens?

+    }
+
+    if (gesture_event.event.type == WebInputEvent::GestureScrollEnd ||
+        gesture_event.event.type == WebInputEvent::GestureFlingStart) {
+      if (no_touch_to_renderer_while_scrolling_) {
+        no_touch_to_renderer_while_scrolling_ = false;
+        if (ShouldForwardTouchEvent())
+          touch_event_queue_->OnGestureScrollEnd();
+      }
+    }
+  }
+}
+
 }  // namespace content