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

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 136 matching lines @@
   bool scroll_on_main_thread = (scroll_thread == MAIN_THREAD);
   if (IsWheelBasedScroll(type)) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorWheelScrollUpdateThread",
                           scroll_on_main_thread);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorTouchScrollUpdateThread",
                           scroll_on_main_thread);
   }
 }
 
+// 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,
                                   "Scheduling.%s.PendingTreeDuration");
 
 LayerTreeHostImpl::FrameData::FrameData()
     : render_surface_layer_list(nullptr),
       has_no_damage(false),
       may_contain_video(false) {}
 
@@ skipping 407 matching lines @@
   }
 
   return false;
 }
 
 EventListenerProperties LayerTreeHostImpl::GetEventListenerProperties(
     EventListenerClass event_class) const {
   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());
 
   // Now determine if there are actually any handlers at that point.
   // TODO(rbyers): Consider also honoring touch-action (crbug.com/347272).
   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>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return base::WrapUnique(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
 ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
@@ skipping 1966 matching lines @@
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
       return NULL;
     }
   }
 
   return potentially_scrolling_layer_impl;
 }
 
 // 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;
   ScrollTree& scroll_tree =
       child->layer_tree_impl()->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
   for (; scroll_tree.parent(scroll_node);
        scroll_node = scroll_tree.parent(scroll_node)) {
     if (scroll_node->scrollable)
       return scroll_node->owner_id == scroll_ancestor->id();
@@ skipping 63 matching lines @@
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   if (layer_impl) {
     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;
       return scroll_status;
     }
   }
 
   bool scroll_on_main_thread = false;
   LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, type, layer_impl, &scroll_on_main_thread,
@@ skipping 1421 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc