BASELINE: Update Chromium to 94.0.4606.111

Change-Id: I924781584def20fc800bedf6ff41fdb96c438193
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 19 insertions, 245 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 a6b55d5ebc2..61b5141a2c5 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
@@ -11,7 +11,6 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
-#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/run_loop.h"
@@ -319,10 +318,9 @@ class MockPageSchedulerImpl : public PageSchedulerImpl {
         .WillByDefault(Return(true));
     ON_CALL(*this, IsMainFrameLocal).WillByDefault(Return(true));
   }
-  ~MockPageSchedulerImpl() override = default;
-
   MockPageSchedulerImpl(const MockPageSchedulerImpl&) = delete;
   MockPageSchedulerImpl& operator=(const MockPageSchedulerImpl&) = delete;
+  ~MockPageSchedulerImpl() override = default;
 
   MOCK_METHOD(bool, RequestBeginMainFrameNotExpected, (bool));
   MOCK_METHOD(bool, IsWaitingForMainFrameContentfulPaint, (), (const));
@@ -410,6 +408,10 @@ class MainThreadSchedulerImplTest : public testing::Test {
 
   MainThreadSchedulerImplTest() : MainThreadSchedulerImplTest({}, {}) {}
 
+  MainThreadSchedulerImplTest(const MainThreadSchedulerImplTest&) = delete;
+  MainThreadSchedulerImplTest& operator=(const MainThreadSchedulerImplTest&) =
+      delete;
+
   ~MainThreadSchedulerImplTest() override = default;
 
   void SetUp() override {
@@ -984,8 +986,6 @@ class MainThreadSchedulerImplTest : public testing::Test {
   bool simulate_throttleable_task_ran_;
   bool initially_ensure_usecase_none_ = true;
   uint64_t next_begin_frame_number_ = viz::BeginFrameArgs::kStartingFrameNumber;
-
-  DISALLOW_COPY_AND_ASSIGN(MainThreadSchedulerImplTest);
 };
 
 TEST_F(MainThreadSchedulerImplTest, TestPostDefaultTask) {
@@ -2511,18 +2511,6 @@ TEST_F(MainThreadSchedulerImplTest, StopAndThrottleThrottleableQueue) {
   EXPECT_THAT(run_order, testing::ElementsAre());
 }
 
-TEST_F(MainThreadSchedulerImplTest, ThrottleAndPauseRenderer) {
-  Vector<String> run_order;
-  PostTestTasks(&run_order, "T1 T2");
-
-  MainThreadTaskQueue::ThrottleHandle handle =
-      throttleable_task_queue()->Throttle();
-  base::RunLoop().RunUntilIdle();
-  auto pause_handle = scheduler_->PauseRenderer();
-  base::RunLoop().RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre());
-}
-
 TEST_F(MainThreadSchedulerImplTest, MultipleStopsNeedMultipleResumes) {
   Vector<String> run_order;
   PostTestTasks(&run_order, "T1 T2");
@@ -2740,8 +2728,7 @@ TEST_F(
     SYNCHRONIZED_GESTURE_ThrottleableTaskThrottling_ThrottleableQueuesStopped) {
   SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
 
-  base::TimeTicks first_throttled_run_time =
-      TaskQueueThrottler::AlignedThrottledRunTime(Now());
+  base::TimeTicks first_run_time = Now();
 
   size_t count = 0;
   // With the compositor task taking 10ms, there is not enough time to run this
@@ -2774,7 +2761,7 @@ TEST_F(
 
     // Before the policy is updated the queue will be enabled. Subsequently it
     // will be disabled until the throttled queue is pumped.
-    bool expect_queue_enabled = (i == 0) || (Now() > first_throttled_run_time);
+    bool expect_queue_enabled = (i == 0) || (Now() > first_run_time);
     if (paused)
       expect_queue_enabled = false;
     EXPECT_EQ(expect_queue_enabled,
@@ -3142,8 +3129,7 @@ TEST_F(
 
 TEST_F(MainThreadSchedulerImplTest, EnableVirtualTime) {
   EXPECT_FALSE(scheduler_->IsVirtualTimeEnabled());
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   EXPECT_TRUE(scheduler_->IsVirtualTimeEnabled());
   scoped_refptr<MainThreadTaskQueue> loading_tq =
       scheduler_->NewLoadingTaskQueue(
@@ -3218,16 +3204,14 @@ TEST_F(MainThreadSchedulerImplTest, EnableVirtualTimeAfterThrottling) {
   frame_scheduler->SetFrameVisible(false);
   EXPECT_TRUE(throttleable_tq->IsThrottled());
 
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   EXPECT_EQ(throttleable_tq->GetTaskQueue()->GetTimeDomain(),
             scheduler_->GetVirtualTimeDomain());
-  EXPECT_FALSE(throttleable_tq->IsThrottled());
+  EXPECT_TRUE(throttleable_tq->IsThrottled());
 }
 
 TEST_F(MainThreadSchedulerImplTest, DisableVirtualTimeForTesting) {
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   scheduler_->DisableVirtualTimeForTesting();
   EXPECT_EQ(scheduler_->DefaultTaskQueue()->GetTaskQueue()->GetTimeDomain(),
             scheduler_->real_time_domain());
@@ -3245,8 +3229,7 @@ TEST_F(MainThreadSchedulerImplTest, DisableVirtualTimeForTesting) {
 }
 
 TEST_F(MainThreadSchedulerImplTest, VirtualTimePauser) {
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   scheduler_->SetVirtualTimePolicy(
       PageSchedulerImpl::VirtualTimePolicy::kDeterministicLoading);
 
@@ -3266,8 +3249,7 @@ TEST_F(MainThreadSchedulerImplTest, VirtualTimePauser) {
 }
 
 TEST_F(MainThreadSchedulerImplTest, VirtualTimePauserNonInstantTask) {
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   scheduler_->SetVirtualTimePolicy(
       PageSchedulerImpl::VirtualTimePolicy::kDeterministicLoading);
 
@@ -3286,8 +3268,7 @@ TEST_F(MainThreadSchedulerImplTest, VirtualTimeWithOneQueueWithoutVirtualTime) {
   // This test ensures that we do not do anything strange like stopping
   // processing task queues after we encountered one task queue with
   // DoNotUseVirtualTime trait.
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
   scheduler_->SetVirtualTimePolicy(
       PageSchedulerImpl::VirtualTimePolicy::kDeterministicLoading);
 
@@ -3345,11 +3326,11 @@ TEST_F(MainThreadSchedulerImplTest, Tracing) {
       CreatePageScheduler(nullptr, scheduler_.get(), *agent_group_scheduler_);
   scheduler_->AddPageScheduler(page_scheduler2.get());
 
-  CPUTimeBudgetPool* time_budget_pool =
-      scheduler_->task_queue_throttler()->CreateCPUTimeBudgetPool("test");
+  std::unique_ptr<CPUTimeBudgetPool> time_budget_pool =
+      scheduler_->CreateCPUTimeBudgetPoolForTesting("test");
 
-  time_budget_pool->AddQueue(base::TimeTicks(),
-                             throttleable_task_queue()->GetTaskQueue());
+  throttleable_task_queue()->AddToBudgetPool(base::TimeTicks(),
+                                             time_budget_pool.get());
 
   throttleable_task_runner_->PostTask(FROM_HERE, base::BindOnce(NullTask));
 
@@ -3604,8 +3585,7 @@ TEST_F(MainThreadSchedulerImplTest, TaskQueueReferenceClearedOnShutdown) {
 
   scheduler_->OnShutdownTaskQueue(queue1);
 
-  scheduler_->EnableVirtualTime(
-      MainThreadSchedulerImpl::BaseTimeOverridePolicy::DO_NOT_OVERRIDE);
+  scheduler_->EnableVirtualTime();
 
   // Virtual time should be enabled for queue2, as it is a regular queue and
   // nothing should change for queue1 because it was shut down.
@@ -3939,212 +3919,6 @@ TEST_F(VeryHighPriorityForCompositingAfterDelayExperimentTest,
   EXPECT_EQ(UseCase::kNone, CurrentUseCase());
 }
 
-class VeryHighPriorityForCompositingBudgetExperimentTest
-    : public MainThreadSchedulerImplTest {
- public:
-  VeryHighPriorityForCompositingBudgetExperimentTest()
-      : MainThreadSchedulerImplTest({kVeryHighPriorityForCompositingBudget},
-                                    {}) {}
-};
-
-TEST_F(VeryHighPriorityForCompositingBudgetExperimentTest,
-       TestCompositorPolicy_CompositorPriorityVeryHighToNormal) {
-  Vector<String> run_order;
-  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
-  EnableIdleTasks();
-  base::RunLoop().RunUntilIdle();
-
-  // Compositor is at kVeryHighPriority Initially.
-  EXPECT_THAT(run_order,
-              testing::ElementsAre("P1", "C1", "C2", "D1", "D2", "I1"));
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-
-  // 1000ms BeginMainFrame compositor task will exhaust the budget. Compositor
-  // tasks will be run at normal priority.
-  DoMainFrame();
-  RunSlowCompositorTask();
-
-  run_order.clear();
-  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
-  EnableIdleTasks();
-  base::RunLoop().RunUntilIdle();
-
-  EXPECT_THAT(run_order,
-              testing::ElementsAre("P1", "D1", "C1", "D2", "C2", "I1"));
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-}
-
-TEST_F(VeryHighPriorityForCompositingBudgetExperimentTest,
-       TestCompositorPolicy_CompositorPriorityNormalToVeryHigh) {
-  // 1000ms BeginMainFrame compositor task will exhaust the budget.
-  DoMainFrame();
-  RunSlowCompositorTask();
-
-  Vector<String> run_order;
-  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
-  EnableIdleTasks();
-  base::RunLoop().RunUntilIdle();
-
-  // Compositor is at kNormalPriority, it will inteleave with default tasks.
-  EXPECT_THAT(run_order,
-              testing::ElementsAre("P1", "D1", "C1", "D2", "C2", "I1"));
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-
-  // Recover the budget.
-  AdvanceTimeWithTask(12);
-
-  run_order.clear();
-  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
-  EnableIdleTasks();
-  base::RunLoop().RunUntilIdle();
-
-  // Compositor is now at kVeryHighPriority, compositing tasks will run
-  // before default tasks.
-  EXPECT_THAT(run_order,
-              testing::ElementsAre("P1", "C1", "C2", "D1", "D2", "I1"));
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-}
-
-class DisableNonMainTimerQueuesUntilFMPTest
-    : public MainThreadSchedulerImplTest {
- public:
-  DisableNonMainTimerQueuesUntilFMPTest()
-      : MainThreadSchedulerImplTest({{kPerAgentSchedulingExperiments,
-                                      {{"queues", "timer-queues"},
-                                       {"method", "disable"},
-                                       {"signal", "fmp"}}}}) {}
-};
-
-TEST_F(DisableNonMainTimerQueuesUntilFMPTest, DisablesOnlyNonMainTimerQueue) {
-  auto page_scheduler =
-      CreatePageScheduler(nullptr, scheduler_.get(), *agent_group_scheduler_);
-
-  NiceMock<MockFrameDelegate> frame_delegate{};
-  std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      CreateFrameScheduler(page_scheduler.get(), &frame_delegate, nullptr,
-                           FrameScheduler::FrameType::kSubframe);
-
-  scoped_refptr<MainThreadTaskQueue> throttleable_tq = QueueForTaskType(
-      frame_scheduler.get(), TaskType::kJavascriptTimerDelayedLowNesting);
-  ForceUpdatePolicyAndGetCurrentUseCase();
-
-  EXPECT_FALSE(throttleable_tq->GetTaskQueue()->IsQueueEnabled());
-
-  ignore_result(
-      scheduler_->agent_scheduling_strategy().OnMainFrameFirstMeaningfulPaint(
-          *main_frame_scheduler_));
-  ForceUpdatePolicyAndGetCurrentUseCase();
-
-  EXPECT_TRUE(throttleable_tq->GetTaskQueue()->IsQueueEnabled());
-}
-
-TEST_F(DisableNonMainTimerQueuesUntilFMPTest,
-       ShouldNotifyAgentStrategyOnInput) {
-  auto page_scheduler =
-      CreatePageScheduler(nullptr, scheduler_.get(), *agent_group_scheduler_);
-
-  NiceMock<MockFrameDelegate> frame_delegate{};
-  std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      CreateFrameScheduler(page_scheduler.get(), &frame_delegate, nullptr,
-                           FrameScheduler::FrameType::kSubframe);
-
-  scoped_refptr<MainThreadTaskQueue> timer_tq = QueueForTaskType(
-      frame_scheduler.get(), TaskType::kJavascriptTimerDelayedLowNesting);
-
-  FakeInputEvent mouse_move_event{WebInputEvent::Type::kMouseMove,
-                                  blink::WebInputEvent::kLeftButtonDown};
-  FakeInputEvent mouse_down_event{WebInputEvent::Type::kMouseDown,
-                                  blink::WebInputEvent::kLeftButtonDown};
-  InputEventState event_state{};
-
-  // Mouse move event should be ignored, meaning the queue should be disabled.
-  scheduler_->DidHandleInputEventOnCompositorThread(mouse_move_event,
-                                                    event_state);
-  ForceUpdatePolicyAndGetCurrentUseCase();
-  EXPECT_FALSE(timer_tq->GetTaskQueue()->IsQueueEnabled());
-
-  // Mouse down should cause MTSI to notify the agent scheduling strategy, which
-  // should re-enable the throttleable queue.
-  scheduler_->DidHandleInputEventOnCompositorThread(mouse_down_event,
-                                                    event_state);
-  base::RunLoop().RunUntilIdle();  // Notification is posted to the main thread.
-  EXPECT_TRUE(timer_tq->GetTaskQueue()->IsQueueEnabled());
-}
-
-class BestEffortNonMainQueuesUntilOnLoadTest
-    : public MainThreadSchedulerImplTest {
- public:
-  BestEffortNonMainQueuesUntilOnLoadTest()
-      : MainThreadSchedulerImplTest({{kPerAgentSchedulingExperiments,
-                                      {{"queues", "all-queues"},
-                                       {"method", "best-effort"},
-                                       {"signal", "onload"}}}}) {}
-};
-
-TEST_F(BestEffortNonMainQueuesUntilOnLoadTest, DeprioritizesAllNonMainQueues) {
-  auto page_scheduler =
-      CreatePageScheduler(nullptr, scheduler_.get(), *agent_group_scheduler_);
-
-  NiceMock<MockFrameDelegate> frame_delegate{};
-  std::unique_ptr<FrameSchedulerImpl> frame_scheduler =
-      CreateFrameScheduler(page_scheduler.get(), &frame_delegate, nullptr,
-                           FrameScheduler::FrameType::kSubframe);
-
-  scoped_refptr<MainThreadTaskQueue> non_timer_tq =
-      QueueForTaskType(frame_scheduler.get(), TaskType::kNetworking);
-  ForceUpdatePolicyAndGetCurrentUseCase();
-  EXPECT_EQ(non_timer_tq->GetTaskQueue()->GetQueuePriority(),
-            TaskQueue::QueuePriority::kBestEffortPriority);
-
-  scheduler_->OnMainFrameLoad(*main_frame_scheduler_);
-
-  EXPECT_EQ(non_timer_tq->GetTaskQueue()->GetQueuePriority(),
-            TaskQueue::QueuePriority::kNormalPriority);
-}
-
-class BestEffortNonMainQueuesUntilOnFMPTimeoutTest
-    : public MainThreadSchedulerImplTest {
- public:
-  BestEffortNonMainQueuesUntilOnFMPTimeoutTest()
-      : MainThreadSchedulerImplTest({{kPerAgentSchedulingExperiments,
-                                      {{"queues", "all-queues"},
-                                       {"method", "best-effort"},
-                                       {"signal", "fmp"},
-                                       {"delay_ms", "1000"}}}}) {}
-};
-
-TEST_F(BestEffortNonMainQueuesUntilOnFMPTimeoutTest,
-       DeprioritizesNonMainQueues) {
-  auto page_scheduler = CreatePageScheduler(
-      /* page_scheduler_delegate= */ nullptr, scheduler_.get(),
-      *agent_group_scheduler_);
-
-  NiceMock<MockFrameDelegate> frame_delegate{};
-  std::unique_ptr<FrameSchedulerImpl> frame_scheduler = CreateFrameScheduler(
-      page_scheduler.get(), &frame_delegate, /* blame_context= */ nullptr,
-      FrameScheduler::FrameType::kSubframe);
-
-  scoped_refptr<MainThreadTaskQueue> non_timer_tq =
-      QueueForTaskType(frame_scheduler.get(), TaskType::kNetworking);
-  ForceUpdatePolicyAndGetCurrentUseCase();
-  EXPECT_EQ(non_timer_tq->GetTaskQueue()->GetQueuePriority(),
-            TaskQueue::QueuePriority::kBestEffortPriority);
-
-  ignore_result(
-      scheduler_->agent_scheduling_strategy().OnMainFrameFirstMeaningfulPaint(
-          *main_frame_scheduler_));
-
-  // Queue should still have lower priority, since we just started counting
-  // towards the timeout.
-  EXPECT_EQ(non_timer_tq->GetTaskQueue()->GetQueuePriority(),
-            TaskQueue::QueuePriority::kBestEffortPriority);
-
-  test_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(1000));
-
-  EXPECT_EQ(non_timer_tq->GetTaskQueue()->GetQueuePriority(),
-            TaskQueue::QueuePriority::kNormalPriority);
-}
-
 TEST_F(MainThreadSchedulerImplTest, ThrottleHandleThrottlesQueue) {
   EXPECT_FALSE(throttleable_task_queue()->IsThrottled());
   {