Make sure all the touch events during an active fling are uncancelable

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 580 matching lines @@
   return false;
 }
 
 EventListenerProperties LayerTreeHostImpl::GetEventListenerProperties(
     EventListenerClass event_class) const {
   return active_tree_->event_listener_properties(event_class);
 }
 
 // Return true if scrollable node for 'ancestor' is the same as 'child' or an
 // ancestor along the scroll tree.
-bool IsScrolledBy(LayerImpl* child, ScrollNode* ancestor) {
+bool LayerTreeHostImpl::IsScrolledBy(LayerImpl* child, ScrollNode* ancestor) {
   DCHECK(ancestor && ancestor->scrollable);
   if (!child)
     return false;
 
-  auto* property_trees = child->layer_tree_impl()->property_trees();
-  ScrollTree& scroll_tree = property_trees->scroll_tree;
+  ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;

[weiliangc, 2017/03/22 18:11:31]

Could you DCHECK that child is on active tree? as in child->layer_tree_impl() ==
active_tree_

[lanwei, 2017/03/23 19:56:49]

Done.

   for (ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
        scroll_node; scroll_node = scroll_tree.parent(scroll_node)) {
     if (scroll_node->id == ancestor->id)
       return true;
   }
   return false;
 }
 
 InputHandler::TouchStartEventListenerType
 LayerTreeHostImpl::EventListenerTypeForTouchStartAt(
     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 =
+  LayerImpl* layer_impl_with_touch_handler =
       active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
           device_viewport_point);
-  if (layer_impl == NULL)
+  if (layer_impl_with_touch_handler == NULL)
     return InputHandler::TouchStartEventListenerType::NO_HANDLER;
 
   if (!CurrentlyScrollingNode())
     return InputHandler::TouchStartEventListenerType::HANDLER;
 
+  // Check if the touch start hits on the current scrolling layer or its
+  // descendant. When we scroll on layer_impl_with_touch_handler, a blank layer
+  // is created inside it, which is the actual scrolling layer, and it does not

[pdr., 2017/03/22 20:30:11]

If we have the following:
<div style="border: 1px solid black; width: 400px; height: 400px; overflow:
scroll; background: white; will-change: transform;">
content<div id=forcescroll style="height: 1000px;"></div>
</div>

I think this example will create two layers: one for the outer div, and one for
the content. Is that correct? I don't think any blank layers are created.

[lanwei, 2017/03/23 19:56:49]

I changed the comments, did not mention the blank layer, should cover all cases.

+  // have any event handler.
+  LayerImpl* layer_impl =
+      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);

[weiliangc, 2017/03/22 18:11:31]

Consider the case where there are two divs, where the parent one has touch
handler, and its child div is inside parent div and has a scrolling layer
inside.
The layer structure would look like:
- parent div layer with touch handler
  - child div layer
    - child div content layer that is currently scrolling

This would make the parent div touch handler uncancellable. Is this expected
behavior?

[pdr., 2017/03/22 20:30:11]

+1 to Wei's question

I am also curious: this logic looks similar to LayerTreeHostImpl::ScrollBegin
which is also called by input_handler_proxy. Are these codes doing similar work?
Are these checks needed for other hit test cases?

[lanwei, 2017/03/23 19:56:49]

This change is part of our touch event intervention, we make touch events
unblock from the event handlers by forcing them uncancellable when there is an
active fling. We are checking the layers when we are handling touch starts to
make sure the touches hit on a scrolling layer or its descendant, so we can make
them uncancellable. That is why we only check it in this class. Maybe the code
is similar than ScrollBegin, but they are doing very different things.

[lanwei, 2017/03/23 19:56:49]

Good question. No matter we scroll on the parent div layer or the child div
layer, we do not make the parent div touch handler uncancellable. We are
actually making the touch events uncancellable, so that they are not blocked by
the event handlers in the parent layer. We want the touch starts are
uncancellable, if the layer the touch starts hit on is the same as the scroll
layer or its descendant.

   bool is_ancestor = IsScrolledBy(layer_impl, CurrentlyScrollingNode());
   return is_ancestor ? InputHandler::TouchStartEventListenerType::
                            HANDLER_ON_SCROLLING_LAYER
                      : InputHandler::TouchStartEventListenerType::HANDLER;
 }
 
 std::unique_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return base::WrapUnique(
@@ skipping 3543 matching lines @@
       worker_context_visibility_ =
           worker_context->CacheController()->ClientBecameVisible();
     } else {
       worker_context->CacheController()->ClientBecameNotVisible(
           std::move(worker_context_visibility_));
     }
   }
 }
 
 }  // namespace cc