[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 323 matching lines @@
       main_thread_only().delayed_incoming_queue.top().delayed_run_time <=
           main_thread_only().time_domain->CreateLazyNow().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() {
+  if (main_thread_only().delayed_incoming_queue.empty())
+    return base::nullopt;
+
+  return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
+}
+
 void TaskQueueImpl::WakeUpForDelayedWork(LazyNow* lazy_now) {
   // Enqueue all delayed tasks that should be running now, skipping any that
   // have been canceled.
   while (!main_thread_only().delayed_incoming_queue.empty()) {
     Task& task =
         const_cast<Task&>(main_thread_only().delayed_incoming_queue.top());
     if (task.task.IsCancelled()) {
       main_thread_only().delayed_incoming_queue.pop();
       continue;
     }
@@ skipping 155 matching lines @@
     const base::PendingTask& pending_task) {
   DCHECK(should_notify_observers_);
   FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver,
                     main_thread_only().task_observers,
                     DidProcessTask(pending_task));
   if (main_thread_only().blame_context)
     main_thread_only().blame_context->Leave();
 }
 
 void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
-  base::AutoLock lock(any_thread_lock_);
-  DCHECK(time_domain);
-  // NOTE this is similar to checking |any_thread().task_queue_manager| but the
-  // TaskQueueSelectorTests constructs TaskQueueImpl directly with a null
-  // task_queue_manager.  Instead we check |any_thread().time_domain| which is
-  // another way of asserting that UnregisterTaskQueue has not been called.
-  DCHECK(any_thread().time_domain);
-  if (!any_thread().time_domain)
-    return;
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  if (time_domain == main_thread_only().time_domain)
-    return;
+  {
+    base::AutoLock lock(any_thread_lock_);
+    DCHECK(time_domain);
+    // NOTE this is similar to checking |any_thread().task_queue_manager| but
+    // the TaskQueueSelectorTests constructs TaskQueueImpl directly with a null
+    // task_queue_manager.  Instead we check |any_thread().time_domain| which is
+    // another way of asserting that UnregisterTaskQueue has not been called.
+    DCHECK(any_thread().time_domain);
+    if (!any_thread().time_domain)
+      return;
+    DCHECK(main_thread_checker_.CalledOnValidThread());
+    if (time_domain == main_thread_only().time_domain)
+      return;
 
+    any_thread().time_domain = time_domain;
+  }
+  // We rely here on TimeDomain::MigrateQueue being thread-safe to use with
+  // TimeDomain::Register/UnregisterAsUpdatableTaskQueue.
   main_thread_only().time_domain->MigrateQueue(this, time_domain);
   main_thread_only().time_domain = time_domain;
-  any_thread().time_domain = time_domain;
 }
 
 TimeDomain* TaskQueueImpl::GetTimeDomain() const {
   if (base::PlatformThread::CurrentId() == thread_id_)
     return main_thread_only().time_domain;
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().time_domain;
 }
 
@@ skipping 140 matching lines @@
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink