Optimize for TouchStart responsiveness

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 "base/callback.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
@@ skipping 108 matching lines @@
   *should_yield_before = scheduler->ShouldYieldForHighPriorityWork();
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   if (simulate_input) {
     scheduler->DidHandleInputEventOnCompositorThread(
         FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
         RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   }
   *should_yield_after = scheduler->ShouldYieldForHighPriorityWork();
 }
 
+enum class SimulateInputType {
+  None,
+  TouchStart,
+  TouchEnd,
+  GestureScrollBegin,
+  GestureScrollEnd
+};
+
 void AnticipationTestTask(RendererSchedulerImpl* scheduler,
-                          bool simulate_input,
+                          SimulateInputType simulate_input,
                           bool* is_anticipated_before,
                           bool* is_anticipated_after) {
   *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
-  if (simulate_input) {
-    scheduler->DidHandleInputEventOnCompositorThread(
-        FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
-        RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+  switch (simulate_input) {
+    case SimulateInputType::None:
+      break;
+
+    case SimulateInputType::TouchStart:
+      scheduler->DidHandleInputEventOnCompositorThread(
+          FakeInputEvent(blink::WebInputEvent::TouchStart),
+          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+      break;
+
+    case SimulateInputType::TouchEnd:
+      scheduler->DidHandleInputEventOnCompositorThread(
+          FakeInputEvent(blink::WebInputEvent::TouchEnd),
+          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+      break;
+
+    case SimulateInputType::GestureScrollBegin:
+      scheduler->DidHandleInputEventOnCompositorThread(
+          FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
+          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+      break;
+
+    case SimulateInputType::GestureScrollEnd:
+      scheduler->DidHandleInputEventOnCompositorThread(
+          FakeInputEvent(blink::WebInputEvent::GestureScrollEnd),
+          RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+      break;
   }
   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 }
 
 };  // namespace
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   using RendererSchedulerImpl::OnIdlePeriodEnded;
   using RendererSchedulerImpl::OnIdlePeriodStarted;
-  using RendererSchedulerImpl::Policy;
-  using RendererSchedulerImpl::PolicyToString;
 
   RendererSchedulerImplForTest(
       scoped_refptr<SchedulerTaskRunnerDelegate> 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");
+    } else {
+      use_cases_.push_back(use_case);
+    }
   }
 
   void EnsureUrgentPolicyUpdatePostedOnMainThread() {
     base::AutoLock lock(any_thread_lock_);
     RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
         FROM_HERE);
   }
 
   void ScheduleDelayedPolicyUpdate(base::TimeTicks now, base::TimeDelta delay) {
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, delay, now);
   }
 
   bool BeginMainFrameOnCriticalPath() {
     base::AutoLock lock(any_thread_lock_);
-    return AnyThread().begin_main_frame_on_critical_path_;
+    return AnyThread().begin_main_frame_on_critical_path;
   }
 
   int update_policy_count_;
+  std::vector<std::string> use_cases_;
 };
 
 // Lets gtest print human readable Policy values.
 ::std::ostream& operator<<(::std::ostream& os,
-                           const RendererSchedulerImplForTest::Policy& policy) {
-  return os << RendererSchedulerImplForTest::PolicyToString(policy);
+                           const RendererScheduler::UseCase& use_case) {
+  return os << RendererScheduler::UseCaseToString(use_case);
 }
 
 class RendererSchedulerImplTest : public testing::Test {
  public:
-  using Policy = RendererSchedulerImpl::Policy;
+  using UseCase = RendererSchedulerImpl::UseCase;
 
   RendererSchedulerImplTest() : clock_(new base::SimpleTestTickClock()) {
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
   }
 
   RendererSchedulerImplTest(base::MessageLoop* message_loop)
       : clock_(new base::SimpleTestTickClock()), message_loop_(message_loop) {
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
   }
 
@@ skipping 45 matching lines @@
   void RunUntilIdle() {
     // Only one of mock_task_runner_ or message_loop_ should be set.
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get())
       mock_task_runner_->RunUntilIdle();
     else
       message_loop_->RunUntilIdle();
   }
 
   void DoMainFrame() {
-    scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
+    cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
+    begin_frame_args.on_critical_path = false;
+    scheduler_->WillBeginFrame(begin_frame_args);
     scheduler_->DidCommitFrameToCompositor();
   }
 
+  void ForceMainThreadScrollingUseCase() {
+    cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
+        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
+    begin_frame_args.on_critical_path = true;
+    scheduler_->WillBeginFrame(begin_frame_args);
+  }
+
   void EnableIdleTasks() { DoMainFrame(); }
 
-  Policy CurrentPolicy() {
-    return scheduler_->MainThreadOnly().current_policy_;
+  UseCase CurrentUseCase() {
+    return scheduler_->MainThreadOnly().current_use_case;
+  }
+
+  UseCase ForceUpdatePolicyAndGetCurrentUseCase() {
+    scheduler_->ForceUpdatePolicy();
+    return scheduler_->MainThreadOnly().current_use_case;
+  }
+
+  bool TouchStartExpectedSoon() {
+    return scheduler_->MainThreadOnly().touchstart_expected_soon;
+  }
+
+  bool HaveSeenABeginMainframe() {
+    return scheduler_->MainThreadOnly().have_seen_a_begin_main_frame;
+  }
+
+  bool LoadingTasksSeemExpensive() {
+    return scheduler_->MainThreadOnly().loading_tasks_seem_expensive;
+  }
+
+  bool TimerTasksSeemExpensive() {
+    return scheduler_->MainThreadOnly().timer_tasks_seem_expensive;
   }
 
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'C': Compositor task
   // - 'L': Loading task
   // - 'I': Idle task
   // - 'T': Timer task
@@ skipping 27 matching lines @@
           break;
         default:
           NOTREACHED();
       }
     }
   }
 
  protected:
   static base::TimeDelta priority_escalation_after_input_duration() {
     return base::TimeDelta::FromMilliseconds(
-        RendererSchedulerImpl::kPriorityEscalationAfterInputMillis);
+        UserModel::kGestureEstimationLimitMillis);
+  }
+
+  static base::TimeDelta subsequent_input_expected_after_input_duration() {
+    return base::TimeDelta::FromMilliseconds(
+        UserModel::kExpectSubsequentGestureMillis);
   }
 
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         IdleHelper::kMaximumIdlePeriodMillis);
   }
 
   static base::TimeDelta end_idle_when_hidden_delay() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kEndIdleWhenHiddenDelayMillis);
@@ skipping 12 matching lines @@
   template <typename E>
   static void CallForEachEnumValue(E first,
                                    E last,
                                    const char* (*function)(E)) {
     for (E val = first; val < last;
          val = static_cast<E>(static_cast<int>(val) + 1)) {
       (*function)(val);
     }
   }
 
-  static void CheckAllPolicyToString() {
-    CallForEachEnumValue<RendererSchedulerImpl::Policy>(
-        RendererSchedulerImpl::Policy::FIRST_POLICY,
-        RendererSchedulerImpl::Policy::POLICY_COUNT,
-        &RendererSchedulerImpl::PolicyToString);
+  static void CheckAllUseCaseToString() {
+    CallForEachEnumValue<RendererSchedulerImpl::UseCase>(
+        RendererSchedulerImpl::UseCase::FIRST_USE_CASE,
+        RendererSchedulerImpl::UseCase::USE_CASE_COUNT,
+        &RendererSchedulerImpl::UseCaseToString);
   }
 
   scoped_ptr<base::SimpleTestTickClock> clock_;
   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_ptr<base::MessageLoop> message_loop_;
 
   scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner_;
   scoped_ptr<RendererSchedulerImplForTest> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
@@ skipping 213 matching lines @@
 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1"),
                                    std::string("C1"), std::string("D2"),
                                    std::string("C2"), std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_CompositorHandlesInput) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   EnableIdleTasks();
   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")));
+              testing::ElementsAre(std::string("L1"), std::string("D1"),
+                                   std::string("C1"), std::string("D2"),
+                                   std::string("C2"), std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_MainThreadHandlesInput) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   EnableIdleTasks();
   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")));
