[scheduler] FrameSchedulerImpl::Create

Remove PageSchedulerImpl::CreateFrameSchedulerImpl in favour of
FrameSchedulerImpl::Create and
PageSchedulerImpl::RegisterFrameSchedulerImpl.
This will allow to create subclasses of FrameSchedulerImpl in tests.

R=alexclarke@chromium.org

Change-Id: I401596bcae945a0039a8737cf795c13a19dd35e2
Reviewed-on: https://chromium-review.googlesource.com/1099071
Commit-Queue: Alexander Timin <altimin@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#567272}

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc

@@ -102,6 +102,17 @@ FrameSchedulerImpl::PauseSubresourceLoadingHandleImpl::
     frame_scheduler_->RemovePauseSubresourceLoadingHandle();
 }
 
+std::unique_ptr<FrameSchedulerImpl> FrameSchedulerImpl::Create(
+    PageSchedulerImpl* parent_page_scheduler,
+    base::trace_event::BlameContext* blame_context,
+    FrameScheduler::FrameType frame_type) {
+  std::unique_ptr<FrameSchedulerImpl> frame_scheduler(
+      new FrameSchedulerImpl(parent_page_scheduler->GetMainThreadScheduler(),
+                             parent_page_scheduler, blame_context, frame_type));
+  parent_page_scheduler->RegisterFrameSchedulerImpl(frame_scheduler.get());
+  return frame_scheduler;
+}
+
 FrameSchedulerImpl::FrameSchedulerImpl(
     MainThreadSchedulerImpl* main_thread_scheduler,
     PageSchedulerImpl* parent_page_scheduler,

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.h

@@ -51,11 +51,10 @@ class PageSchedulerImplTest;
 
 class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
  public:
-  FrameSchedulerImpl(MainThreadSchedulerImpl* main_thread_scheduler,
-                     PageSchedulerImpl* parent_page_scheduler,
-                     base::trace_event::BlameContext* blame_context,
-                     FrameScheduler::FrameType frame_type);
-
+  static std::unique_ptr<FrameSchedulerImpl> Create(
+      PageSchedulerImpl* page_scheduler,
+      base::trace_event::BlameContext* blame_context,
+      FrameScheduler::FrameType frame_type);
   ~FrameSchedulerImpl() override;
 
   // FrameScheduler implementation:
@@ -106,6 +105,11 @@ class PLATFORM_EXPORT FrameSchedulerImpl : public FrameScheduler {
       MainThreadTaskQueue* task_queue) const;
 
  protected:
+  FrameSchedulerImpl(MainThreadSchedulerImpl* main_thread_scheduler,
+                     PageSchedulerImpl* parent_page_scheduler,
+                     base::trace_event::BlameContext* blame_context,
+                     FrameScheduler::FrameType frame_type);
+
   // This will construct a subframe that is not linked to any main thread or
   // page scheduler. Should be used only for testing purposes.
   FrameSchedulerImpl();

third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl_unittest.cc

@@ -48,8 +48,8 @@ class FrameSchedulerImplTest : public testing::Test {
             task_environment_.GetMockTickClock()),
         base::nullopt));
     page_scheduler_.reset(new PageSchedulerImpl(nullptr, scheduler_.get()));
