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_->DoTouchHandlersBlockScrollAt(gfx::Point(10, 10)),
+            EventListenerProperties::kBlocking);
 
   // 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_->DoTouchHandlersBlockScrollAt(gfx::Point(10, 30)),
+            EventListenerProperties::kBlocking);
   root->SetTouchEventHandlerRegion(gfx::Rect());
-  EXPECT_FALSE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 30)));
+  EXPECT_EQ(host_impl_->DoTouchHandlersBlockScrollAt(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_->DoTouchHandlersBlockScrollAt(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) {
+  gfx::Size surface_size(100, 100);
+  gfx::Size inner_size(50, 50);

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

Please use CreateBasicVirtualViewportLayers to initialize the layer tree. It
makes sure we're everything is properly initialized to look and behave like the
compositor does when Chrome is running in the wild. For an example, see:

TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit)

Then you can add your child/grand-child layers and avoid a lot of boilerplate.

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

Done.

+  std::unique_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl_->active_tree(), 1);
+  root->test_properties()->force_render_surface = true;
+
+  std::unique_ptr<LayerImpl> root_scrolling_layer =
+      CreateScrollableLayer(2, surface_size, root.get());
+  auto* root_scrolling = root_scrolling_layer.get();
+  root->test_properties()->AddChild(std::move(root_scrolling_layer));
+
+  std::unique_ptr<LayerImpl> child_layer =
+      CreateScrollableLayer(3, surface_size, root.get());
+  auto* child = child_layer.get();
+  root_scrolling->test_properties()->AddChild(std::move(child_layer));
+
+  std::unique_ptr<LayerImpl> grand_child_layer =
+      CreateScrollableLayer(4, inner_size, root.get());
+  child->test_properties()->AddChild(std::move(grand_child_layer));
+
+  host_impl_->active_tree()->SetRootLayerForTesting(std::move(root));
+  host_impl_->active_tree()->BuildPropertyTreesForTesting();
+  host_impl_->active_tree()->DidBecomeActive();
+
+  host_impl_->SetViewportSize(surface_size);
+  DrawFrame();
+  {
+    std::unique_ptr<ScrollAndScaleSet> scroll_info;
+    LayerImpl* child = host_impl_->active_tree()

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

We've already saved the child and grand_child pointers above, no need to get
them again.

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

Done.

+                           ->root_layer_for_testing()
+                           ->test_properties()
+                           ->children[0]
+                           ->test_properties()
+                           ->children[0];
+    LayerImpl* grand_child = child->test_properties()->children[0];
+    child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
+    grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
+    EXPECT_EQ(host_impl_->DoTouchHandlersBlockScrollAt(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);
+    // Touch on the child layer, which is an active fling layer, the touch
+    // event handler will force to be passive.
+    EXPECT_EQ(host_impl_->DoTouchHandlersBlockScrollAt(gfx::Point(70, 80)),
+              EventListenerProperties::kBlockingAndPassiveDueToFling);
+    // 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_->DoTouchHandlersBlockScrollAt(gfx::Point(20, 30)),
+              EventListenerProperties::kBlockingAndPassiveDueToFling);
+
+    // 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);
+    // Touch on the child layer, the touch event handler will still be blocking.
+    EXPECT_EQ(host_impl_->DoTouchHandlersBlockScrollAt(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