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

cc/trees/layer_tree_host_impl_unittest.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 <algorithm>
 #include <cmath>
@@ skipping 790 matching lines @@
     child = child_layer.get();
     child_layer->SetDrawsContent(true);
     child_layer->SetPosition(gfx::PointF(0, 20));
     child_layer->SetBounds(gfx::Size(50, 50));
     scroll->test_properties()->AddChild(std::move(child_layer));
     host_impl_->active_tree()->BuildPropertyTreesForTesting();
   }
 
   // Touch handler regions determine whether touch events block scroll.
   root->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
-  EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
+  EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(10, 10)),
+            EventListenerProperties::kBlocking);

[bokan, 2016/11/17 15:39:28]

EXPECT_EQ's arguments are (expected, actual), which means this is backwards.

[lanwei, 2016/11/18 00:54:07]

Acknowledged.

 
   // But they don't influence the actual handling of the scroll gestures.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::TOUCHSCREEN);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain,
             status.main_thread_scrolling_reasons);
   host_impl_->ScrollEnd(EndState().get());
 
-  EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 30)));
+  EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(10, 30)),

[bokan, 2016/11/17 15:39:28]

Ditto to these ones.

[lanwei, 2016/11/18 00:54:07]

Done.

+            EventListenerProperties::kBlocking);
   root->SetTouchEventHandlerRegion(gfx::Rect());
-  EXPECT_FALSE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 30)));
+  EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(10, 30)),
+            EventListenerProperties::kNone);
   child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
-  EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 30)));
+  EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(10, 30)),
+            EventListenerProperties::kBlocking);
 }
 
 TEST_F(LayerTreeHostImplTest, FlingOnlyWhenScrollingTouchscreen) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   // Ignore the fling since no layer is being scrolled
   InputHandler::ScrollStatus status = host_impl_->FlingScrollBegin();
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
@@ skipping 9085 matching lines @@
   last_on_draw_frame_.reset();
 
   // Different draw params does swap.
   did_request_redraw_ = false;
   host_impl_->OnDraw(draw_transform, draw_viewport2,
                      resourceless_software_draw);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
+TEST_F(LayerTreeHostImplTest, TouchInsideOrOutsideFlingLayer) {

[bokan, 2016/11/17 15:39:28]

Please add a short 1-2 sentence comment above describing what this test is
checking for.

[lanwei, 2016/11/18 00:54:07]

Done.

+  gfx::Size surface_size(100, 100);
+  gfx::Size inner_size(50, 50);
+
+  LayerImpl* root =
+      CreateBasicVirtualViewportLayers(surface_size, surface_size);

[bokan, 2016/11/17 15:39:28]

I think the viewports should be the inner_size (we resize the content root to
surface_size/2 in CreateScrollableLayer anyway so this will make things more
logical).

[lanwei, 2016/11/18 00:54:07]

Done.

+  root->test_properties()->force_render_surface = true;
+
+  std::unique_ptr<LayerImpl> child =
+      CreateScrollableLayer(26, surface_size, root);
+  std::unique_ptr<LayerImpl> grand_child =
+      CreateScrollableLayer(27, inner_size, root);

[bokan, 2016/11/17 15:39:28]

I think the clip for the grand_child should be child instead of root. I have a
hard time visualizing how this look as it is (though I know it technically works
as other tests do this). If it still works, change this to use child and make
the size surface_size*2. That'll simulate 2 nested scrolling divs.

[lanwei, 2016/11/18 00:54:07]

Sorry, I tried, but they do not work. I want to be able touch the child layer,
so the grand_child layer size is smaller than child. If I make  child as the
clip for the grand_child, then I could not touch the child layer.

[bokan, 2016/11/18 18:41:36]

Ok, thanks for trying.

+  LayerImpl* grand_child_layer = grand_child.get();
+  child->test_properties()->AddChild(std::move(grand_child));
+
+  LayerImpl* child_layer = child.get();
+  root->test_properties()->AddChild(std::move(child));
+  host_impl_->active_tree()->BuildPropertyTreesForTesting();
+  host_impl_->active_tree()->DidBecomeActive();
+
+  grand_child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
+                                                     gfx::ScrollOffset(0, 5));
+  child_layer->layer_tree_impl()
+      ->property_trees()
+      ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
+                                                     gfx::ScrollOffset(3, 0));
+
+  host_impl_->SetViewportSize(surface_size);

[bokan, 2016/11/17 15:39:28]

No need for this, it's called as part of CreateBasicVirtualViewportLayers.

[lanwei, 2016/11/18 00:54:07]

Done.

+  DrawFrame();
+  {
+    child_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
+    grand_child_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
+    EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(10, 10)),
+              EventListenerProperties::kBlocking);
+    // Flinging the child layer.
+    EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
+              host_impl_
+                  ->ScrollBegin(BeginState(gfx::Point(60, 60)).get(),
+                                InputHandler::TOUCHSCREEN)
+                  .thread);
+    EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
+              host_impl_->FlingScrollBegin().thread);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child_layer);
+    // Touch on the child layer, which is an active fling layer, the touch
+    // event handler will force to be passive.
+    EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(70, 80)),
+              EventListenerProperties::kBlockingAndMaybePassiveDueToFling);
+    // Touch on the grand child layer, which is a descendant of an active fling
+    // layer, the touch event handler will force to be passive.
+    EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(20, 30)),
+              EventListenerProperties::kBlockingAndMaybePassiveDueToFling);
+
+    // Now flinging on the grand child layer.
+    EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
+              host_impl_
+                  ->ScrollBegin(BeginState(gfx::Point(10, 10)).get(),
+                                InputHandler::TOUCHSCREEN)
+                  .thread);
+    EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
+              host_impl_->FlingScrollBegin().thread);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
+    // Touch on the child layer, the touch event handler will still be blocking.
+    EXPECT_EQ(host_impl_->EventListenerTypeForTouchStartAt(gfx::Point(60, 60)),
+              EventListenerProperties::kBlocking);
+  }
+}
+
 class ResourcelessSoftwareLayerTreeHostImplTest : public LayerTreeHostImplTest {
  protected:
   std::unique_ptr<CompositorFrameSink> CreateCompositorFrameSink() override {
     return FakeCompositorFrameSink::Create3d();
   }
 };
 
 TEST_F(ResourcelessSoftwareLayerTreeHostImplTest,
        ResourcelessSoftwareSetNeedsRedraw) {
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
@@ skipping 1679 matching lines @@
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_over_scrollbar());
   host_impl_->MouseMoveAt(gfx::Point(10, 150));
   EXPECT_TRUE(scrollbar_1_animation_controller->mouse_is_near_scrollbar());
   EXPECT_TRUE(scrollbar_1_animation_controller->mouse_is_over_scrollbar());
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_near_scrollbar());
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_over_scrollbar());
 }
 
 }  // namespace
 }  // namespace cc