[scheduler]: Avoid waking up the scheduler to end long idle periods.

components/scheduler/child/single_thread_idle_task_runner.cc

Index: components/scheduler/child/single_thread_idle_task_runner.cc
diff --git a/components/scheduler/child/single_thread_idle_task_runner.cc b/components/scheduler/child/single_thread_idle_task_runner.cc
index e7aeda31ba31bcc478390584f3a56d4f55c8b758..846a4a462394f130ef8df3eaf6278b873d8cd0db 100644
--- a/components/scheduler/child/single_thread_idle_task_runner.cc
+++ b/components/scheduler/child/single_thread_idle_task_runner.cc
@@ -12,11 +12,11 @@ namespace scheduler {
 SingleThreadIdleTaskRunner::SingleThreadIdleTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> idle_priority_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> after_wakeup_task_runner,
-    base::Callback<void(base::TimeTicks*)> deadline_supplier,
+    Delegate* delegate,
     const char* tracing_category)
     : idle_priority_task_runner_(idle_priority_task_runner),
       after_wakeup_task_runner_(after_wakeup_task_runner),
-      deadline_supplier_(deadline_supplier),
+      delegate_(delegate),
       tracing_category_(tracing_category),
       weak_factory_(this) {
   DCHECK(!idle_priority_task_runner_ ||
@@ -29,6 +29,12 @@ SingleThreadIdleTaskRunner::SingleThreadIdleTaskRunner(
 SingleThreadIdleTaskRunner::~SingleThreadIdleTaskRunner() {
 }
 
+SingleThreadIdleTaskRunner::Delegate::Delegate() {
+}
+
+SingleThreadIdleTaskRunner::Delegate::~Delegate() {
+}
+
 bool SingleThreadIdleTaskRunner::RunsTasksOnCurrentThread() const {
   return idle_priority_task_runner_->RunsTasksOnCurrentThread();
 }
@@ -36,6 +42,7 @@ bool SingleThreadIdleTaskRunner::RunsTasksOnCurrentThread() const {
 void SingleThreadIdleTaskRunner::PostIdleTask(
     const tracked_objects::Location& from_here,
     const IdleTask& idle_task) {
+  delegate_->OnIdleTaskPosted();
   idle_priority_task_runner_->PostTask(
       from_here, base::Bind(&SingleThreadIdleTaskRunner::RunTask,
                             weak_scheduler_ptr_, idle_task));
@@ -44,6 +51,7 @@ void SingleThreadIdleTaskRunner::PostIdleTask(
 void SingleThreadIdleTaskRunner::PostNonNestableIdleTask(
     const tracked_objects::Location& from_here,
     const IdleTask& idle_task) {
+  delegate_->OnIdleTaskPosted();
   idle_priority_task_runner_->PostNonNestableTask(
       from_here, base::Bind(&SingleThreadIdleTaskRunner::RunTask,
                             weak_scheduler_ptr_, idle_task));
@@ -52,25 +60,20 @@ void SingleThreadIdleTaskRunner::PostNonNestableIdleTask(
 void SingleThreadIdleTaskRunner::PostIdleTaskAfterWakeup(
     const tracked_objects::Location& from_here,
     const IdleTask& idle_task) {
+  // Don't signal posting of idle task to the delegate here, wait until the
+  // after-wakeup task posts the real idle task.
   after_wakeup_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SingleThreadIdleTaskRunner::PostIdleTask,
                             weak_scheduler_ptr_, from_here, idle_task));
 }
 
 void SingleThreadIdleTaskRunner::RunTask(IdleTask idle_task) {
-  base::TimeTicks deadline;
-  deadline_supplier_.Run(&deadline);
+  base::TimeTicks deadline = delegate_->WillProcessIdleTask();
   TRACE_EVENT1(tracing_category_, "SingleThreadIdleTaskRunner::RunTask",
                "allotted_time_ms",
                (deadline - base::TimeTicks::Now()).InMillisecondsF());
   idle_task.Run(deadline);
-  bool is_tracing;
-  TRACE_EVENT_CATEGORY_GROUP_ENABLED(tracing_category_, &is_tracing);
-  if (is_tracing && base::TimeTicks::Now() > deadline) {
-    TRACE_EVENT_INSTANT0(tracing_category_,
-                         "SingleThreadIdleTaskRunner::DidOverrunDeadline",
-                         TRACE_EVENT_SCOPE_THREAD);
-  }
+  delegate_->DidProcessIdleTask();
 }
 
 }  // namespace scheduler