scheduler: Add main thread gesture as a detected use case

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 175 matching lines @@
       scoped_refptr<SchedulerTqmDelegate> main_task_runner)
       : RendererSchedulerImpl(main_task_runner), update_policy_count_(0) {}
 
   void UpdatePolicyLocked(UpdateType update_type) override {
     update_policy_count_++;
     RendererSchedulerImpl::UpdatePolicyLocked(update_type);
 
     std::string use_case =
         RendererScheduler::UseCaseToString(MainThreadOnly().current_use_case);
     if (MainThreadOnly().touchstart_expected_soon) {
-      use_cases_.push_back(use_case + " scroll expected");
+      use_cases_.push_back(use_case + " touchstart expected");
     } else {
       use_cases_.push_back(use_case);
     }
   }
 
   void EnsureUrgentPolicyUpdatePostedOnMainThread() {
     base::AutoLock lock(any_thread_lock_);
     RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
         FROM_HERE);
   }
@@ skipping 131 matching lines @@
 
   enum class TouchEventPolicy {
     SEND_TOUCH_START,
     DONT_SEND_TOUCH_START,
   };
 
   void SimulateCompositorGestureStart(TouchEventPolicy touch_event_policy) {
     if (touch_event_policy == TouchEventPolicy::SEND_TOUCH_START) {
       scheduler_->DidHandleInputEventOnCompositorThread(
           FakeInputEvent(blink::WebInputEvent::TouchStart),
-          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+          RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
       scheduler_->DidHandleInputEventOnCompositorThread(
           FakeInputEvent(blink::WebInputEvent::TouchMove),
-          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+          RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
       scheduler_->DidHandleInputEventOnCompositorThread(
           FakeInputEvent(blink::WebInputEvent::TouchMove),
-          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+          RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
     }
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   }
 
   // Simulate a gesture where there is an active compositor scroll, but no
@@ skipping 34 matching lines @@
         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());
-    EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE,
+    EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
               ForceUpdatePolicyAndGetCurrentUseCase());
     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(
@@ skipping 21 matching lines @@
           RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
       scheduler_->DidHandleInputEventOnMainThread(
           FakeInputEvent(blink::WebInputEvent::TouchMove));
 
       scheduler_->DidHandleInputEventOnCompositorThread(
           FakeInputEvent(blink::WebInputEvent::TouchMove),
           RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
       scheduler_->DidHandleInputEventOnMainThread(
           FakeInputEvent(blink::WebInputEvent::TouchMove));
     }
-    scheduler_->DidHandleInputEventOnCompositorThread(
-        FakeInputEvent(gesture_type),
-        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
-    scheduler_->DidHandleInputEventOnMainThread(FakeInputEvent(gesture_type));
+    if (gesture_type != blink::WebInputEvent::Undefined) {
+      scheduler_->DidHandleInputEventOnCompositorThread(
+          FakeInputEvent(gesture_type),
+          RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+      scheduler_->DidHandleInputEventOnMainThread(FakeInputEvent(gesture_type));
+    }
   }
 
-  void SimulateMainThreadGestureCompositorTask(
+  void SimulateMainThreadInputHandlingCompositorTask(
       base::TimeDelta begin_main_frame_duration) {
     scheduler_->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::TouchMove),
         RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
     clock_->Advance(begin_main_frame_duration);
     scheduler_->DidHandleInputEventOnMainThread(
         FakeInputEvent(blink::WebInputEvent::TouchMove));
     scheduler_->DidCommitFrameToCompositor();
   }
 
@@ skipping 402 matching lines @@
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
   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());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            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();
@@ skipping 59 matching lines @@
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EnableIdleTasks();
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
   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());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_MainThreadHandlesInput_WithoutTouchHandler) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
   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());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 }
 
 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_DidAnimateForInput) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   scheduler_->DidAnimateForInputOnCompositorThread();
@@ skipping 19 matching lines @@
 
   SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
   scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
   RunUntilIdle();
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
-TEST_F(RendererSchedulerImplTest, ExpensiveTimersDoRunWhenMainThreadScrolling) {
+TEST_F(RendererSchedulerImplTest,
+       ExpensiveTimersDontRunWhenMainThreadScrolling) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(timer_task_runner_);
   DoMainFrame();
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
-                                 blink::WebInputEvent::GestureScrollBegin);
+                                 blink::WebInputEvent::GestureScrollUpdate);
 
   PostTestTasks(&run_order, "C1 T1");
 
   RunUntilIdle();
   EXPECT_FALSE(TouchStartExpectedSoon());
   EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
