Throttling Helper to disable task queue until PumpThrottledTasks called

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 2654 matching lines @@
     timer_queue->PostTask(FROM_HERE, base::Bind(SlowCountingTask, count, clock,
                                                 task_duration, timer_queue));
   }
 }
 }
 
 TEST_F(RendererSchedulerImplTest,
        SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_expensive) {
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
+  base::TimeTicks first_throttled_run_time =
+      ThrottlingHelper::ThrottledRunTime(clock_->NowTicks());
+
   size_t count = 0;
   // With the compositor task taking 10ms, there is not enough time to run this
   // 7ms timer task in the 16ms frame.
   scheduler_->TimerTaskRunner()->PostTask(
       FROM_HERE, base::Bind(SlowCountingTask, &count, clock_.get(), 7,
                             scheduler_->TimerTaskRunner()));
 
   for (int i = 0; i < 1000; 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_CONSUMED_BY_COMPOSITOR);
 
     simulate_compositor_task_ran_ = false;
     compositor_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask,
                    base::Unretained(this),
                    base::TimeDelta::FromMilliseconds(10)));
 
     mock_task_runner_->RunTasksWhile(
         base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
                    base::Unretained(this)));
     EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
-    EXPECT_TRUE(scheduler_->TimerTaskRunner()->IsQueueEnabled()) << "i = " << i;
+
+    // Before the policy is updated the queue will be enabled. Subsequently it
+    // will be disabled until the throttled queue is pumped.
+    bool expect_queue_enabled =
+        (i == 0) || (clock_->NowTicks() > first_throttled_run_time);
+    EXPECT_EQ(expect_queue_enabled,
+              scheduler_->TimerTaskRunner()->IsQueueEnabled())
+        << "i = " << i;
   }
 
   // Task is throttled but not completely blocked.
-  EXPECT_EQ(13u, count);
+  EXPECT_EQ(12u, count);
 }
 
 TEST_F(RendererSchedulerImplTest,
        SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_not_expensive) {
   SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
 
   size_t count = 0;
   // With the compositor task taking 10ms, there is enough time to run this 6ms
   // timer task in the 16ms frame.
   scheduler_->TimerTaskRunner()->PostTask(
@@ skipping 165 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