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 scrollable 'ancestor' is the same layer as 'child' or its
+// ancestor along the scroll tree.
+bool IsScrolledBy(LayerImpl* child, LayerImpl* ancestor) {
+  DCHECK(ancestor && ancestor->scrollable());
+  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 =
+      IsScrolledBy(layer_impl, active_tree_->CurrentlyScrollingLayer());
+  return is_ancestor ? EventListenerProperties::kBlockingAndPassiveDueToFling

[bokan, 2016/11/15 22:42:40]

It's only a fling if we're currently in a touch start. If we don't have a bit
somewhere that keeps track of whether we're in a fling or not, the name of the
method should imply that it should only be called from a TouchStart. e.g.
EventListenerTypeForTouchStartAt()

[lanwei, 2016/11/16 21:13:28]

Done.

+                     : EventListenerProperties::kBlocking;
 }
 
 std::unique_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return base::WrapUnique(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
 ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
@@ skipping 1965 matching lines @@
     if (IsMainThreadScrolling(status, scroll_node)) {
       *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.

[bokan, 2016/11/15 22:42:40]

It's Layer::HasAncestor and the difference is significant because of the if
(scroll_node->scrollable) so I'd just remove this comment.

[lanwei, 2016/11/16 21:13:28]

Done.

-static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
+static bool IsClosestScrollAncestor(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 64 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)) {
+        !IsClosestScrollAncestor(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