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 11 matching lines @@
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pesimistic view when estimating
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 99;
 const int kTimerTaskEstimationSampleCount = 1000;
 const double kTimerTaskEstimationPercentile = 99;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 50;
+

[Sami, 2016/04/06 15:52:37]

Accidental change?

[szager1, 2016/04/06 17:55:30]

Yes, reverted

 }
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<SchedulerTqmDelegate> main_task_runner)
     : helper_(main_task_runner,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
       idle_helper_(&helper_,
                    this,
@@ skipping 77 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)
+    return;
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::EndIdlePeriod");
   helper_.CheckOnValidThread();
   idle_helper_.EndIdlePeriod();
 }
 
+void RendererSchedulerImpl::EndIdlePeriodForTesting(
+    const base::Closure& callback,
+    base::TimeTicks time_remaining) {
+  MainThreadOnly().in_idle_period_for_testing = false;
+  EndIdlePeriod();
+  callback.Run();
+}
+
 // 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;
+  IdleTaskRunner()->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&RendererSchedulerImpl::EndIdlePeriodForTesting,
+                 weak_factory_.GetWeakPtr(), callback));
+  idle_helper_.EnableLongIdlePeriod();
+}
+
 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