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

components/scheduler/child/idle_helper.h

 // Copyright 2015 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.
 
 #ifndef COMPONENTS_SCHEDULER_CHILD_IDLE_HELPER_H_
 #define COMPONENTS_SCHEDULER_CHILD_IDLE_HELPER_H_
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "components/scheduler/base/cancelable_closure_holder.h"
@@ skipping 81 matching lines @@
 
   // Start an idle period with a given idle period deadline.
   void StartIdlePeriod(IdlePeriodState new_idle_period_state,
                        base::TimeTicks now,
                        base::TimeTicks idle_period_deadline);
 
   // This will end an idle period either started with StartIdlePeriod or
   // EnableLongIdlePeriod.
   void EndIdlePeriod();
 
+  // Enter a long idle period that automatically ends when all queued
+  // idle tasks have run.  The callback argument will be run after the
+  // idle period ends.
+  void RunIdleTasksForTesting(const base::Closure& callback);
+
   // Returns true if a currently running idle task could exceed its deadline
   // without impacting user experience too much. This should only be used if
   // there is a task which cannot be pre-empted and is likely to take longer
   // than the largest expected idle task deadline. It should NOT be polled to
   // check whether more work can be performed on the current idle task after
   // its deadline has expired - post a new idle task for the continuation of the
   // work in this case.
   // Must be called from the thread this class was created on.
   bool CanExceedIdleDeadlineIfRequired() const;
 
@@ skipping 68 matching lines @@
   // |next_long_idle_period_delay_out| with the next time we should try to
   // initiate the next idle period.
   IdlePeriodState ComputeNewLongIdlePeriodState(
       const base::TimeTicks now,
       base::TimeDelta* next_long_idle_period_delay_out);
 
   bool ShouldWaitForQuiescence();
   void OnIdleTaskPostedOnMainThread();
   void UpdateLongIdlePeriodStateAfterIdleTask();
 
+  void EndIdlePeriodForTesting(const base::Closure& callback,
+                               base::TimeTicks time_remaining);
+
   void SetIdlePeriodState(IdlePeriodState new_state,
                           base::TimeTicks new_deadline,
                           base::TimeTicks optional_now);
 
   // Returns true if |state| represents being within an idle period state.
   static bool IsInIdlePeriod(IdlePeriodState state);
   // Returns true if |state| represents being within a long idle period state.
   static bool IsInLongIdlePeriod(IdlePeriodState state);
 
   SchedulerHelper* helper_;  // NOT OWNED
@@ skipping 12 matching lines @@
 
   base::WeakPtr<IdleHelper> weak_idle_helper_ptr_;
   base::WeakPtrFactory<IdleHelper> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IdleHelper);
 };
 
 }  // namespace scheduler
 
 #endif  // COMPONENTS_SCHEDULER_CHILD_IDLE_HELPER_H_