[scheduler] Implement time-based cpu throttling.

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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 THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 131 matching lines @@
                                   base::TimeDelta delay) override;
   TaskHandle PostCancellableDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
       base::TimeDelta delay) override;
   bool CancelTask(const TaskHandle& handle) override;
   void SetQueueEnabled(bool enabled) override;
   bool IsQueueEnabled() const override;
   bool IsEmpty() const override;
   bool HasPendingImmediateWork() const override;
+  base::Optional<base::TimeTicks> GetNextScheduledWakeUp() override;
+  base::Optional<base::TimeTicks> GetNextTaskRunTime() override;

[alex clarke (OOO till 29th), 2016/09/12 17:45:26]

I'm fine with adding GetNextScheduledWakeUp but I'm not keen on
GetNextTaskRunTime being part of the TaskQueue API for these reasons:

1. It's too similar to GetNextScheduledWakeUp.  How would you know which to
call?
2. You can simulate it with HasPendingImmediateWork() plus
GetNextScheduledWakeUp()

I'd suggest moving the logic into a helper inside TaskQueueThrottler.

[altimin, 2016/09/14 11:23:15]

I added a comment about this in TaskQueue itself, copying it here:

Difference is that GetNextTaskRunTime behaves "atomically" i.e.
it avoids problem when task becomes ready immediately after
HasPendingImmediateWork.

   void SetQueuePriority(QueuePriority priority) override;
   QueuePriority GetQueuePriority() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
   void SetTimeDomain(TimeDomain* time_domain) override;
   TimeDomain* GetTimeDomain() const override;
   void SetBlameContext(base::trace_event::BlameContext* blame_context) override;
   void InsertFence() override;
   void RemoveFence() override;
@@ skipping 124 matching lines @@
   bool BlockedByFenceLocked() const;
 
   void TraceQueueSize(bool is_locked) const;
   static void QueueAsValueInto(const ComparatorQueue& queue,
                                base::trace_event::TracedValue* state);
   static void QueueAsValueInto(const DelayedRunTimeQueue& queue,
                                base::trace_event::TracedValue* state);
   static void TaskAsValueInto(const Task& task,
                               base::trace_event::TracedValue* state);
 
+  // Same as public version, but uses given LazyNow.
+  bool HasPendingImmediateWork(LazyNow* lazy_now) const;
+
   const base::PlatformThreadId thread_id_;
 
   mutable base::Lock any_thread_lock_;
   AnyThread any_thread_;
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
@@ skipping 20 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_