-    frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-        nullptr, FrameScheduler::FrameType::kSubframe);
+    frame_scheduler_ = FrameSchedulerImpl::Create(
+        page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kSubframe);
   }
 
   void TearDown() override {
@@ -954,8 +954,8 @@ TEST_F(FrameSchedulerImplTest, kLowPriorityForThrottleableTaskFeatureEnabled) {
   EXPECT_EQ(UnpausableTaskQueue()->GetQueuePriority(),
             TaskQueue::QueuePriority::kNormalPriority);
 
-  frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-      nullptr, FrameScheduler::FrameType::kMainFrame);
+  frame_scheduler_ = FrameSchedulerImpl::Create(
+      page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kMainFrame);
 
   // Main Frame Task Queues.
   EXPECT_EQ(LoadingTaskQueue()->GetQueuePriority(),
@@ -1019,8 +1019,8 @@ TEST_F(FrameSchedulerImplTest,
   feature_list_.InitWithFeatures(
       {kLowPriorityForThrottleableTask, kExperimentOnlyWhenLoading}, {});
 
-  frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-      nullptr, FrameScheduler::FrameType::kMainFrame);
+  frame_scheduler_ = FrameSchedulerImpl::Create(
+      page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kMainFrame);
 
   // Main thread is in the loading use case.
   scheduler_->DidStartProvisionalLoad(true);

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc

@@ -301,8 +301,8 @@ class MainThreadSchedulerImplTest : public testing::Test {
 
     page_scheduler_ =
         std::make_unique<PageSchedulerImpl>(nullptr, scheduler_.get());
-    main_frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-        nullptr, FrameScheduler::FrameType::kMainFrame);
+    main_frame_scheduler_ = FrameSchedulerImpl::Create(
+        page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kMainFrame);
 
     loading_task_runner_ = main_frame_scheduler_->LoadingTaskQueue();
     loading_control_task_runner_ =
@@ -3465,8 +3465,8 @@ TEST_F(MainThreadSchedulerImplTest, EnableVirtualTimeAfterThrottling) {
   scheduler_->AddPageScheduler(page_scheduler.get());
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   TaskQueue* timer_tq = ThrottleableTaskQueue(frame_scheduler.get()).get();
 
@@ -3554,8 +3554,8 @@ TEST_F(MainThreadSchedulerImplTest, Tracing) {
   scheduler_->AddPageScheduler(page_scheduler1.get());
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler1->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler1.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   std::unique_ptr<PageSchedulerImpl> page_scheduler2 =
       base::WrapUnique(new PageSchedulerImpl(nullptr, scheduler_.get()));

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.cc

@@ -261,21 +261,17 @@ void PageSchedulerImpl::SetIsMainFrameLocal(bool is_local) {
   is_main_frame_local_ = is_local;
 }
 
-std::unique_ptr<FrameSchedulerImpl> PageSchedulerImpl::CreateFrameSchedulerImpl(
-    base::trace_event::BlameContext* blame_context,
-    FrameScheduler::FrameType frame_type) {
+void PageSchedulerImpl::RegisterFrameSchedulerImpl(
+    FrameSchedulerImpl* frame_scheduler) {
   MaybeInitializeBackgroundCPUTimeBudgetPool();
-  std::unique_ptr<FrameSchedulerImpl> frame_scheduler(new FrameSchedulerImpl(
-      main_thread_scheduler_, this, blame_context, frame_type));
+  frame_schedulers_.insert(frame_scheduler);
   frame_scheduler->UpdatePolicy();
-  frame_schedulers_.insert(frame_scheduler.get());
-  return frame_scheduler;
 }
 
 std::unique_ptr<blink::FrameScheduler> PageSchedulerImpl::CreateFrameScheduler(
     blink::BlameContext* blame_context,
     FrameScheduler::FrameType frame_type) {
-  return CreateFrameSchedulerImpl(blame_context, frame_type);
+  return FrameSchedulerImpl::Create(this, blame_context, frame_type);
 }
 
 void PageSchedulerImpl::Unregister(FrameSchedulerImpl* frame_scheduler) {
@@ -558,6 +554,10 @@ void PageSchedulerImpl::SetMaxVirtualTimeTaskStarvationCount(
       max_task_starvation_count);
 }
 
+MainThreadSchedulerImpl* PageSchedulerImpl::GetMainThreadScheduler() const {
+  return main_thread_scheduler_;
+}
+
 ukm::UkmRecorder* PageSchedulerImpl::GetUkmRecorder() {
   if (!delegate_)
     return nullptr;

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h

@@ -91,9 +91,9 @@ class PLATFORM_EXPORT PageSchedulerImpl : public PageScheduler {
   bool IsThrottled() const;
   bool KeepActive() const;
 
-  std::unique_ptr<FrameSchedulerImpl> CreateFrameSchedulerImpl(
-      base::trace_event::BlameContext*,
-      FrameScheduler::FrameType);
+  void RegisterFrameSchedulerImpl(FrameSchedulerImpl* frame_scheduler);
+
+  MainThreadSchedulerImpl* GetMainThreadScheduler() const;
 
   void Unregister(FrameSchedulerImpl*);
   void OnNavigation();

third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl_unittest.cc

@@ -60,8 +60,8 @@ class PageSchedulerImplTest : public testing::Test {
             nullptr, test_task_runner_, test_task_runner_->GetMockTickClock()),
         base::nullopt));
     page_scheduler_.reset(new PageSchedulerImpl(nullptr, scheduler_.get()));
-    frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-        nullptr, FrameScheduler::FrameType::kSubframe);
+    frame_scheduler_ = FrameSchedulerImpl::Create(
+        page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kSubframe);
   }
 
   void TearDown() override {
@@ -296,8 +296,8 @@ TEST_F(PageSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
   std::unique_ptr<PageSchedulerImpl> page_scheduler2(
       new PageSchedulerImpl(nullptr, scheduler_.get()));
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler2 =
-      page_scheduler2->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler2.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   page_scheduler_->SetPageVisible(true);
   page_scheduler2->SetPageVisible(false);
@@ -548,8 +548,8 @@ TEST_F(PageSchedulerImplTest, VirtualTimeSettings_NewFrameScheduler) {
   page_scheduler_->EnableVirtualTime();
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler_->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   ThrottleableTaskQueueForScheduler(frame_scheduler.get())
       ->PostDelayedTask(
@@ -578,9 +578,8 @@ base::OnceClosure MakeDeletionTask(T* obj) {
 TEST_F(PageSchedulerImplTest, DeleteFrameSchedulers_InTask) {
   for (int i = 0; i < 10; i++) {
     FrameSchedulerImpl* frame_scheduler =
-        page_scheduler_
-            ->CreateFrameSchedulerImpl(nullptr,
-                                       FrameScheduler::FrameType::kSubframe)
+        FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                   FrameScheduler::FrameType::kSubframe)
             .release();
     ThrottleableTaskQueueForScheduler(frame_scheduler)
         ->PostDelayedTask(FROM_HERE, MakeDeletionTask(frame_scheduler),
@@ -599,9 +598,8 @@ TEST_F(PageSchedulerImplTest, DeleteThrottledQueue_InTask) {
   page_scheduler_->SetPageVisible(false);
 
   FrameSchedulerImpl* frame_scheduler =
-      page_scheduler_
-          ->CreateFrameSchedulerImpl(nullptr,
-                                     FrameScheduler::FrameType::kSubframe)
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe)
           .release();
   scoped_refptr<TaskQueue> timer_task_queue =
       ThrottleableTaskQueueForScheduler(frame_scheduler);
@@ -653,8 +651,8 @@ TEST_F(PageSchedulerImplTest,
       VirtualTimePolicy::kDeterministicLoading);
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler_->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   {
     WebScopedVirtualTimePauser virtual_time_pauser =
@@ -720,8 +718,8 @@ TEST_F(PageSchedulerImplTest,
   base::TimeTicks time_second_task;
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler_->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   // Pauses and unpauses virtual time, thereby advancing virtual time by an
   // additional 10ms due to WebScopedVirtualTimePauser's delay.
@@ -756,8 +754,8 @@ TEST_F(PageSchedulerImplTest,
       VirtualTimePolicy::kDeterministicLoading);
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler_->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   WebScopedVirtualTimePauser virtual_time_pauser1 =
       frame_scheduler->CreateWebScopedVirtualTimePauser(
@@ -795,8 +793,8 @@ TEST_F(PageSchedulerImplTest, PauseTimersWhileVirtualTimeIsPaused) {
   std::vector<int> run_order;
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      page_scheduler_->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler_.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
   page_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
   page_scheduler_->EnableVirtualTime();
 
@@ -1077,8 +1075,8 @@ TEST_F(PageSchedulerImplTest, BackgroundTimerThrottling) {
   EXPECT_FALSE(page_scheduler_->IsThrottled());
 
   std::vector<base::TimeTicks> run_times;
-  frame_scheduler_ = page_scheduler_->CreateFrameSchedulerImpl(
-      nullptr, FrameScheduler::FrameType::kSubframe);
+  frame_scheduler_ = FrameSchedulerImpl::Create(
+      page_scheduler_.get(), nullptr, FrameScheduler::FrameType::kSubframe);
   page_scheduler_->SetPageVisible(true);
   EXPECT_FALSE(page_scheduler_->IsThrottled());
 
@@ -1143,11 +1141,11 @@ TEST_F(PageSchedulerImplTest, OpenWebSocketExemptsFromBudgetThrottling) {
   std::vector<base::TimeTicks> run_times;
 
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler1 =
-      page_scheduler->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
   std::unique_ptr<FrameSchedulerImpl> frame_scheduler2 =
-      page_scheduler->CreateFrameSchedulerImpl(
-          nullptr, FrameScheduler::FrameType::kSubframe);
+      FrameSchedulerImpl::Create(page_scheduler.get(), nullptr,
+                                 FrameScheduler::FrameType::kSubframe);
 
   page_scheduler->SetPageVisible(false);
 

third_party/blink/renderer/platform/scheduler/worker/worker_scheduler_proxy_unittest.cc

@@ -122,9 +122,10 @@ class WorkerSchedulerProxyTest : public testing::Test {
         page_scheduler_(
             std::make_unique<PageSchedulerImpl>(nullptr,
                                                 main_thread_scheduler_.get())),
-        frame_scheduler_(page_scheduler_->CreateFrameSchedulerImpl(
-            nullptr,
-            FrameScheduler::FrameType::kMainFrame)) {
+        frame_scheduler_(
+            FrameSchedulerImpl::Create(page_scheduler_.get(),
+                                       nullptr,
+                                       FrameScheduler::FrameType::kMainFrame)) {
     // Null clock triggers some assertions.
     task_environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(5));
   }