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

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 0cf868ff75b5c5bb77f196d119ce0ac4063215da..49165482aec0b647991a6f7a261a75fbd5c9c214 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -154,6 +154,22 @@ void RecordCompositorSlowScrollMetric(InputHandler::ScrollInputType type,
   }
 }
 
+// Return true if ancestor is same as child or its ancestor.
+bool isScrollingAncestor(LayerImpl* child, LayerImpl* ancestor) {
+  DCHECK(ancestor);
+  if (!child)
+    return false;
+
+  ScrollTree& scroll_tree =
+      child->layer_tree_impl()->property_trees()->scroll_tree;
+  for (ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
+       scroll_node; scroll_node = scroll_tree.parent(scroll_node)) {
+    if (scroll_node->owner_id == ancestor->id())

[weiliangc, 2016/11/15 18:50:38]

Another difference between this function and HasScrollAncestor is that the other
function checks for scollable. Is this intentional?

Probably a nit but I think it's very hard to tell the difference between this
function and HasScrollAncestor by the name.

[bokan, 2016/11/15 19:02:29]

We should get rid of one of the functions because this would be quite confusing.
There's no point in checking scrollable in the loop, we should just check if the
returned layer's scroll node is scrollable at the call sites of
HasScrollingAncestor.

Also, nit: Chromium style functions start with capital letter.

[weiliangc, 2016/11/15 19:13:46]

We could break out of the loop and check if scrollable still inside the
function? It might be hard to reinforce checking for scrollable at all the call
sites. Unless there are use cases for both checking and not checking scrollable?

[weiliangc, 2016/11/15 19:43:47]

Oops now paid more attention to the code, I think the two functions are doing
different things.

Function here is "child IsCurrentlyScrolledBy ancestor" where the ancestor is
assumed to be scrollable, since it is the active scrolling layer. And the
function returns true if ancestor is anywhere between child and root (including
child). Maybe add a DCHECK for ancestor's scroll_node is scrollable?

Function HasScrollAncestor is probably more "child's ClosestScrollAncestorIs
ancestor" since the loop is broken out as soon as it finds a scrollable node.

So we would need both functions, just need to rename thing to distinguish them.

+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 DEFINE_SCOPED_UMA_HISTOGRAM_TIMER(PendingTreeDurationHistogramTimer,
@@ -581,7 +597,7 @@ EventListenerProperties LayerTreeHostImpl::GetEventListenerProperties(
   return active_tree_->event_listener_properties(event_class);
 }
 
-bool LayerTreeHostImpl::DoTouchEventsBlockScrollAt(
+EventListenerProperties LayerTreeHostImpl::DoTouchHandlersBlockScrollAt(
     const gfx::Point& viewport_point) {
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
@@ -591,7 +607,16 @@ bool LayerTreeHostImpl::DoTouchEventsBlockScrollAt(
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
           device_viewport_point);
-  return layer_impl != NULL;
+  if (layer_impl == NULL)
+    return EventListenerProperties::kNone;
+
+  if (!CurrentlyScrollingLayer())
+    return EventListenerProperties::kBlocking;
+
+  bool is_ancestor =
+      isScrollingAncestor(layer_impl, active_tree_->CurrentlyScrollingLayer());
+  return is_ancestor ? EventListenerProperties::kBlockingAndPassiveDueToFling
+                     : EventListenerProperties::kBlocking;
 }
 
 std::unique_ptr<SwapPromiseMonitor>
@@ -2578,7 +2603,7 @@ LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
 }
 
 // Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
-static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
+static bool isScrolledBy(LayerImpl* child, LayerImpl* scroll_ancestor) {
   DCHECK(scroll_ancestor);
   if (!child)
     return false;
@@ -2662,8 +2687,7 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     LayerImpl* scroll_layer_impl =
         active_tree_->FindFirstScrollingLayerOrScrollbarLayerThatIsHitByPoint(
             device_viewport_point);
-    if (scroll_layer_impl &&
-        !HasScrollAncestor(layer_impl, scroll_layer_impl)) {
+    if (scroll_layer_impl && !isScrolledBy(layer_impl, scroll_layer_impl)) {
       scroll_status.thread = SCROLL_UNKNOWN;
       scroll_status.main_thread_scrolling_reasons =
           MainThreadScrollingReason::kFailedHitTest;