[scheduler] Move TimeBudgetPool to a separate file.

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
index a884b48aeb81be63a156531fe1ce02754be0025a..649aaaa599942167d5bb9896dfd3476d143a8a3c 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
@@ -18,6 +18,7 @@
 #include "platform/scheduler/base/test_time_source.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h"
 #include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
+#include "platform/scheduler/renderer/budget_pool.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "platform/scheduler/renderer/web_view_scheduler_impl.h"
@@ -492,9 +493,8 @@ TEST_F(TaskQueueThrottlerTest, IncrementThenEnableVirtualTime) {
 }
 
 TEST_F(TaskQueueThrottlerTest, TimeBudgetPool) {
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   base::TimeTicks time_zero = clock_->NowTicks();
 
@@ -540,9 +540,8 @@ void ExpensiveTestTask(std::vector<base::TimeTicks>* run_times,
 TEST_F(TaskQueueThrottlerTest, TimeBasedThrottling) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -590,9 +589,8 @@ TEST_F(TaskQueueThrottlerTest, TimeBasedThrottling) {
 TEST_F(TaskQueueThrottlerTest, EnableAndDisableTimeBudgetPool) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
   EXPECT_TRUE(pool->IsThrottlingEnabled());
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
@@ -651,9 +649,8 @@ TEST_F(TaskQueueThrottlerTest, EnableAndDisableTimeBudgetPool) {
 TEST_F(TaskQueueThrottlerTest, ImmediateTasksTimeBudgetThrottling) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -700,9 +697,8 @@ TEST_F(TaskQueueThrottlerTest, TwoQueuesTimeBudgetThrottling) {
   scoped_refptr<TaskQueue> second_queue =
       scheduler_->NewTimerTaskRunner(TaskQueue::QueueType::TEST);
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -735,9 +731,8 @@ TEST_F(TaskQueueThrottlerTest, DisabledTimeBudgetDoesNotAffectThrottledQueues) {
   std::vector<base::TimeTicks> run_times;
   LazyNow lazy_now(clock_.get());
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
   pool->SetTimeBudgetRecoveryRate(lazy_now.Now(), 0.1);
   pool->DisableThrottling(&lazy_now);
 
@@ -764,9 +759,8 @@ TEST_F(TaskQueueThrottlerTest,
        TimeBudgetThrottlingDoesNotAffectUnthrottledQueues) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
 
   LazyNow lazy_now(clock_.get());
@@ -792,9 +786,8 @@ TEST_F(TaskQueueThrottlerTest,
 TEST_F(TaskQueueThrottlerTest, MaxThrottlingDuration) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool(
-          "test", base::nullopt, base::TimeDelta::FromMinutes(1));
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::TimeDelta::FromMinutes(1));
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.001);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -893,9 +886,8 @@ TEST_F(TaskQueueThrottlerTest, ReportThrottling) {
   std::vector<base::TimeTicks> run_times;
   std::vector<base::TimeDelta> reported_throttling_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -934,9 +926,8 @@ TEST_F(TaskQueueThrottlerTest, ReportThrottling) {
 TEST_F(TaskQueueThrottlerTest, GrantAdditionalBudget) {
   std::vector<base::TimeTicks> run_times;
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
 
   pool->SetTimeBudgetRecoveryRate(base::TimeTicks(), 0.1);
   pool->AddQueue(base::TimeTicks(), timer_queue_.get());
@@ -975,9 +966,8 @@ TEST_F(TaskQueueThrottlerTest, EnableAndDisableThrottlingAndTimeBudgets) {
 
   task_queue_throttler_->DisableThrottling();
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
   LazyNow lazy_now(clock_.get());
@@ -1008,9 +998,8 @@ TEST_F(TaskQueueThrottlerTest, AddQueueToBudgetPoolWhenThrottlingDisabled) {
 
   task_queue_throttler_->DisableThrottling();
 
-  TaskQueueThrottler::TimeBudgetPool* pool =
-      task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt,
-                                                  base::nullopt);
+  TimeBudgetPool* pool = task_queue_throttler_->CreateTimeBudgetPool(
+      "test", base::nullopt, base::nullopt);
   task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
 
   mock_task_runner_->RunUntilTime(base::TimeTicks() +