[scheduler] Untangle BudgetPool from TaskQueueThrottler.

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"
@@ skipping 43 matching lines @@
   // will be scheduled to enable this queues back again and respect
   // timer alignment. Internal budget level will not regenerate with time.
   virtual void DisableThrottling(LazyNow* now) = 0;
 
   virtual bool IsThrottlingEnabled() const = 0;
 
   // Report task run time to the budget pool.
   virtual void RecordTaskRunTime(base::TimeTicks start_time,
                                  base::TimeTicks end_time) = 0;
 
+  // Call TaskQueueThrottler::BlockThrottledQueue for all relevant queues.

[Sami, 2017/03/14 18:43:00]

This is an abstract interface with no obvious ties to TaskQueueThrottler -- can
we describe what this method does on a higher level without referring to TQT?

[altimin, 2017/03/14 20:04:28]

Done.

+  virtual void BlockThrottledQueues(base::TimeTicks now) = 0;
+
   // All queues should be removed before calling Close().
   virtual void Close() = 0;
 
   // Retuns earliest time (can be in the past) when the next task can run.
   virtual base::TimeTicks GetNextAllowedRunTime() = 0;
 
   // Returns true at a task can be run immediately at the given time.
   virtual bool HasEnoughBudgetToRun(base::TimeTicks now) = 0;
 
   // Returns state for tracing.
   virtual void AsValueInto(base::trace_event::TracedValue* state,
                            base::TimeTicks now) const = 0;
 };
 
 // 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,
+                    TaskQueueThrottler* task_queue_throttler,
+                    base::TimeTicks now,
+                    base::Optional<base::TimeDelta> max_budget_level,
+                    base::Optional<base::TimeDelta> max_throttling_duration);
+
   ~CPUTimeBudgetPool();
 
   // Throttle task queues from this time budget pool if tasks are running
   // for more than |cpu_percentage| per cent of wall time.
   // This function does not affect internal time budget level.
   void SetTimeBudgetRecoveryRate(base::TimeTicks now, double cpu_percentage);
 
   // Increase budget level by given value. This function DOES NOT unblock
   // 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:
   const char* Name() const override;
   void AddQueue(base::TimeTicks now, TaskQueue* queue) override;
   void RemoveQueue(base::TimeTicks now, TaskQueue* queue) override;
   void EnableThrottling(LazyNow* now) override;
   void DisableThrottling(LazyNow* now) override;
   bool IsThrottlingEnabled() const override;
   void RecordTaskRunTime(base::TimeTicks start_time,
                          base::TimeTicks end_time) override;
+  void BlockThrottledQueues(base::TimeTicks now) override;
   void Close() override;
   bool HasEnoughBudgetToRun(base::TimeTicks now) override;
   base::TimeTicks GetNextAllowedRunTime() override;
   void AsValueInto(base::trace_event::TracedValue* state,
                    base::TimeTicks now) const override;
 
  private:
-  friend class TaskQueueThrottler;
-
   FRIEND_TEST_ALL_PREFIXES(TaskQueueThrottlerTest, CPUTimeBudgetPool);
 
-  CPUTimeBudgetPool(const char* name,
-                    TaskQueueThrottler* task_queue_throttler,
-                    base::TimeTicks now,
-                    base::Optional<base::TimeDelta> max_budget_level,
-                    base::Optional<base::TimeDelta> max_throttling_duration);
-
   // Advances |last_checkpoint_| to |now| if needed and recalculates
   // budget level.
   void Advance(base::TimeTicks now);
 
-  // Disable all associated throttled queues.
-  void BlockThrottledQueues(base::TimeTicks now);
-
   // Increase |current_budget_level_| to satisfy max throttling duration
   // condition if necessary.
   // Decrease |current_budget_level_| to satisfy max budget level
   // condition if necessary.
   void EnforceBudgetLevelRestrictions();
 
   const char* name_;  // NOT OWNED
 
   TaskQueueThrottler* task_queue_throttler_;
 
@@ skipping 17 matching lines @@
 
   base::Callback<void(base::TimeDelta)> reporting_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CPUTimeBudgetPool);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_BUDGET_POOL_H_