scheduler: Detect when a main thread touch stream turns into a compositor gesture

components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

 // Copyright 2014 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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 343 matching lines @@
           RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     }
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   }
 
-  void SimulateMainThreadGestureWithCancelledScroll() {
+  // Simulate a gesture where there is an active compositor scroll, but no
+  // scroll updates are generated. Instead, the main thread handles
+  // non-canceleable touch events, making this an effectively main thread
+  // driven gesture.
+  void SimulateMainThreadGestureWithoutScrollUpdates() {
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::TouchStart),
         RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::TouchMove),
         RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::TouchMove),
         RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   }
 
+  // Simulate a gesture where the main thread handles touch events but does not
+  // preventDefault(), allowing the gesture to turn into a compositor driven
+  // gesture. This function also verifies the necessary policy updates are
+  // scheduled.
+  void SimulateMainThreadGestureWithoutPreventDefault() {
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::TouchStart),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+
+    // Touchstart policy update.
+    EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
+    scheduler_->ForceUpdatePolicy();

[alex clarke (OOO till 29th), 2016/05/11 17:06:52]

Perhaps assert on the policy - to double check what we think is happen is
actually happening?

[Sami, 2016/05/11 18:00:10]

Good idea, done.

+    EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
+
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::TouchMove),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureTapCancel),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
+        RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+
+    // Main thread gesture policy update.
+    EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
+    scheduler_->ForceUpdatePolicy();
+    EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
+
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
+        RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::TouchScrollStarted),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::TouchMove),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+
+    // Compositor thread gesture policy update.
+    EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
+    scheduler_->ForceUpdatePolicy();
+    EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
+  }
+
   void SimulateMainThreadGestureStart(TouchEventPolicy touch_event_policy,
                                       blink::WebInputEvent::Type gesture_type) {
     if (touch_event_policy == TouchEventPolicy::SEND_TOUCH_START) {
       scheduler_->DidHandleInputEventOnCompositorThread(
           FakeInputEvent(blink::WebInputEvent::TouchStart),
           RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
       scheduler_->DidHandleInputEventOnMainThread(
           FakeInputEvent(blink::WebInputEvent::TouchStart));
 
       scheduler_->DidHandleInputEventOnCompositorThread(
@@ skipping 418 matching lines @@
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1"),
                                    std::string("D2"), std::string("I1"),
                                    std::string("C1"), std::string("C2")));
   EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
-       TestCompositorPolicy_MainThreadHandlesInput_WithCancelledScroll) {
+       TestCompositorPolicy_MainThreadHandlesInput_WithoutScrollUpdates) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
-  SimulateMainThreadGestureWithCancelledScroll();
+  SimulateMainThreadGestureWithoutScrollUpdates();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("L1"), std::string("D1"),
                                    std::string("D2"), std::string("I1")));
   EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
+       TestCompositorPolicy_MainThreadHandlesInput_WithoutPreventDefault) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
+
+  scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
+  EnableIdleTasks();
+  SimulateMainThreadGestureWithoutPreventDefault();
+  RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("L1"), std::string("D1"),
+                                   std::string("D2"), std::string("I1"),
+                                   std::string("C1"), std::string("C2")));
+  EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
+}
+
+TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_CompositorHandlesInput_LongGestureDuration) {
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   base::TimeTicks loop_end_time =
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(
                                UserModel::kMedianGestureDurationMillis * 2);
 
   // The UseCase::COMPOSITOR_GESTURE usecase initially deprioritizes compositor
@@ skipping 2074 matching lines @@
   }
 
   // Timer tasks should not have been starved by the expensive compositor
   // tasks.
   EXPECT_EQ(TaskQueue::NORMAL_PRIORITY,
             scheduler_->CompositorTaskRunner()->GetQueuePriority());
   EXPECT_EQ(1000u, run_order.size());
 }
 
 }  // namespace scheduler