[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/budget_pool.h

 // Copyright 2017 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_RENDERER_BUDGET_POOL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_
 
 #include <unordered_set>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "platform/scheduler/base/lazy_now.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace blink {
 namespace scheduler {
 
 class TaskQueue;
 class BudgetPoolController;
+enum class QueueBlockType;
 
 // BudgetPool represents a group of task queues which share a limit
 // on a resource. This limit applies when task queues are already throttled
 // by TaskQueueThrottler.
 class BLINK_PLATFORM_EXPORT BudgetPool {
  public:
   virtual ~BudgetPool();
 
   const char* Name() const;
 
   // Report task run time to the budget pool.
-  virtual void RecordTaskRunTime(base::TimeTicks start_time,
+  virtual void RecordTaskRunTime(TaskQueue* queue,
+                                 base::TimeTicks start_time,
                                  base::TimeTicks end_time) = 0;
 
-  // Retuns earliest time (can be in the past) when the next task can run.
-  virtual base::TimeTicks GetNextAllowedRunTime() = 0;
+  // Returns the earliest time when the next pump can be scheduled to run
+  // new tasks.
+  virtual base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const = 0;
 
-  // Returns true at a task can be run immediately at the given time.
-  virtual bool HasEnoughBudgetToRun(base::TimeTicks now) = 0;
+  // Returns true if a task can run at the given time.
+  virtual bool CanRunTasksAt(base::TimeTicks moment, bool is_wake_up) const = 0;
+
+  // Returns true if tasks can run at any time up to |moment|.
+  virtual bool CanRunTasksUntil(base::TimeTicks now,
+                                base::TimeTicks moment) const = 0;
+
+  // Notifies budget pool that queue has work with desired run time.
+  virtual void OnQueueNextWakeUpChanged(TaskQueue* queue,
+                                        base::TimeTicks now,
+                                        base::TimeTicks desired_run_time) = 0;
+
+  // Notifies budget pool that wakeup has happened.
+  virtual void OnWakeUp(base::TimeTicks now) = 0;
+
+  // Specify how this budget pool should block affected queues.
+  virtual QueueBlockType GetBlockType() const = 0;
 
   // Returns state for tracing.
   virtual void AsValueInto(base::trace_event::TracedValue* state,
                            base::TimeTicks now) const = 0;
 
   // Adds |queue| to given pool. If the pool restriction does not allow
   // a task to be run immediately and |queue| is throttled, |queue| becomes
   // disabled.
   void AddQueue(base::TimeTicks now, TaskQueue* queue);
 
   // Removes |queue| from given pool. If it is throttled, it does not
-  // become enabled immediately, but a call to |PumpThrottledTasks|
-  // is scheduled.
+  // become enabled immediately, but a wake-up is scheduled if needed.
   void RemoveQueue(base::TimeTicks now, TaskQueue* queue);
 
+  // Unlike RemoveQueue, does not schedule a new wake-up for the queue.
+  void UnregisterQueue(TaskQueue* queue);
+
   // Enables this time budget pool. Queues from this pool will be
   // throttled based on their run time.
   void EnableThrottling(LazyNow* now);
 
   // Disables with time budget pool. Queues from this pool will not be
   // throttled based on their run time. A call to |PumpThrottledTasks|
   // will be scheduled to enable this queues back again and respect
   // timer alignment. Internal budget level will not regenerate with time.
   void DisableThrottling(LazyNow* now);
 
   bool IsThrottlingEnabled() const;
 
   // All queues should be removed before calling Close().
   void Close();
 
   // Block all associated queues and schedule them to run when appropriate.
   void BlockThrottledQueues(base::TimeTicks now);
 
  protected:
   BudgetPool(const char* name, BudgetPoolController* budget_pool_controller);
 
   const char* name_;  // NOT OWNED
 
   BudgetPoolController* budget_pool_controller_;
 
   std::unordered_set<TaskQueue*> associated_task_queues_;
   bool is_enabled_;
+
+ private:
+  void DissociateQueue(TaskQueue* queue);

[alex clarke (OOO till 29th), 2017/04/27 10:28:14]

Why do we need this and UnregisterQueue? 

[altimin, 2017/04/27 11:07:41]

I believe that it's confusing to call UnregisterQueue from RemoveQueue, so I
moved out the common code from UnregisterQueue and RemoveQueue to a separate
function (and at this point common code is the same as UnregisterQueue itself,
yes).

 };
 
 // CPUTimeBudgetPool represents a collection of task queues which share a limit
 // on total cpu time.
 class BLINK_PLATFORM_EXPORT CPUTimeBudgetPool : public BudgetPool {
  public:
   CPUTimeBudgetPool(const char* name,
                     BudgetPoolController* budget_pool_controller,
                     base::TimeTicks now);
 
@@ skipping 36 matching lines @@
   // queues even if they are allowed to run with increased budget level.
   void GrantAdditionalBudget(base::TimeTicks now, base::TimeDelta budget_level);
 
   // Set callback which will be called every time when this budget pool
   // is throttled. Throttling duration (time until the queue is allowed
   // to run again) is passed as a parameter to callback.
   void SetReportingCallback(
       base::Callback<void(base::TimeDelta)> reporting_callback);
 
   // BudgetPool implementation:
-  void RecordTaskRunTime(base::TimeTicks start_time,
+  void RecordTaskRunTime(TaskQueue* queue,
+                         base::TimeTicks start_time,
                          base::TimeTicks end_time) final;
-  bool HasEnoughBudgetToRun(base::TimeTicks now) final;
-  base::TimeTicks GetNextAllowedRunTime() final;
+  bool CanRunTasksUntil(base::TimeTicks now, base::TimeTicks until) const final;
+  bool CanRunTasksAt(base::TimeTicks now, bool is_wake_up) const final;
+  base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const final;
+  void OnQueueNextWakeUpChanged(TaskQueue* queue,
+                                base::TimeTicks now,
+                                base::TimeTicks desired_run_time) final;
+  void OnWakeUp(base::TimeTicks now) final;
   void AsValueInto(base::trace_event::TracedValue* state,
                    base::TimeTicks now) const final;
 
+ protected:
+  QueueBlockType GetBlockType() const final;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(TaskQueueThrottlerTest, CPUTimeBudgetPool);
 
   // Advances |last_checkpoint_| to |now| if needed and recalculates
   // budget level.
   void Advance(base::TimeTicks now);
 
   // Increase |current_budget_level_| to satisfy max throttling duration
   // condition if necessary.
   // Decrease |current_budget_level_| to satisfy max budget level
@@ skipping 15 matching lines @@
 
   base::TimeDelta current_budget_level_;
   base::TimeTicks last_checkpoint_;
   double cpu_percentage_;
 
   base::Callback<void(base::TimeDelta)> reporting_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CPUTimeBudgetPool);
 };
 
+// WakeUpBudgetPool represents a collection of task queues which share a limit
+// on total cpu time.
+class BLINK_PLATFORM_EXPORT WakeUpBudgetPool : public BudgetPool {
+ public:
+  WakeUpBudgetPool(const char* name,
+                   BudgetPoolController* budget_pool_controller,
+                   base::TimeTicks now);
+  ~WakeUpBudgetPool() override;
+
+  // Note: this does not have an immediate effect and should be called only
+  // during initialization of a WakeUpBudgetPool.
+  void SetWakeUpRate(double wakeups_per_second);
+
+  // Note: this does not have an immediate effect and should be called only
+  // during initialization of a WakeUpBudgetPool.
+  void SetWakeUpDuration(base::TimeDelta duration);
+
+  // BudgetPool implementation:
+  void RecordTaskRunTime(TaskQueue* queue,
+                         base::TimeTicks start_time,
+                         base::TimeTicks end_time) final;
+  bool CanRunTasksUntil(base::TimeTicks now,
+                        base::TimeTicks moment) const final;
+  bool CanRunTasksAt(base::TimeTicks now, bool is_wake_up) const final;
+  base::TimeTicks GetNextAllowedRunTime(
+      base::TimeTicks desired_run_time) const final;
+  void OnQueueNextWakeUpChanged(TaskQueue* queue,
+                                base::TimeTicks now,
+                                base::TimeTicks desired_run_time) final;
+  void OnWakeUp(base::TimeTicks now) final;
+  void AsValueInto(base::trace_event::TracedValue* state,
+                   base::TimeTicks now) const final;
+
+ protected:
+  QueueBlockType GetBlockType() const final;
+
+ private:
+  base::Optional<base::TimeTicks> NextWakeUp() const;
+
+  double wakeups_per_second_;
+  base::TimeDelta wakeup_duration_;
+
+  base::Optional<base::TimeTicks> last_wakeup_;
+
+  DISALLOW_COPY_AND_ASSIGN(WakeUpBudgetPool);
+};
+
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_