Don't send touch move to renderer while scrolling

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_router_client.h"
@@ skipping 65 matching lines @@
     InputRouterClient* client,
     int routing_id)
     : process_(process),
       client_(client),
       routing_id_(routing_id),
       select_range_pending_(false),
       move_caret_pending_(false),
       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);
   DCHECK(client);
 }
 
 ImmediateInputRouter::~ImmediateInputRouter() {
 }
 
 bool ImmediateInputRouter::SendInput(IPC::Message* message) {
@@ skipping 96 matching lines @@
   HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
   gesture_event_filter_->FlingHasBeenHalted();
 
   // Only forward the non-native portions of our event.
   FilterAndSendWebInputEvent(key_event, latency_info, is_shortcut);
 }
 
 void ImmediateInputRouter::SendGestureEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
+  HandleGestureScroll(gesture_event);
   if (!client_->OnSendGestureEvent(gesture_event))
     return;
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 void ImmediateInputRouter::SendTouchEvent(
     const TouchEventWithLatencyInfo& touch_event) {
   // Always queue TouchEvents, even if the client request they be dropped.
   client_->OnSendTouchEvent(touch_event);
   touch_event_queue_->QueueEvent(touch_event);
@@ skipping 33 matching lines @@
 
 void ImmediateInputRouter::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
   if (!client_->OnSendTouchEventImmediately(touch_event))
     return;
   FilterAndSendWebInputEvent(touch_event.event, touch_event.latency, false);
 }
 
 void ImmediateInputRouter::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
+  HandleGestureScroll(gesture_event);
   if (!client_->OnSendGestureEventImmediately(gesture_event))
     return;
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 const NativeWebKeyboardEvent*
     ImmediateInputRouter::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front();
 }
 
 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(
     const GestureEventWithLatencyInfo& touch_event) const {
   return gesture_event_filter_->ShouldForward(touch_event);
 }
 
 bool ImmediateInputRouter::HasQueuedGestureEvents() const {
   return gesture_event_filter_->HasQueuedGestureEvents();
 }
@@ skipping 259 matching lines @@
   client_->OnGestureEventAck(
       gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void ImmediateInputRouter::ProcessTouchAck(InputEventAckState ack_result) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   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