[scheduler] Support setting maximal throttling duration

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 51 matching lines @@
     // 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::TimeDelta task_run_time);
+    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;
 
     const char* Name() const;
 
     // All queues should be removed before calling Close().
     void Close();
 
    private:
     friend class TaskQueueThrottler;
 
     FRIEND_TEST_ALL_PREFIXES(TaskQueueThrottlerTest, TimeBudgetPool);
 
     TimeBudgetPool(const char* name,
                    TaskQueueThrottler* task_queue_throttler,
-                   base::TimeTicks now);
+                   base::TimeTicks now,
+                   base::Optional<base::TimeDelta> max_budget_level,
+                   base::Optional<base::TimeDelta> max_throttling_duration);
 
     bool HasEnoughBudgetToRun(base::TimeTicks now);
     base::TimeTicks GetNextAllowedRunTime();
 
     // Advances |last_checkpoint_| to |now| if needed and recalculates
     // budget level.
     void Advance(base::TimeTicks now);
 
     // Returns state for tracing.
     void AsValueInto(base::trace_event::TracedValue* state,
                      base::TimeTicks now) const;
 
     // Disable all associated throttled queues.
     void BlockThrottledQueues(base::TimeTicks now);
 
+    // Increase current_budget_level_ to satisfy max throttling duration
+    // condition if necessary.
+    void EnforceMaximalThrottlingDuration();
+
     const char* name_;  // NOT OWNED
 
     TaskQueueThrottler* task_queue_throttler_;
 
+    // Max budget level which we can accrue.
+    // Tasks will be allowed to run for this time before being throttled
+    // after a very long period of inactivity.
+    base::Optional<base::TimeDelta> max_budget_level_;
+    // Max throttling duration places a lower limit on time budget level,
+    // ensuring that one long task does not cause extremely long throttling.
+    // Note that this is not the guarantee that every task will run
+    // after desired run time + max throttling duration, but a guarantee
+    // that at least one task will be run every max_throttling_duration.
+    base::Optional<base::TimeDelta> max_throttling_duration_;
+
     base::TimeDelta current_budget_level_;
-    base::TimeDelta max_budget_level_;
     base::TimeTicks last_checkpoint_;
     double cpu_percentage_;
     bool is_enabled_;
 
     std::unordered_set<TaskQueue*> associated_task_queues_;
 
     DISALLOW_COPY_AND_ASSIGN(TimeBudgetPool);
   };
 
   // TODO(altimin): Do not pass tracing category as const char*,
@@ skipping 99 matching lines @@
   void MaybeDeleteQueueMetadata(TaskQueueMap::iterator it);
 
   TaskQueueMap queue_details_;
   base::Callback<void(TaskQueue*)> forward_immediate_work_callback_;
   scoped_refptr<TaskQueue> task_runner_;
   RendererSchedulerImpl* renderer_scheduler_;  // NOT OWNED
   base::TickClock* tick_clock_;                // NOT OWNED
   const char* tracing_category_;               // NOT OWNED
   std::unique_ptr<ThrottledTimeDomain> time_domain_;
 
+  base::Optional<base::TimeDelta> max_budget_level_;
+  base::Optional<base::TimeDelta> max_throttling_duration_;
+
   CancelableClosureHolder pump_throttled_tasks_closure_;
   base::Optional<base::TimeTicks> pending_pump_throttled_tasks_runtime_;
   bool virtual_time_;
 
   std::unordered_map<TimeBudgetPool*, std::unique_ptr<TimeBudgetPool>>
       time_budget_pools_;
 
   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_