+              testing::ElementsAre(std::string("L1"), std::string("D1"),
+                                   std::string("C1"), std::string("D2"),
+                                   std::string("C2"), std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, 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_->DidAnimateForInputOnCompositorThread();
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("C1"), std::string("C2"),
-                                   std::string("D1"), std::string("D2"),
+              testing::ElementsAre(std::string("D1"), std::string("C1"),
+                                   std::string("D2"), std::string("C2"),
                                    std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 }
 
 TEST_F(
     RendererSchedulerImplTest,
     TestCompositorPolicy_ExpensiveTimersDontRunWhenMainThreadOnCriticalPath) {
   std::vector<std::string> run_order;
 
+  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
+  // tasks unless we set AutoAdvanceNow to true :/
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
   // Simulate a bunch of expensive timer tasks
   for (int i = 0; i < 10; i++) {
     timer_task_runner_->PostTask(
         FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
                               base::Unretained(clock_.get()),
                               base::TimeDelta::FromMilliseconds(500)));
   }
+
   RunUntilIdle();
 
-  // Timers should now be disabled during main thread user userinteractions.
+  // Switch back to not auto-advancing because we want to be in control of when
+  // time advances.
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+
+  // Timers should now be disabled during main thread user user interactions.
+  PostTestTasks(&run_order, "C1 T1");
+
+  // Trigger main_thread_gesture UseCase
+  scheduler_->DidAnimateForInputOnCompositorThread();
+  cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
+      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
+  begin_frame_args1.on_critical_path = true;
+  scheduler_->WillBeginFrame(begin_frame_args1);
+  RunUntilIdle();
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
+  clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
+
+  run_order.clear();
+  RunUntilIdle();
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
+}
+
+TEST_F(RendererSchedulerImplTest, Navigation_ResetsTaskCostEstimations) {
+  std::vector<std::string> run_order;
+
+  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
+  // tasks unless we set AutoAdvanceNow to true :/
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  // Simulate a bunch of expensive timer tasks
+  for (int i = 0; i < 10; i++) {
+    timer_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
+                              base::Unretained(clock_.get()),
+                              base::TimeDelta::FromMilliseconds(500)));
+  }
+
+  RunUntilIdle();
+
+  // Switch back to not auto-advancing because we want to be in control of when
+  // time advances.
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+
+  scheduler_->OnPageLoadStarted();
   PostTestTasks(&run_order, "C1 T1");
 
   scheduler_->DidAnimateForInputOnCompositorThread();
-  scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
+  cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL));
-  RunUntilIdle();
-
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
-  clock_->Advance(priority_escalation_after_input_duration() * 2);
-
-  run_order.clear();
-  RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
-}
-
-TEST_F(RendererSchedulerImplTest,
-       TestCompositorPolicy_TimersAlwaysRunIfNoRecentIdlePeriod) {
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "C1 T1");
-
-  // Simulate no recent idle period.
-  clock_->Advance(idle_period_starvation_threshold() * 2);
-
-  scheduler_->DidAnimateForInputOnCompositorThread();
-  scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
-      BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL));
-
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
+  begin_frame_args1.on_critical_path = true;
+  scheduler_->WillBeginFrame(begin_frame_args1);
+  scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
   RunUntilIdle();
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicy_TimersAlwaysRun_MainThreadNotOnCriticalPath) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "C1 T1");
@@ skipping 108 matching lines @@
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
   RunUntilIdle();
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("T1"),
                                    std::string("T2")));
 }
 
-TEST_F(RendererSchedulerImplTest, LoadingPriorityPolicy) {
+// TODO(alexclarke): Reenable once we've reinstaed the Loading UseCase.
+TEST_F(RendererSchedulerImplTest, DISABLED_LoadingUseCase) {
   std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
+  PostTestTasks(&run_order, "I1 D1 C1 T1 L1 D2 C2 T2 L2");
 
   scheduler_->OnPageLoadStarted();
   EnableIdleTasks();
   RunUntilIdle();
-  // In loading policy compositor tasks are best effort and should be run last.
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("D1"),
-                                   std::string("D2"), std::string("I1"),
-                                   std::string("C1"), std::string("C2")));
 
-  // Advance 1.5s and try again, the loading policy should have ended and the
-  // task order should return to normal.
-  clock_->Advance(base::TimeDelta::FromMilliseconds(1500));
+  // In loading policy, loading tasks are prioritized other others.
+  std::string loading_policy_expected[] = {
+      std::string("D1"), std::string("L1"), std::string("D2"),
+      std::string("L2"), std::string("C1"), std::string("T1"),
+      std::string("C2"), std::string("T2"), std::string("I1")};
+  EXPECT_THAT(run_order, testing::ElementsAreArray(loading_policy_expected));
+  EXPECT_EQ(RendererScheduler::UseCase::LOADING, CurrentUseCase());
+
+  // Advance 15s and try again, the loading policy should have ended and the
+  // task order should return to the NONE use case where loading tasks are no
+  // longer prioritized.
+  clock_->Advance(base::TimeDelta::FromMilliseconds(150000));
   run_order.clear();
-  PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
+  PostTestTasks(&run_order, "I1 D1 C1 T1 L1 D2 C2 T2 L2");
   EnableIdleTasks();
   RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("D1"),
-                                   std::string("C1"), std::string("D2"),
-                                   std::string("C2"), std::string("I1")));
+
+  std::string default_order_expected[] = {
+      std::string("D1"), std::string("C1"), std::string("T1"),
+      std::string("L1"), std::string("D2"), std::string("C2"),
+      std::string("T2"), std::string("L2"), std::string("I1")};
+  EXPECT_THAT(run_order, testing::ElementsAreArray(default_order_expected));
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
-  EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
-  EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
-  scheduler_->DidHandleInputEventOnMainThread(
-      FakeInputEvent(blink::WebInputEvent::MouseMove));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_MouseMove_WhenMouseDown) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove,
                      blink::WebInputEvent::LeftButtonDown),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
-  EnableIdleTasks();
   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")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_MouseMove_WhenMouseDown) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseMove,
                      blink::WebInputEvent::LeftButtonDown),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
-  EnableIdleTasks();
   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")));
   scheduler_->DidHandleInputEventOnMainThread(FakeInputEvent(
       blink::WebInputEvent::MouseMove, blink::WebInputEvent::LeftButtonDown));
 }
 
 TEST_F(RendererSchedulerImplTest, EventConsumedOnCompositorThread_MouseWheel) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseWheel),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
-  EnableIdleTasks();
   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")));
 }
 
 TEST_F(RendererSchedulerImplTest, EventForwardedToMainThread_MouseWheel) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::MouseWheel),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
-  EnableIdleTasks();
   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")));
-  scheduler_->DidHandleInputEventOnMainThread(
-      FakeInputEvent(blink::WebInputEvent::MouseWheel));
+  EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventConsumedOnCompositorThread_IgnoresKeyboardEvents) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::KeyDown),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
-  EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        EventForwardedToMainThread_IgnoresKeyboardEvents) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 D2 C2");
 
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::KeyDown),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
-  EnableIdleTasks();
   RunUntilIdle();
   // Note compositor tasks are not prioritized.
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
+  // Note compositor tasks are not prioritized.
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::KeyDown));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       TestCompositorPolicyDoesNotStarveDefaultTasks) {
+       TestMainthreadScrollingUseCaseDoesNotStarveDefaultTasks) {
+  ForceMainThreadScrollingUseCase();
+  scheduler_->DidCommitFrameToCompositor();  // Enable Idle tasks.
+
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 C1");
 
   for (int i = 0; i < 20; i++) {
     compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
   }
   PostTestTasks(&run_order, "C2");
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   RunUntilIdle();
   // Ensure that the default D1 task gets to run at some point before the final
   // C2 compositor task.
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("D1"),
                                    std::string("C2")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicyEnds_CompositorHandlesInput) {
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "D1 C1 D2 C2");
-
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("C1"), std::string("C2"),
-                                   std::string("D1"), std::string("D2")));
+  EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+            ForceUpdatePolicyAndGetCurrentUseCase());
 
-  run_order.clear();
   clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
-  PostTestTasks(&run_order, "D1 C1 D2 C2");
-
-  // Compositor policy mode should have ended now that the clock has advanced.
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("D2"), std::string("C2")));
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest,
        TestCompositorPolicyEnds_MainThreadHandlesInput) {
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "D1 C1 D2 C2");
-
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("C1"), std::string("C2"),
-                                   std::string("D1"), std::string("D2")));
+  EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+            ForceUpdatePolicyAndGetCurrentUseCase());
 
-  run_order.clear();
   clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
-  PostTestTasks(&run_order, "D1 C1 D2 C2");
-
-  // Compositor policy mode should have ended now that the clock has advanced.
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("D2"), std::string("C2")));
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 TEST_F(RendererSchedulerImplTest, TestTouchstartPolicyEndsAfterTimeout) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "L1 D1 C1 D2 C2");
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   RunUntilIdle();
@@ skipping 43 matching lines @@
       FakeInputEvent(blink::WebInputEvent::TouchMove),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("L1")));
 }
 
 TEST_F(RendererSchedulerImplTest, TestIsHighPriorityWorkAnticipated) {
   bool is_anticipated_before = false;
   bool is_anticipated_after = false;
 
-  bool simulate_input = false;
   default_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
-                 &is_anticipated_before, &is_anticipated_after));
+      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
+                            SimulateInputType::None, &is_anticipated_before,
+                            &is_anticipated_after));
   RunUntilIdle();
   // In its default state, without input receipt, the scheduler should indicate
   // that no high-priority is anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
 
-  simulate_input = true;
+  default_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
+                            SimulateInputType::TouchStart,
+                            &is_anticipated_before, &is_anticipated_after));
+  bool dummy;
+  default_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
+                            SimulateInputType::TouchEnd, &dummy, &dummy));
   default_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
-                 &is_anticipated_before, &is_anticipated_after));
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::GestureScrollBegin, &dummy, &dummy));
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(),
+                 SimulateInputType::GestureScrollEnd, &dummy, &dummy));
+
   RunUntilIdle();
   // When input is received, the scheduler should indicate that high-priority
   // work is anticipated.
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_TRUE(is_anticipated_after);
 
   clock_->Advance(priority_escalation_after_input_duration() * 2);
-  simulate_input = false;
   default_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
-                 &is_anticipated_before, &is_anticipated_after));
+      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
+                            SimulateInputType::None, &is_anticipated_before,
+                            &is_anticipated_after));
   RunUntilIdle();
-  // Without additional input, the scheduler should indicate that high-priority
-  // work is no longer anticipated.
+  // Without additional input, the scheduler should go into NONE
+  // use case but with scrolling expected where high-priority work is still
+  // anticipated.
+  EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_TRUE(is_anticipated_before);
+  EXPECT_TRUE(is_anticipated_after);
+
+  clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
+  default_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AnticipationTestTask, scheduler_.get(),
+                            SimulateInputType::None, &is_anticipated_before,
+                            &is_anticipated_after));
+  RunUntilIdle();
+  // Eventually the scheduler should go into the default use case where
+  // high-priority work is no longer anticipated.
+  EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+  EXPECT_FALSE(TouchStartExpectedSoon());
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
 }
 
 TEST_F(RendererSchedulerImplTest, TestShouldYield) {
   bool should_yield_before = false;
   bool should_yield_after = false;
 
+  ForceMainThreadScrollingUseCase();
+
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             default_task_runner_, false, &should_yield_before,
                             &should_yield_after));
   RunUntilIdle();
   // Posting to default runner shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             compositor_task_runner_, false,
                             &should_yield_before, &should_yield_after));
   RunUntilIdle();
-  // Posting while not in compositor priority shouldn't cause yielding.
+  // Posting while not mainthread scrolling shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             compositor_task_runner_, true, &should_yield_before,
                             &should_yield_after));
   RunUntilIdle();
   // We should be able to switch to compositor priority mid-task.
   EXPECT_FALSE(should_yield_before);
   EXPECT_TRUE(should_yield_after);
+}
 
+TEST_F(RendererSchedulerImplTest, TestShouldYield_TouchStart) {
   // Receiving a touchstart should immediately trigger yielding, even if
   // there's no immediately pending work in the compositor queue.
   EXPECT_FALSE(scheduler_->ShouldYieldForHighPriorityWork());
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart),
       RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
   EXPECT_TRUE(scheduler_->ShouldYieldForHighPriorityWork());
   RunUntilIdle();
 }
 
 TEST_F(RendererSchedulerImplTest, SlowMainThreadInputEvent) {
-  EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
+  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(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
+  EXPECT_EQ(UseCase::COMPOSITOR_GESTURE, 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 compositor priority since the input remains queued.
-  EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
+  EXPECT_EQ(UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 
   // After the escalation period ends we should go back into normal mode.
   clock_->Advance(priority_escalation_after_input_duration() * 2);
   RunUntilIdle();
-  EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
+  EXPECT_EQ(UseCase::NONE, CurrentUseCase());
 }
 
 class RendererSchedulerImplWithMockSchedulerTest
     : public RendererSchedulerImplTest {
  public:
   void SetUp() override {
     mock_task_runner_ = make_scoped_refptr(
         new cc::OrderedSimpleTaskRunner(clock_.get(), false));
     main_task_runner_ =
         SchedulerTaskRunnerDelegateForTest::Create(mock_task_runner_);
@@ skipping 157 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplWithMockSchedulerTest,
        EnsureUpdatePolicyNotTriggeredTooOften) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   scheduler_->DidHandleInputEventOnCompositorThread(
-      FakeInputEvent(blink::WebInputEvent::TouchMove),
+      FakeInputEvent(blink::WebInputEvent::GestureScrollBegin),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
 
   // We expect the first call to IsHighPriorityWorkAnticipated to be called
   // after recieving an input event (but before the UpdateTask was processed) to
   // call UpdatePolicy.
   EXPECT_EQ(0, mock_scheduler_->update_policy_count_);
   scheduler_->IsHighPriorityWorkAnticipated();
   EXPECT_EQ(1, 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_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->DidHandleInputEventOnMainThread(
-      FakeInputEvent(blink::WebInputEvent::TouchMove));
+      FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));
 
   EXPECT_EQ(1, 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'.
   RunUntilIdle();
-  // We expect both the urgent and the delayed updates to run in addition to the
-  // earlier updated cause by IsHighPriorityWorkAnticipated.
-  EXPECT_EQ(3, mock_scheduler_->update_policy_count_);
+  EXPECT_THAT(mock_scheduler_->use_cases_,
+              testing::ElementsAre(std::string("compositor_gesture"),
+                                   std::string("compositor_gesture"),
+                                   std::string("none scroll expected"),
+                                   std::string("none")));
 }
 
 class RendererSchedulerImplWithMessageLoopTest
     : public RendererSchedulerImplTest {
  public:
   RendererSchedulerImplWithMessageLoopTest()
       : RendererSchedulerImplTest(new base::MessageLoop()) {}
   ~RendererSchedulerImplWithMessageLoopTest() override {}
 
   void PostFromNestedRunloop(std::vector<
@@ skipping 334 matching lines @@
   scheduler_->ResumeTimerQueue();
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   scheduler_->ResumeTimerQueue();
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 }
 
-TEST_F(RendererSchedulerImplTest, PolicyToString) {
-  CheckAllPolicyToString();
+TEST_F(RendererSchedulerImplTest, UseCaseToString) {
+  CheckAllUseCaseToString();
 }
 
 TEST_F(RendererSchedulerImplTest, MismatchedDidHandleInputEventOnMainThread) {
   // This should not DCHECK because there was no corresponding compositor side
   // call to DidHandleInputEventOnCompositorThread with
   // INPUT_EVENT_ACK_STATE_NOT_CONSUMED. There are legitimate reasons for the
   // compositor to not be there and we don't want to make debugging impossible.
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 }
@@ skipping 53 matching lines @@
   RunUntilIdle();
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T4"), std::string("T5")));
 
   // Subsequent timer tasks should fire as usual.
   run_order.clear();
   PostTestTasks(&run_order, "T6");
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T6")));
 }
+
+TEST_F(RendererSchedulerImplTest,
+       ExpensiveLoadingTasksNotBlockedTillFirstBeginMainFrame) {
+  std::vector<std::string> run_order;
+
+  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
+  // tasks unless we set AutoAdvanceNow to true :/
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  // Simulate a bunch of expensive loading tasks
+  for (int i = 0; i < 10; i++) {
+    loading_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
+                              base::Unretained(clock_.get()),
+                              base::TimeDelta::FromMilliseconds(500)));
+  }
+
+  RunUntilIdle();
+
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+  EXPECT_FALSE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("L1"), std::string("D1")));
+
+  // Emit a BeginMainFrame, and the loading task should get blocked.
+  DoMainFrame();
+  run_order.clear();
+
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("L1"), std::string("D1")));
+}
+
 }  // namespace scheduler