[scheduler] Initial budget for time-based throttling.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.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_RENDERER_THROTTLING_HELPER_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_THROTTLING_HELPER_H_
 
 #include <set>
 #include <unordered_map>
 
@@ skipping 38 matching lines @@
   // TimeBudgetPool represents a group of task queues which share a limit
   // on execution time. This limit applies when task queues are already
   // throttled by TaskQueueThrottler.
   class BLINK_PLATFORM_EXPORT TimeBudgetPool {
    public:
     ~TimeBudgetPool();
 
     // 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 SetTimeBudget(base::TimeTicks now, double cpu_percentage);
+    void SetTimeBudgetRecoveryRate(base::TimeTicks now, double cpu_percentage);
 
     // 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.
     void RemoveQueue(base::TimeTicks now, TaskQueue* queue);
 
     void RecordTaskRunTime(base::TimeTicks start_time,
                            base::TimeTicks end_time);
 
     // 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;
 
+    // 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);
+
     const char* Name() const;
 
     // 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);
 
     // All queues should be removed before calling Close().
     void Close();
@@ skipping 182 matching lines @@
 
   base::WeakPtrFactory<TaskQueueThrottler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueThrottler);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_THROTTLING_HELPER_H_