Cancel browser process scroll bubbling when new gestures start

content/browser/renderer_host/render_widget_host_input_event_router.cc

 // Copyright 2015 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_input_event_router.h"
 
 #include "base/debug/dump_without_crashing.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
@@ skipping 192 matching lines @@
             FindEventTarget(root_view, original_point, &transformed_point);
 
         // TODO(wjmaclean): Instead of just computing a delta, we should extract
         // the complete transform. We assume it doesn't change for the duration
         // of the touch sequence, though this could be wrong; a better approach
         // might be to always transform each point to the |touch_target_.target|
         // for the duration of the sequence.
         touch_target_.delta = transformed_point - original_point;
         touchscreen_gesture_target_queue_.push_back(touch_target_);
 
-        if (!touch_target_.target)
+        if (!touch_target_.target) {
           return;
+        } else if (touch_target_.target ==
+                   bubbling_gesture_scroll_target_.target) {
+          SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
+                               blink::WebGestureEvent());
+          CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
+        }
       }
+
       ++active_touches_;
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
         touch_target_.target->ProcessTouchEvent(*event, latency);
       }
       break;
     }
     case blink::WebInputEvent::TouchMove:
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
@@ skipping 57 matching lines @@
   if (target_view == bubbling_gesture_scroll_target_.target) {
     bubbling_gesture_scroll_target_.target->ProcessGestureEvent(
         event, ui::LatencyInfo());
     return;
   }
 
   // If target_view has unrelated gesture events in progress, do
   // not proceed. This could cause confusion between independent
   // scrolls.
   if (target_view == touchscreen_gesture_target_.target ||
-      target_view == touchpad_gesture_target_.target)
+      target_view == touchpad_gesture_target_.target ||
+      target_view == touch_target_.target)
     return;
 
   // This accounts for bubbling through nested OOPIFs. A gesture scroll has
   // been bubbled but the target has sent back a gesture scroll event ack with
   // unused scroll delta, and so another level of bubbling is needed. This
   // requires a GestureScrollEnd be sent to the last view, which will no
   // longer be the scroll target.
   if (bubbling_gesture_scroll_target_.target)
     SendGestureScrollEnd(bubbling_gesture_scroll_target_.target, event);
   else
@@ skipping 93 matching lines @@
       // Ignore this gesture sequence as no target is available.
       // TODO(wjmaclean): this only happens on Windows, and should not happen.
       // https://crbug.com/595422
       touchscreen_gesture_target_.target = nullptr;
       base::debug::DumpWithoutCrashing();
       return;
     }
 
     touchscreen_gesture_target_ = touchscreen_gesture_target_queue_.front();
     touchscreen_gesture_target_queue_.pop_front();
+
+    // Abort any scroll bubbling in progress to avoid double entry.
+    if (touchscreen_gesture_target_.target &&
+        touchscreen_gesture_target_.target ==
+            bubbling_gesture_scroll_target_.target) {
+      SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
+                           blink::WebGestureEvent());
+      CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
+    }
   }
 
   if (!touchscreen_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchscreen_gesture_target_.delta.x();
   event->y += touchscreen_gesture_target_.delta.y();
   touchscreen_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 void RenderWidgetHostInputEventRouter::RouteTouchpadGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   DCHECK_EQ(blink::WebGestureDeviceTouchpad, event->sourceDevice);
 
   if (event->type == blink::WebInputEvent::GesturePinchBegin ||
       event->type == blink::WebInputEvent::GestureFlingStart) {
     gfx::Point transformed_point;
     gfx::Point original_point(event->x, event->y);
     touchpad_gesture_target_.target =
         FindEventTarget(root_view, original_point, &transformed_point);
     // TODO(mohsen): Instead of just computing a delta, we should extract the
     // complete transform. We assume it doesn't change for the duration of the
     // touchpad gesture sequence, though this could be wrong; a better approach
     // might be to always transform each point to the
     // |touchpad_gesture_target_.target| for the duration of the sequence.
     touchpad_gesture_target_.delta = transformed_point - original_point;
+
+    // Abort any scroll bubbling in progress to avoid double entry.
+    if (touchpad_gesture_target_.target &&
+        touchpad_gesture_target_.target ==
+            bubbling_gesture_scroll_target_.target) {
+      SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
+                           blink::WebGestureEvent());
+      CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
+    }
   }
 
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content