Make touch events uncancelable during fling when they are on the current active scroll layer

ui/events/blink/input_handler_proxy.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 "ui/events/blink/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 779 matching lines @@
       return DID_HANDLE;
     }
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD: {
       TRACE_EVENT_INSTANT0("input,rail",
                            "InputHandlerProxy::HandleGestureFling::"
                            "scroll_on_main_thread",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = false;
       fling_may_be_active_on_main_thread_ = true;
-      client_->DidStartFlinging();
       return DID_NOT_HANDLE;
     }
     case cc::InputHandler::SCROLL_IGNORED: {
       TRACE_EVENT_INSTANT0(
           "input,rail",
           "InputHandlerProxy::HandleGestureFling::ignored",
           TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = false;
       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
         // We still pass the curve to the main thread if there's nothing
         // scrollable, in case something
         // registers a handler before the curve is over.
         return DID_NOT_HANDLE;
       }
       return DROP_EVENT;
     }
   }
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchStart(
     const blink::WebTouchEvent& touch_event) {
   EventDisposition result = DROP_EVENT;
+  cc::InputHandler::TouchStartHitResult hit_result =
+      cc::InputHandler::TouchStartHitResult::SAME_LAYER;
   for (size_t i = 0; i < touch_event.touchesLength; ++i) {
     if (touch_event.touches[i].state != WebTouchPoint::StatePressed)
       continue;
-    if (input_handler_->DoTouchEventsBlockScrollAt(
-            gfx::Point(touch_event.touches[i].position.x,
-                       touch_event.touches[i].position.y))) {
+    hit_result = input_handler_->DoTouchEventsBlockScrollAt(gfx::Point(
+        touch_event.touches[i].position.x, touch_event.touches[i].position.y));
+    if (hit_result != cc::InputHandler::HANDLER) {
       result = DID_NOT_HANDLE;
       break;
     }
   }
 
   // If |result| is DROP_EVENT it wasn't processed above.
   if (result == DROP_EVENT) {
     switch (input_handler_->GetEventListenerProperties(
         cc::EventListenerClass::kTouchStartOrMove)) {
       case cc::EventListenerProperties::kPassive:
@@ skipping 29 matching lines @@
   // If |result| is still DROP_EVENT look at the touch end handler as
   // we may not want to discard the entire touch sequence. Note this
   // code is explicitly after the assignment of the |touch_start_result_|
   // so the touch moves are not sent to the main thread un-necessarily.
   if (result == DROP_EVENT &&
       input_handler_->GetEventListenerProperties(
           cc::EventListenerClass::kTouchEndOrCancel) !=
           cc::EventListenerProperties::kNone) {
     result = DID_HANDLE_NON_BLOCKING;
   }
+  bool is_fling_on_impl = fling_curve_ && !fling_may_be_active_on_main_thread_;
+  bool touch_on_active_scroll_layer =
+      hit_result == cc::InputHandler::TouchStartHitResult::SAME_LAYER;
 
+  if (result == DID_NOT_HANDLE && touch_on_active_scroll_layer &&
+      is_fling_on_impl) {
+    result = DID_NOT_HANDLE_NON_BLOCKING;
+  }
   return result;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchMove(
     const blink::WebTouchEvent& touch_event) {
   if (touch_start_result_ != kEventDispositionUndefined)
     return static_cast<EventDisposition>(touch_start_result_);
   return DID_NOT_HANDLE;
 }
 
@@ skipping 404 matching lines @@
       return false;
   }
 
   switch (disposition) {
     case DID_HANDLE:
     case DID_HANDLE_NON_BLOCKING:
       return true;
     case DROP_EVENT:
       break;
     case DID_NOT_HANDLE:
+    case DID_NOT_HANDLE_NON_BLOCKING:
       TRACE_EVENT_INSTANT0("input",
                            "InputHandlerProxy::scrollBy::AbortFling",
                            TRACE_EVENT_SCOPE_THREAD);
       // If we got a DID_NOT_HANDLE, that means we need to deliver wheels on the
       // main thread. In this case we need to schedule a commit and transfer the
       // fling curve over to the main thread and run the rest of the wheels from
       // there. This can happen when flinging a page that contains a scrollable
       // subarea that we can't scroll on the thread if the fling starts outside
       // the subarea but then is flung "under" the pointer.
       client_->TransferActiveWheelFlingAnimation(fling_parameters_);
       fling_may_be_active_on_main_thread_ = true;
-      client_->DidStartFlinging();
       CancelCurrentFlingWithoutNotifyingClient();
       break;
   }
 
   return false;
 }
 
 bool InputHandlerProxy::scrollBy(const WebFloatSize& increment,
                                  const WebFloatSize& velocity) {
   WebFloatSize clipped_increment;
@@ skipping 70 matching lines @@
   // is made asynchronously, to minimize divergence between main thread and
   // impl thread event handling paths.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&InputScrollElasticityController::ObserveGestureEventAndResult,
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
 }  // namespace ui