1 files changed, 54 insertions, 24 deletions

diff --git a/chromium/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc b/chromium/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
index 006a901f95a..56a4eb6f6e9 100644
--- a/chromium/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
+++ b/chromium/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
@@ -444,13 +444,23 @@ class MainThreadSchedulerImplTest : public testing::Test {
 
     default_task_runner_ =
         scheduler_->DefaultTaskQueue()->GetTaskRunnerWithDefaultTaskType();
-    compositor_task_runner_ =
-        scheduler_->CompositorTaskQueue()->GetTaskRunnerWithDefaultTaskType();
+    if (!scheduler_->scheduling_settings()
+             .mbi_compositor_task_runner_per_agent_scheduling_group) {
+      compositor_task_runner_ =
+          scheduler_->CompositorTaskQueue()->GetTaskRunnerWithDefaultTaskType();
+    }
     idle_task_runner_ = scheduler_->IdleTaskRunner();
     v8_task_runner_ =
         scheduler_->V8TaskQueue()->GetTaskRunnerWithDefaultTaskType();
 
-    agent_group_scheduler_ = scheduler_->CreateAgentGroupScheduler();
+    agent_group_scheduler_ = std::unique_ptr<AgentGroupSchedulerImpl>(
+        static_cast<AgentGroupSchedulerImpl*>(
+            scheduler_->CreateAgentGroupScheduler().release()));
+    if (scheduler_->scheduling_settings()
+            .mbi_compositor_task_runner_per_agent_scheduling_group) {
+      compositor_task_runner_ = agent_group_scheduler_->CompositorTaskQueue()
+                                    ->GetTaskRunnerWithDefaultTaskType();
+    }
     page_scheduler_ = std::make_unique<NiceMock<MockPageSchedulerImpl>>(
         scheduler_.get(),
         static_cast<AgentGroupSchedulerImpl&>(*agent_group_scheduler_));
@@ -474,6 +484,15 @@ class MainThreadSchedulerImplTest : public testing::Test {
         blink::TaskType::kInternalHighPriorityLocalFrame);
   }
 
+  MainThreadTaskQueue* compositor_task_queue() {
+    if (scheduler_->scheduling_settings()
+            .mbi_compositor_task_runner_per_agent_scheduling_group) {
+      return agent_group_scheduler_->CompositorTaskQueue().get();
+    } else {
+      return scheduler_->CompositorTaskQueue().get();
+    }
+  }
+
   MainThreadTaskQueue* loading_task_queue() {
     auto queue_traits = FrameSchedulerImpl::LoadingTaskQueueTraits();
     return main_frame_scheduler_->FrameTaskQueueControllerForTest()
@@ -946,7 +965,7 @@ class MainThreadSchedulerImplTest : public testing::Test {
   scoped_refptr<base::TestMockTimeTaskRunner> test_task_runner_;
 
   std::unique_ptr<MainThreadSchedulerImplForTest> scheduler_;
-  std::unique_ptr<WebAgentGroupScheduler> agent_group_scheduler_;
+  std::unique_ptr<AgentGroupSchedulerImpl> agent_group_scheduler_;
   std::unique_ptr<MockPageSchedulerImpl> page_scheduler_;
   std::unique_ptr<FrameSchedulerImpl> main_frame_scheduler_;
   std::unique_ptr<WebWidgetScheduler> widget_scheduler_;
@@ -2485,8 +2504,8 @@ TEST_F(MainThreadSchedulerImplTest, StopAndThrottleThrottleableQueue) {
 
   auto pause_handle = scheduler_->PauseRenderer();
   base::RunLoop().RunUntilIdle();
-  scheduler_->task_queue_throttler()->IncreaseThrottleRefCount(
-      throttleable_task_queue()->GetTaskQueue());
+  MainThreadTaskQueue::ThrottleHandle handle =
+      throttleable_task_queue()->Throttle();
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre());
 }
@@ -2495,8 +2514,8 @@ TEST_F(MainThreadSchedulerImplTest, ThrottleAndPauseRenderer) {
   Vector<String> run_order;
   PostTestTasks(&run_order, "T1 T2");
 
-  scheduler_->task_queue_throttler()->IncreaseThrottleRefCount(
-      throttleable_task_queue()->GetTaskQueue());
+  MainThreadTaskQueue::ThrottleHandle handle =
+      throttleable_task_queue()->Throttle();
   base::RunLoop().RunUntilIdle();
   auto pause_handle = scheduler_->PauseRenderer();
   base::RunLoop().RunUntilIdle();
@@ -2883,9 +2902,8 @@ TEST_F(MainThreadSchedulerImplTest, SYNCHRONIZED_GESTURE_CompositingExpensive) {
 
   // Throttleable tasks should not have been starved by the expensive compositor
   // tasks.
-  EXPECT_EQ(
-      TaskQueue::kNormalPriority,
-      scheduler_->CompositorTaskQueue()->GetTaskQueue()->GetQueuePriority());
+  EXPECT_EQ(TaskQueue::kNormalPriority,
+            compositor_task_queue()->GetTaskQueue()->GetQueuePriority());
   EXPECT_EQ(1000u, run_order.size());
 }
 
@@ -2926,9 +2944,8 @@ TEST_F(MainThreadSchedulerImplTest, MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
 
   // Throttleable tasks should not have been starved by the expensive compositor
   // tasks.
-  EXPECT_EQ(
-      TaskQueue::kNormalPriority,
-      scheduler_->CompositorTaskQueue()->GetTaskQueue()->GetQueuePriority());
+  EXPECT_EQ(TaskQueue::kNormalPriority,
+            compositor_task_queue()->GetTaskQueue()->GetQueuePriority());
   EXPECT_EQ(1000u, run_order.size());
 }
 
@@ -2967,9 +2984,8 @@ TEST_F(MainThreadSchedulerImplTest, MAIN_THREAD_GESTURE) {
     EXPECT_EQ(UseCase::kMainThreadGesture, CurrentUseCase()) << "i = " << i;
   }
 
-  EXPECT_EQ(
-      TaskQueue::kHighestPriority,
-      scheduler_->CompositorTaskQueue()->GetTaskQueue()->GetQueuePriority());
+  EXPECT_EQ(TaskQueue::kHighestPriority,
+            compositor_task_queue()->GetTaskQueue()->GetQueuePriority());
   EXPECT_EQ(279u, run_order.size());
 }
 
@@ -3140,7 +3156,7 @@ TEST_F(MainThreadSchedulerImplTest, EnableVirtualTime) {
 
   EXPECT_EQ(scheduler_->DefaultTaskQueue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->GetVirtualTimeDomain());
-  EXPECT_EQ(scheduler_->CompositorTaskQueue()->GetTaskQueue()->GetTimeDomain(),
+  EXPECT_EQ(compositor_task_queue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->GetVirtualTimeDomain());
   EXPECT_EQ(loading_task_queue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->GetVirtualTimeDomain());
@@ -3199,15 +3215,13 @@ TEST_F(MainThreadSchedulerImplTest, EnableVirtualTimeAfterThrottling) {
 
   frame_scheduler->SetCrossOriginToMainFrame(true);
   frame_scheduler->SetFrameVisible(false);
-  EXPECT_TRUE(scheduler_->task_queue_throttler()->IsThrottled(
-      throttleable_tq->GetTaskQueue()));
+  EXPECT_TRUE(throttleable_tq->IsThrottled());
 
   scheduler_->EnableVirtualTime(
       MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
   EXPECT_EQ(throttleable_tq->GetTaskQueue()->GetTimeDomain(),
             scheduler_->GetVirtualTimeDomain());
-  EXPECT_FALSE(scheduler_->task_queue_throttler()->IsThrottled(
-      throttleable_tq->GetTaskQueue()));
+  EXPECT_FALSE(throttleable_tq->IsThrottled());
 }
 
 TEST_F(MainThreadSchedulerImplTest, DisableVirtualTimeForTesting) {
@@ -3216,7 +3230,7 @@ TEST_F(MainThreadSchedulerImplTest, DisableVirtualTimeForTesting) {
   scheduler_->DisableVirtualTimeForTesting();
   EXPECT_EQ(scheduler_->DefaultTaskQueue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->real_time_domain());
-  EXPECT_EQ(scheduler_->CompositorTaskQueue()->GetTaskQueue()->GetTimeDomain(),
+  EXPECT_EQ(compositor_task_queue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->real_time_domain());
   EXPECT_EQ(loading_task_queue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->real_time_domain());
@@ -3342,7 +3356,7 @@ TEST_F(MainThreadSchedulerImplTest, Tracing) {
       FROM_HERE, base::BindOnce(NullTask),
       base::TimeDelta::FromMilliseconds(10));
 
-  EXPECT_FALSE(scheduler_->ToString().empty());
+  scheduler_->CreateTraceEventObjectSnapshot();
 }
 
 TEST_F(MainThreadSchedulerImplTest,
@@ -4130,6 +4144,22 @@ TEST_F(BestEffortNonMainQueuesUntilOnFMPTimeoutTest,
             TaskQueue::QueuePriority::kNormalPriority);
 }
 
+TEST_F(MainThreadSchedulerImplTest, ThrottleHandleThrottlesQueue) {
+  EXPECT_FALSE(throttleable_task_queue()->IsThrottled());
+  {
+    MainThreadTaskQueue::ThrottleHandle handle =
+        throttleable_task_queue()->Throttle();
+    EXPECT_TRUE(throttleable_task_queue()->IsThrottled());
+    {
+      MainThreadTaskQueue::ThrottleHandle handle_2 =
+          throttleable_task_queue()->Throttle();
+      EXPECT_TRUE(throttleable_task_queue()->IsThrottled());
+    }
+    EXPECT_TRUE(throttleable_task_queue()->IsThrottled());
+  }
+  EXPECT_FALSE(throttleable_task_queue()->IsThrottled());
+}
+
 }  // namespace main_thread_scheduler_impl_unittest
 }  // namespace scheduler
 }  // namespace blink