+}
+
+TEST_F(RendererSchedulerImplTest,
+       ExpensiveTimersDoRunWhenMainThreadInputHandling) {
+  std::vector<std::string> run_order;
+
+  scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
+  SimulateExpensiveTasks(timer_task_runner_);
+  DoMainFrame();
+  SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+                                 blink::WebInputEvent::Undefined);
+
+  PostTestTasks(&run_order, "C1 T1");
+
+  RunUntilIdle();
+  EXPECT_FALSE(TouchStartExpectedSoon());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
+
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        ExpensiveTimersDoRunWhenMainThreadScrolling_AndOnCriticalPath) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(timer_task_runner_);
   DoMainFrameOnCriticalPath();
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
 
   PostTestTasks(&run_order, "C1 T1");
 
   RunUntilIdle();
   EXPECT_FALSE(TouchStartExpectedSoon());
-  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestTouchstartPolicy_Compositor) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 D1 C1 D2 C2 T1 T2");
 
   // Observation of touchstart should defer execution of timer, idle and loading
@@ skipping 211 matching lines @@
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseWheel),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   RunUntilIdle();
   // Note compositor tasks are prioritized.
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("C2"),
                                    std::string("D1"), std::string("D2"),
                                    std::string("I1")));
-  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresKeyboardEvents) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::KeyDown),
@@ skipping 60 matching lines @@
             ForceUpdatePolicyAndGetCurrentUseCase());
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicyEnds_MainThreadHandlesInput) {
   SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
-  EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE,
+  EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
             ForceUpdatePolicyAndGetCurrentUseCase());
 
   clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest, TestTouchstartPolicyEndsAfterTimeout) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 D1 C1 D2 C2");
 
@@ skipping 160 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplTest, SlowMainThreadInputEvent) {
   EXPECT_EQ(UseCase::NONE, CurrentUseCase());
 
   // An input event should bump us into input priority.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   RunUntilIdle();
-  EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+  EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
 
   // Simulate the input event being queued for a very long time. The compositor
   // task we post here represents the enqueued input task.
   clock_->Advance(priority_escalation_after_input_duration() * 2);
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
   RunUntilIdle();
 
   // Even though we exceeded the input priority escalation period, we should
   // still be in main thread gesture since the input remains queued.
-  EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+  EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
 
   // After the escalation period ends we should go back into normal mode.
   clock_->Advance(priority_escalation_after_input_duration() * 2);
   RunUntilIdle();
   EXPECT_EQ(UseCase::NONE, CurrentUseCase());
 }
 
 class RendererSchedulerImplWithMockSchedulerTest
     : public RendererSchedulerImplTest {
  public:
@@ skipping 165 matching lines @@
        EnsureUpdatePolicyNotTriggeredTooOften) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   EXPECT_EQ(0, mock_scheduler_->update_policy_count_);
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   EXPECT_EQ(1, mock_scheduler_->update_policy_count_);
 
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   // We expect the first call to IsHighPriorityWorkAnticipated to be called
-  // after recieving an input event (but before the UpdateTask was processed) to
+  // after receiving an input event (but before the UpdateTask was processed) to
   // call UpdatePolicy.
   EXPECT_EQ(1, mock_scheduler_->update_policy_count_);
   scheduler_->IsHighPriorityWorkAnticipated();
   EXPECT_EQ(2, mock_scheduler_->update_policy_count_);
   // Subsequent calls should not call UpdatePolicy.
   scheduler_->IsHighPriorityWorkAnticipated();
   scheduler_->IsHighPriorityWorkAnticipated();
   scheduler_->IsHighPriorityWorkAnticipated();
   scheduler_->ShouldYieldForHighPriorityWork();
   scheduler_->ShouldYieldForHighPriorityWork();
   scheduler_->ShouldYieldForHighPriorityWork();
   scheduler_->ShouldYieldForHighPriorityWork();
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollEnd),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+  scheduler_->DidHandleInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchEnd),
+      RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+
+  scheduler_->DidHandleInputEventOnMainThread(
+      FakeInputEvent(blink::WebInputEvent::TouchStart));
+  scheduler_->DidHandleInputEventOnMainThread(
+      FakeInputEvent(blink::WebInputEvent::TouchMove));
+  scheduler_->DidHandleInputEventOnMainThread(
+      FakeInputEvent(blink::WebInputEvent::TouchMove));
+  scheduler_->DidHandleInputEventOnMainThread(
+      FakeInputEvent(blink::WebInputEvent::TouchEnd));
 
   EXPECT_EQ(2, mock_scheduler_->update_policy_count_);
 
   // We expect both the urgent and the delayed updates to run in addition to the
   // earlier updated cause by IsHighPriorityWorkAnticipated, a final update
-  // transitions from 'not_scrolling scroll expected' to 'not_scrolling'.
+  // transitions from 'not_scrolling touchstart expected' to 'not_scrolling'.
   RunUntilIdle();
-  EXPECT_THAT(mock_scheduler_->use_cases_,
-              testing::ElementsAre(
-                  std::string("none"), std::string("compositor_gesture"),
-                  std::string("compositor_gesture scroll expected"),
-                  std::string("none scroll expected"), std::string("none")));
+  EXPECT_THAT(
+      mock_scheduler_->use_cases_,
+      testing::ElementsAre(
+          std::string("none"), std::string("compositor_gesture"),
+          std::string("compositor_gesture touchstart expected"),
+          std::string("none touchstart expected"), std::string("none")));
 }
 
 class RendererSchedulerImplWithMessageLoopTest
     : public RendererSchedulerImplTest {
  public:
   RendererSchedulerImplWithMessageLoopTest()
       : RendererSchedulerImplTest(new base::MessageLoop()) {}
   ~RendererSchedulerImplWithMessageLoopTest() override {}
 
   void PostFromNestedRunloop(std::vector<
@@ skipping 513 matching lines @@
 TEST_F(RendererSchedulerImplTest,
        ExpensiveTimerTaskNotBlocked_UseCase_NONE_PreviousMainThreadGesture) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   DoMainFrame();
   SimulateExpensiveTasks(timer_task_runner_);
 
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
-  EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE,
+  EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
             ForceUpdatePolicyAndGetCurrentUseCase());
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchEnd),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::TouchEnd));
 
   clock_->Advance(priority_escalation_after_input_duration() * 2);
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
@@ skipping 204 matching lines @@
 
   SimulateExpensiveTasks(loading_task_runner_);
 
   // Loading tasks should not be disabled during main thread user interactions.
   PostTestTasks(&run_order, "C1 L1");
 
   // Trigger main_thread_gesture UseCase
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
   RunUntilIdle();
-  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+            CurrentUseCase());
 
   EXPECT_TRUE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("L1")));
 }
 
 TEST_F(RendererSchedulerImplTest, ModeratelyExpensiveTimer_NotBlocked) {
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::TouchMove);
   RunUntilIdle();
   for (int i = 0; i < 20; i++) {
     simulate_timer_task_ran_ = false;
 
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
 
     compositor_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &RendererSchedulerImplTest::SimulateMainThreadGestureCompositorTask,
-            base::Unretained(this), base::TimeDelta::FromMilliseconds(8)));
+        FROM_HERE, base::Bind(&RendererSchedulerImplTest::
+                                  SimulateMainThreadInputHandlingCompositorTask,
+                              base::Unretained(this),
+                              base::TimeDelta::FromMilliseconds(8)));
     timer_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
                               base::Unretained(this),
                               base::TimeDelta::FromMilliseconds(4)));
 
     RunUntilIdle();
     EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
-    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase())
+    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+              CurrentUseCase())
         << " i = " << i;
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
         EstimatedNextFrameBegin() - clock_->NowTicks();
     if (time_till_next_frame > base::TimeDelta())
       clock_->Advance(time_till_next_frame);
   }
 }
@@ skipping 30 matching lines @@
     EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
         EstimatedNextFrameBegin() - clock_->NowTicks();
     if (time_till_next_frame > base::TimeDelta())
       clock_->Advance(time_till_next_frame);
   }
 }
 
 TEST_F(RendererSchedulerImplTest,
-       ExpensiveTimer_NotBlocked_UseCase_MAIN_THREAD_GESTURE) {
+       ExpensiveTimer_NotBlocked_UseCase_MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::TouchMove);
   RunUntilIdle();
   for (int i = 0; i < 20; i++) {
     simulate_timer_task_ran_ = false;
 
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = false;
     scheduler_->WillBeginFrame(begin_frame_args);
 
     compositor_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &RendererSchedulerImplTest::SimulateMainThreadGestureCompositorTask,
-            base::Unretained(this), base::TimeDelta::FromMilliseconds(8)));
+        FROM_HERE, base::Bind(&RendererSchedulerImplTest::
+                                  SimulateMainThreadInputHandlingCompositorTask,
+                              base::Unretained(this),
+                              base::TimeDelta::FromMilliseconds(8)));
     timer_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RendererSchedulerImplTest::SimulateTimerTask,
                               base::Unretained(this),
                               base::TimeDelta::FromMilliseconds(10)));
 
     RunUntilIdle();
-    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase())
+    EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+              CurrentUseCase())
         << " i = " << i;
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     if (i == 0) {
       EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
     } else {
       EXPECT_TRUE(TimerTasksSeemExpensive()) << " i = " << i;
     }
     EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
@@ skipping 23 matching lines @@
 TEST_F(RendererSchedulerImplTest,
        DISABLED_EstimateLongestJankFreeTaskDuration_UseCase_) {
   scheduler_->OnNavigationStarted();
   EXPECT_EQ(UseCase::LOADING, ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_EQ(rails_response_time(),
             scheduler_->EstimateLongestJankFreeTaskDuration());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EstimateLongestJankFreeTaskDuration_UseCase_MAIN_THREAD_GESTURE) {
+  SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+                                 blink::WebInputEvent::GestureScrollUpdate);
   cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
   begin_frame_args.on_critical_path = false;
   scheduler_->WillBeginFrame(begin_frame_args);
 
   compositor_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &RendererSchedulerImplTest::SimulateMainThreadGestureCompositorTask,
-          base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
+      base::Bind(&RendererSchedulerImplTest::
+                     SimulateMainThreadInputHandlingCompositorTask,
+                 base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
 
   RunUntilIdle();
   EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 
   // 16ms frame - 5ms compositor work = 11ms for other stuff.
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
             scheduler_->EstimateLongestJankFreeTaskDuration());
 }
 
+TEST_F(
+    RendererSchedulerImplTest,
+    EstimateLongestJankFreeTaskDuration_UseCase_MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
+  cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
+      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
+  begin_frame_args.on_critical_path = false;
+  scheduler_->WillBeginFrame(begin_frame_args);
+
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&RendererSchedulerImplTest::
+                     SimulateMainThreadInputHandlingCompositorTask,
+                 base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
+
+  RunUntilIdle();
+  EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
+
+  // 16ms frame - 5ms compositor work = 11ms for other stuff.
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
+            scheduler_->EstimateLongestJankFreeTaskDuration());
+}
+
 TEST_F(RendererSchedulerImplTest,
        EstimateLongestJankFreeTaskDuration_UseCase_SYNCHRONIZED_GESTURE) {
   SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
 
   cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
   begin_frame_args.on_critical_path = true;
   scheduler_->WillBeginFrame(begin_frame_args);
 
@@ skipping 191 matching lines @@
     EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
     EXPECT_TRUE(scheduler_->TimerTaskRunner()->IsQueueEnabled()) << "i = " << i;
   }
 
   // Task is not throttled.
   EXPECT_EQ(500u, count);
 }
 
 TEST_F(RendererSchedulerImplTest,
        ExpensiveTimerTaskBlocked_SYNCHRONIZED_GESTURE_TouchStartExpected) {
+  SimulateExpensiveTasks(timer_task_runner_);
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
-  SimulateExpensiveTasks(timer_task_runner_);
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   ForceTouchStartToBeExpectedSoon();
 
   // Bump us into SYNCHRONIZED_GESTURE.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
 
   cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
@@ skipping 78 matching lines @@
     EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
   }
 
   // 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());
 }
 
-TEST_F(RendererSchedulerImplTest, MAIN_THREAD_GESTURE_CompositingExpensive) {
-  SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+TEST_F(RendererSchedulerImplTest, MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
+  SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
 
   // With the compositor task taking 20ms, there is not enough time to run
   // other tasks in the same 16ms frame. To avoid starvation, compositing tasks
   // should therefore not get prioritized.
   std::vector<std::string> run_order;
   for (int i = 0; i < 1000; i++)
     PostTestTasks(&run_order, "T1");
 
   for (int i = 0; i < 100; i++) {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidHandleInputEventOnCompositorThread(
-        FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
+        FakeInputEvent(blink::WebInputEvent::TouchMove),
         RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
 
     simulate_compositor_task_ran_ = false;
     compositor_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask,
                    base::Unretained(this),
                    base::TimeDelta::FromMilliseconds(20)));
 
     mock_task_runner_->RunTasksWhile(
         base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
                    base::Unretained(this)));
-    EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase()) << "i = " << i;
+    EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase())
+        << "i = " << i;
   }
 
   // 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());
 }
 
+TEST_F(RendererSchedulerImplTest, MAIN_THREAD_GESTURE) {
+  SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+                                 blink::WebInputEvent::GestureScrollBegin);
+
+  // With the compositor task taking 20ms, there is not enough time to run
+  // other tasks in the same 16ms frame. However because this is a main thread
+  // gesture instead of custom main thread input handling, we allow the timer
+  // tasks to be starved.
+  std::vector<std::string> run_order;
+  for (int i = 0; i < 1000; i++)
+    PostTestTasks(&run_order, "T1");
+
+  for (int i = 0; i < 100; i++) {
+    cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
+        base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
+    begin_frame_args.on_critical_path = true;
+    scheduler_->WillBeginFrame(begin_frame_args);
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate),
+        RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
+
+    simulate_compositor_task_ran_ = false;
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask,
+                   base::Unretained(this),
+                   base::TimeDelta::FromMilliseconds(20)));
+
+    mock_task_runner_->RunTasksWhile(
+        base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
+                   base::Unretained(this)));
+    EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase()) << "i = " << i;
+  }
+
+  EXPECT_EQ(TaskQueue::HIGH_PRIORITY,
+            scheduler_->CompositorTaskRunner()->GetQueuePriority());
+  EXPECT_EQ(279u, run_order.size());
+}
+
 }  // namespace scheduler