[content]: Add support for long idle times in the Blink Scheduler.

content/renderer/scheduler/task_queue_manager.cc

Index: content/renderer/scheduler/task_queue_manager.cc
diff --git a/content/renderer/scheduler/task_queue_manager.cc b/content/renderer/scheduler/task_queue_manager.cc
index 0b460d4bad831870d8d50a02151e0e6ba7cbd441..71f350e026307b1313648d47fb1e8fa882f8225c 100644
--- a/content/renderer/scheduler/task_queue_manager.cc
+++ b/content/renderer/scheduler/task_queue_manager.cc
@@ -42,6 +42,8 @@ class TaskQueue : public base::SingleThreadTaskRunner {
   void SetPumpPolicy(TaskQueueManager::PumpPolicy pump_policy);
   void PumpQueue();
 
+  void GetNextPendingDelayedTask(base::TimeTicks* next_pending_delayed_task);
+
   bool UpdateWorkQueue(base::TimeTicks* next_pending_delayed_task,
                        const base::PendingTask* previous_task);
   base::PendingTask TakeTaskFromWorkQueue();
@@ -76,6 +78,8 @@ class TaskQueue : public base::SingleThreadTaskRunner {
   bool TaskIsOlderThanQueuedTasks(const base::PendingTask* task);
   bool ShouldAutoPumpQueueLocked(const base::PendingTask* previous_task);
   void EnqueueTaskLocked(const base::PendingTask& pending_task);
+  void GetNextPendingDelayedTaskLocked(
+      base::TimeTicks* next_pending_delayed_task);
 
   void TraceQueueSize(bool is_locked) const;
   static const char* PumpPolicyToString(
@@ -186,6 +190,21 @@ bool TaskQueue::ShouldAutoPumpQueueLocked(
   return true;
 }
 
+void TaskQueue::GetNextPendingDelayedTask(
+    base::TimeTicks* next_pending_delayed_task) {
+  base::AutoLock lock(lock_);
+  GetNextPendingDelayedTaskLocked(next_pending_delayed_task);
+}
+
+void TaskQueue::GetNextPendingDelayedTaskLocked(

[picksi, 2015/03/04 10:43:23]

Can this deal better with the delayed_task_run_times being empty? It's silent
"failure" could lead to trouble. Maybe it should return a success bool?

[rmcilroy, 2015/03/04 14:23:12]

Done.

+    base::TimeTicks* next_pending_delayed_task) {
+  lock_.AssertAcquired();
+  if (!delayed_task_run_times_.empty()) {
+    *next_pending_delayed_task =
+        std::min(*next_pending_delayed_task, delayed_task_run_times_.top());
+  }
+}
+
 bool TaskQueue::UpdateWorkQueue(
     base::TimeTicks* next_pending_delayed_task,
     const base::PendingTask* previous_task) {
@@ -194,10 +213,7 @@ bool TaskQueue::UpdateWorkQueue(
 
   {
     base::AutoLock lock(lock_);
-    if (!delayed_task_run_times_.empty()) {
-      *next_pending_delayed_task =
-          std::min(*next_pending_delayed_task, delayed_task_run_times_.top());
-    }
+    GetNextPendingDelayedTaskLocked(next_pending_delayed_task);
     if (!ShouldAutoPumpQueueLocked(previous_task))
       return false;
     work_queue_.Swap(&incoming_queue_);
@@ -388,6 +404,21 @@ bool TaskQueueManager::IsQueueEmpty(size_t queue_index) const {
   return queue->IsQueueEmpty();
 }
 
+base::TimeTicks TaskQueueManager::NextPendingDelayedTask() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  base::TimeTicks next_pending_delayed_task(
+      base::TimeTicks::FromInternalValue(kMaxTimeTicks));
+  for (auto& queue : queues_) {
+    queue->GetNextPendingDelayedTask(&next_pending_delayed_task);
+  }
+
+  if (next_pending_delayed_task ==

[picksi, 2015/03/04 10:43:22]

If I understand the code, this check for unchanged-time looks fragile to me
(i.e. what would happen if GetNextPendingDelayedTask returned kMaxTimeTicks
coincidentally?).

[rmcilroy, 2015/03/04 14:23:12]

Done (although we don't really need to worry about this ever happening until a
task is posted for Sun, 4 December 292,277,026,596 ;)).

[picksi, 2015/03/04 16:29:05]

I suppose the heat death of the universe will be a more pressing issue than a
glitch in some ancient software, but I definitely prefer the way it looks now!

+      base::TimeTicks::FromInternalValue(kMaxTimeTicks))
+    return base::TimeTicks();
+
+  return next_pending_delayed_task;
+}
+
 void TaskQueueManager::SetPumpPolicy(size_t queue_index,
                                      PumpPolicy pump_policy) {
   DCHECK(main_thread_checker_.CalledOnValidThread());