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

components/scheduler/renderer/renderer_scheduler_impl.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/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 108 matching lines @@
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       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() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       have_seen_touchstart(false) {}
 
@@ skipping 236 matching lines @@
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !MainThreadOnly().renderer_backgrounded)
     return;
 
   MainThreadOnly().renderer_backgrounded = false;
   suspend_timers_when_backgrounded_closure_.Cancel();
   ResumeTimerQueueWhenForegrounded();
 }
 
 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) {
   // We regard MouseMove events with the left mouse button down as a signal
   // that the user is doing something requiring a smooth frame rate.
   if (web_input_event.type == blink::WebInputEvent::MouseMove &&
       (web_input_event.modifiers & blink::WebInputEvent::LeftButtonDown)) {
     return true;
   }
   // Ignore all other mouse events because they probably don't signal user
@@ skipping 165 matching lines @@
       NOTREACHED();
       return false;
   }
 }
 
 base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting()
     const {
   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()) {
     UpdatePolicy();
   }
 }
 
 void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
     const tracked_objects::Location& from_here) {
   // TODO(scheduler-dev): Check that this method isn't called from the main
@@ skipping 636 matching lines @@
     }
     MainThreadOnly().have_reported_blocking_intervention_since_navigation =
         true;
     BroadcastConsoleWarning(
         "Deferred long-running timer task(s) to improve scrolling smoothness. "
         "See crbug.com/574343.");
   }
 }
 
 }  // namespace scheduler