[scheduler] Implement time-based cpu throttling.

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

 // 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.
 
 #include "platform/scheduler/base/task_queue_impl.h"
 
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
@@ skipping 496 matching lines @@
       !main_thread_only().immediate_work_queue->Empty()) {
     return false;
   }
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().immediate_incoming_queue.empty() &&
          main_thread_only().delayed_incoming_queue.empty();
 }
 
 bool TaskQueueImpl::HasPendingImmediateWork() const {
+  LazyNow lazy_now = main_thread_only().time_domain->CreateLazyNow();
+  return HasPendingImmediateWork(&lazy_now);
+}
+
+bool TaskQueueImpl::HasPendingImmediateWork(LazyNow* lazy_now) const {
   // Any work queue tasks count as immediate work.
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return true;
   }
 
   // Tasks on |delayed_incoming_queue| that could run now, count as
   // immediate work.
   if (!main_thread_only().delayed_incoming_queue.empty() &&
       main_thread_only().delayed_incoming_queue.begin()->delayed_run_time <=
-          main_thread_only().time_domain->CreateLazyNow().Now()) {
+          lazy_now->Now()) {
     return true;
   }
 
   // Finally tasks on |immediate_incoming_queue| count as immediate work.
   base::AutoLock lock(any_thread_lock_);
   return !any_thread().immediate_incoming_queue.empty();
 }
 
+base::Optional<base::TimeTicks> TaskQueueImpl::GetNextScheduledWakeUp() {
+  LazyNow lazy_now = main_thread_only().time_domain->CreateLazyNow();
+  MoveReadyDelayedTasksToDelayedWorkQueue(&lazy_now);
+
+  if (main_thread_only().delayed_incoming_queue.empty())
+    return base::nullopt;
+
+  return main_thread_only().delayed_incoming_queue.begin()->delayed_run_time;
+}
+
+base::Optional<base::TimeTicks> TaskQueueImpl::GetNextTaskRunTime() {
+  LazyNow lazy_now = main_thread_only().time_domain->CreateLazyNow();
+  MoveReadyDelayedTasksToDelayedWorkQueue(&lazy_now);
+
+  if (HasPendingImmediateWork())
+    return lazy_now.Now();
+
+  return GetNextScheduledWakeUp();
+}
+
 void TaskQueueImpl::MoveReadyDelayedTasksToDelayedWorkQueue(LazyNow* lazy_now) {
   // Enqueue all delayed tasks that should be running now.
   while (!main_thread_only().delayed_incoming_queue.empty()) {
     DelayedRunTimeQueue::iterator next_task =
         main_thread_only().delayed_incoming_queue.begin();
     if (next_task->delayed_run_time > lazy_now->Now())
       break;
     // TODO(alexclarke): Use extract() when C++17 is allowed.
     Task& task = const_cast<Task&>(*next_task);
     task.set_enqueue_order(
@@ skipping 311 matching lines @@
   state->SetBoolean("is_high_res", task.is_high_res);
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink