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 isAncestor(LayerImpl* child, LayerImpl* ancestor) {

[bokan, 2016/11/14 18:32:48]

This should be called isScrollingAncestor to make clear that it's looking along
the scroll tree.

This leaves us with isScrollingAncestor and hasScrollingAncestor, the latter of
which checks all the way up to - but not including - the root. weiliangc@, is
the behavior in hasScrollingAncestor intentionally skipping the root scroll
node? If so, we should rename it to make it clear. Otherwise, we should remove
it and replace uses with this function.

[weiliangc, 2016/11/14 19:02:55]

It is an unfortunate implementation detail of Property Tree that the node 0 is
actually a dummy node that contains no real information. This implementation
would be able to reach the root node we care about.

[bokan, 2016/11/14 19:04:32]

But in that case, there shouldn't be a LayerImpl to match the scroll tree root
node right? So looping all the way up to the root should be ok.

[weiliangc, 2016/11/14 20:57:20]

Yeah, so only one of the two function would be fine.

[lanwei, 2016/11/14 22:47:45]

https://codesearch.chromium.org/chromium/src/cc/trees/layer_tree_host_impl.cc...
One more different part is 
if (scroll_node->scrollable)
  return scroll_node->owner_id == scroll_ancestor->id();

if the scroll_node is scrollable, and scroll_node is a ancestor of
scroll_ancestor, but not equal, this will return false. But we want the loop to
be continue and check its parents...

weiliangc@ I guess HasScrollAncestor want to compare with the first scroll layer
of child with scroll_ancestor?

[weiliangc, 2016/11/15 15:32:35]

How about rename the function to isScrolledBy? It would make it clear you are
only looking at the first scrollable ancestor.

Thanks!

+  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())
+      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 =
+      isAncestor(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 3479 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc