Add testRunner.runIdleTasks() to force idle tasks to run.

components/scheduler/renderer/renderer_scheduler_impl.cc

Index: components/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/components/scheduler/renderer/renderer_scheduler_impl.cc b/components/scheduler/renderer/renderer_scheduler_impl.cc
index 306c45cc0a783df4c849963c17ec761c1dc2a490..0420a7247a19783ee17bfb5702896ac63c44ed6e 100644
--- a/components/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/components/scheduler/renderer/renderer_scheduler_impl.cc
@@ -126,7 +126,8 @@ RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
-      expensive_task_blocking_allowed(true) {}
+      expensive_task_blocking_allowed(true),
+      in_idle_period_for_testing(false) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
@@ -383,12 +384,22 @@ void RendererSchedulerImpl::OnRendererForegrounded() {
 }
 
 void RendererSchedulerImpl::EndIdlePeriod() {
+  if (MainThreadOnly().in_idle_period_for_testing)

[rmcilroy, 2016/04/06 23:17:53]

Is this necessary given you are using a long idle period? The long idle periods
should keep repeating until the compositor says it is about to draw a frame, and
given the compositor doesn't send this signal for the layout tests, we should
always be in an idle periods after you call RunIdleTasksForTesting until
EndIdlePeriodForTesting (e.g., even although each period is only max 50ms, once
we reach the end of that 50ms a new long idle period starts immediately).

[szager1, 2016/04/06 23:28:39]

It's my hope that runIdleTasks will also be useful for virtual/threaded/ layout
tests, i.e., it will be deterministic even if the compositor thread jumps in. 
I'm really new to all of this code, so if that seems silly, please let me know.

[rmcilroy, 2016/04/07 08:48:38]

Ahh I see. I guess it doesn't hurt to ensure runIdleTasks works in threaded
mode, although I would prefer that we didn't use it for threaded mode specific
tests to ensure that we are testing real rIC behaviour.

+    return;
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::EndIdlePeriod");
   helper_.CheckOnValidThread();
   idle_helper_.EndIdlePeriod();
 }
 
+void RendererSchedulerImpl::EndIdlePeriodForTesting(
+    const base::Closure& callback) {
+  MainThreadOnly().in_idle_period_for_testing = false;
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+               "RendererSchedulerImpl::EndIdlePeriodForTesting");
+  callback.Run();

[rmcilroy, 2016/04/06 23:17:53]

You probably need to explicitly call EndIdlePeriod here (see above), otherwise
the idle period would continue if there is anything left in the idle queue
(i.e., if the previously run idle callbacks posted called rIC themselves) or go
into the IN_LONG_IDLE_PERIOD_PAUSED state (not ended). See
IdleHelper::UpdateLongIdlePeriodStateAfterIdleTask(). 

[szager1, 2016/04/06 23:28:39]

This method is only invoked from IdleHelper::EndIdlePeriodForTesting, which
itself calls EndIdlePeriod().  I suppose there's no harm in calling it again
here, but I don't think it's necessary.

[rmcilroy, 2016/04/07 08:48:38]

Ahh, missed this. I'm wondering if it would make sense to move all the logic
from IdleHelper here instead - you should be able to do everything you need
(start / end a long idle period and post the end idle period for testing task.
Personally I think that would be cleaner.

+}
+
 // static
 bool RendererSchedulerImpl::ShouldPrioritizeInputEvent(
     const blink::WebInputEvent& web_input_event) {
@@ -574,6 +585,15 @@ base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting()
   return idle_helper_.CurrentIdleTaskDeadline();
 }
 
+void RendererSchedulerImpl::RunIdleTasksForTesting(
+    const base::Closure& callback) {
+  MainThreadOnly().in_idle_period_for_testing = true;
+  idle_helper_.RunIdleTasksForTesting(
+      base::Bind(&RendererSchedulerImpl::EndIdlePeriodForTesting,
+                 weak_factory_.GetWeakPtr(),
+                 callback));
+}
+
 void RendererSchedulerImpl::MaybeUpdatePolicy() {
   helper_.CheckOnValidThread();
   if (policy_may_need_update_.IsSet()) {