Scheduler: Extend resource fetch priority experiment to loading only.

Extend resource fetch priority experiment to support being enabled
only in the loading use case.

Bug: 870349
Change-Id: I980f078f3a48bc7ab240e475869125d6dc9ffa55
Reviewed-on: https://chromium-review.googlesource.com/1159064Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Farah Charab <farahcharab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#580629}

testing/variations/fieldtrial_testing_config.json

@@ -26,12 +26,11 @@
                 "mac",
                 "chromeos",
                 "linux",
-                "ios",
                 "android"
             ],
             "experiments": [
                 {
-                    "name": "LowPriorityAdFrameEnabled",
+                    "name": "LowPriorityForAdFrame",
                     "enable_features": [
                         "BlinkSchedulerLowPriorityForAdFrame"
                     ]
@@ -1662,7 +1661,7 @@
                 {
                     "name": "LowPriorityForHiddenFrameDuringLoadingEnabled",
                     "enable_features": [
-                        "BlinkSchedulerExperimentOnlyWhenLoading",
+                        "BlinkSchedulerFrameExperimentOnlyWhenLoading",
                         "BlinkSchedulerLowPriorityForHiddenFrame"
                     ]
                 }

third_party/blink/renderer/platform/scheduler/child/features.h

@@ -87,6 +87,14 @@ const base::Feature kLowPriorityForHiddenFrame{
     "BlinkSchedulerLowPriorityForHiddenFrame",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Used along with |kLowPriorityForHiddenFrame|,
+// |kLowPriorityForSubFrameThrottleableTask|, |kLowPriorityForThrottleableTask|,
+// |kLowPriorityForSubFrame| to enable one of these experiments only during the
+// load use case.
+const base::Feature kFrameExperimentOnlyWhenLoading{
+    "BlinkSchedulerFrameExperimentOnlyWhenLoading",
+    base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Enables setting the priority of an ad frame to low priority.
 const base::Feature kLowPriorityForAdFrame{
     "BlinkSchedulerLowPriorityForAdFrame", base::FEATURE_DISABLED_BY_DEFAULT};
@@ -96,20 +104,34 @@ const base::Feature kBestEffortPriorityForAdFrame{
     "BlinkSchedulerBestEffortPriorityForAdFrame",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Used along with |kLowPriorityForAdFrame| or |kBestEffortPriorityForAdFrame|
+// to enable one of these experiments only during the load use case.
+const base::Feature kAdFrameExperimentOnlyWhenLoading{
+    "BlinkSchedulerAdFrameExperimentOnlyWhenLoading",
+    base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Enables using a resource's fetch priority to determine the priority of the
 // resource's loading tasks posted to blink's scheduler.
 const base::Feature kUseResourceFetchPriority{
     "BlinkSchedulerResourceFetchPriority", base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Enables using a resource's fetch priority to determine the priority of the
+// resource's loading tasks posted to blink's scheduler only for resources
+// requested during the loading phase.
+const base::Feature kUseResourceFetchPriorityOnlyWhenLoading{
+    "BlinkSchedulerResourceFetchPriorityOnlyWhenLoading",
+    base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Enables setting the priority of cross-origin task queues to
 // low priority.
 const base::Feature kLowPriorityForCrossOrigin{
     "BlinkSchedulerLowPriorityForCrossOrigin",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
-// Enables a chosen experiments only during the load use case.
-const base::Feature kExperimentOnlyWhenLoading{
-    "BlinkSchedulerExperimentOnlyWhenLoading",
+// Enables setting the priority of cross-origin task queues to
+// low priority during loading only.
+const base::Feature kLowPriorityForCrossOriginOnlyWhenLoading{
+    "BlinkSchedulerLowPriorityForCrossOriginOnlyWhenLoading",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
 // Enable setting throttleable and freezable task types from field trial

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

@@ -508,7 +508,10 @@ FrameSchedulerImpl::CreateResourceLoadingTaskRunnerHandle() {
 std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl>
 FrameSchedulerImpl::CreateResourceLoadingTaskRunnerHandleImpl() {
   if (main_thread_scheduler_->scheduling_settings()
-          .use_resource_fetch_priority) {
+          .use_resource_fetch_priority ||
+      (parent_page_scheduler_->IsLoading() &&
+       main_thread_scheduler_->scheduling_settings()
+           .use_resource_priorities_only_during_loading)) {
     scoped_refptr<MainThreadTaskQueue> task_queue =
         frame_task_queue_controller_->NewResourceLoadingTaskQueue();
     resource_loading_task_queue_priorities_.insert(
@@ -796,7 +799,7 @@ TaskQueue::QueuePriority FrameSchedulerImpl::ComputePriority(
   // all times.
   if (parent_page_scheduler_->IsLoading() ||
       !main_thread_scheduler_->scheduling_settings()
-           .experiment_only_when_loading) {
+           .use_frame_priorities_only_during_loading) {
     // Low priority feature enabled for hidden frame.
     if (main_thread_scheduler_->scheduling_settings()
             .low_priority_hidden_frame &&
@@ -824,20 +827,28 @@ TaskQueue::QueuePriority FrameSchedulerImpl::ComputePriority(
             .low_priority_throttleable &&
         is_throttleable_task_queue)
       return TaskQueue::QueuePriority::kLowPriority;
+  }
 
-    if (main_thread_scheduler_->scheduling_settings().low_priority_ad_frame &&
-        IsAdFrame()) {
+  // Ad frame experiment.
+  if (IsAdFrame() && (parent_page_scheduler_->IsLoading() ||
+                      !main_thread_scheduler_->scheduling_settings()
+                           .use_adframe_priorities_only_during_loading)) {
+    if (main_thread_scheduler_->scheduling_settings().low_priority_ad_frame) {
       return TaskQueue::QueuePriority::kLowPriority;
     }
 
-    if (main_thread_scheduler_->scheduling_settings().best_effort_ad_frame &&
-        IsAdFrame()) {
+    if (main_thread_scheduler_->scheduling_settings().best_effort_ad_frame) {
       return TaskQueue::QueuePriority::kBestEffortPriority;
     }
+  }
 
+  // Frame origin type experiment.
+  if (IsCrossOrigin()) {
     if (main_thread_scheduler_->scheduling_settings()
-            .low_priority_cross_origin &&
-        IsCrossOrigin()) {
+            .low_priority_cross_origin ||
+        (main_thread_scheduler_->scheduling_settings()
+             .low_priority_cross_origin_only_during_loading &&
+         parent_page_scheduler_->IsLoading())) {
       return TaskQueue::QueuePriority::kLowPriority;
     }
   }

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

@@ -785,7 +785,7 @@ class LowPriorityHiddenFrameExperimentTest : public FrameSchedulerImplTest {
  public:
   LowPriorityHiddenFrameExperimentTest()
       : FrameSchedulerImplTest({kLowPriorityForHiddenFrame},
-                               {kExperimentOnlyWhenLoading}) {}
+                               {kFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(LowPriorityHiddenFrameExperimentTest, FrameQueuesPriorities) {
@@ -825,7 +825,7 @@ class LowPriorityHiddenFrameDuringLoadingExperimentTest
  public:
   LowPriorityHiddenFrameDuringLoadingExperimentTest()
       : FrameSchedulerImplTest(
-            {kLowPriorityForHiddenFrame, kExperimentOnlyWhenLoading},
+            {kLowPriorityForHiddenFrame, kFrameExperimentOnlyWhenLoading},
             {}) {}
 };
 
@@ -872,7 +872,7 @@ class LowPrioritySubFrameExperimentTest : public FrameSchedulerImplTest {
  public:
   LowPrioritySubFrameExperimentTest()
       : FrameSchedulerImplTest({kLowPriorityForSubFrame},
-                               {kExperimentOnlyWhenLoading}) {}
+                               {kFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(LowPrioritySubFrameExperimentTest, FrameQueuesPriorities) {
@@ -914,7 +914,7 @@ class LowPrioritySubFrameDuringLoadingExperimentTest
  public:
   LowPrioritySubFrameDuringLoadingExperimentTest()
       : FrameSchedulerImplTest(
-            {kLowPriorityForSubFrame, kExperimentOnlyWhenLoading},
+            {kLowPriorityForSubFrame, kFrameExperimentOnlyWhenLoading},
             {}) {}
 };
 
@@ -961,7 +961,7 @@ class LowPrioritySubFrameThrottleableTaskExperimentTest
  public:
   LowPrioritySubFrameThrottleableTaskExperimentTest()
       : FrameSchedulerImplTest({kLowPriorityForSubFrameThrottleableTask},
-                               {kExperimentOnlyWhenLoading}) {}
+                               {kFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(LowPrioritySubFrameThrottleableTaskExperimentTest,
@@ -1004,7 +1004,7 @@ class LowPrioritySubFrameThrottleableTaskDuringLoadingExperimentTest
  public:
   LowPrioritySubFrameThrottleableTaskDuringLoadingExperimentTest()
       : FrameSchedulerImplTest({kLowPriorityForSubFrameThrottleableTask,
-                                kExperimentOnlyWhenLoading},
+                                kFrameExperimentOnlyWhenLoading},
                                {}) {}
 };
 
@@ -1052,7 +1052,7 @@ class LowPriorityThrottleableTaskExperimentTest
  public:
   LowPriorityThrottleableTaskExperimentTest()
       : FrameSchedulerImplTest({kLowPriorityForThrottleableTask},
-                               {kExperimentOnlyWhenLoading}) {}
+                               {kFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(LowPriorityThrottleableTaskExperimentTest, FrameQueuesPriorities) {
@@ -1094,7 +1094,7 @@ class LowPriorityThrottleableTaskDuringLoadingExperimentTest
  public:
   LowPriorityThrottleableTaskDuringLoadingExperimentTest()
       : FrameSchedulerImplTest(
-            {kLowPriorityForThrottleableTask, kExperimentOnlyWhenLoading},
+            {kLowPriorityForThrottleableTask, kFrameExperimentOnlyWhenLoading},
             {}) {}
 };
 
@@ -1181,7 +1181,8 @@ TEST_F(LowPriorityThrottleableTaskDuringLoadingExperimentTest,
 class LowPriorityAdFrameExperimentTest : public FrameSchedulerImplTest {
  public:
   LowPriorityAdFrameExperimentTest()
-      : FrameSchedulerImplTest({kLowPriorityForAdFrame}, {}) {}
+      : FrameSchedulerImplTest({kLowPriorityForAdFrame},
+                               {kAdFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(LowPriorityAdFrameExperimentTest, FrameQueuesPriorities) {
@@ -1223,7 +1224,7 @@ class LowPriorityAdFrameDuringLoadingExperimentTest
  public:
   LowPriorityAdFrameDuringLoadingExperimentTest()
       : FrameSchedulerImplTest(
-            {kLowPriorityForAdFrame, kExperimentOnlyWhenLoading},
+            {kLowPriorityForAdFrame, kAdFrameExperimentOnlyWhenLoading},
             {}) {}
 };
 
@@ -1271,7 +1272,8 @@ TEST_F(LowPriorityAdFrameDuringLoadingExperimentTest, FrameQueuesPriorities) {
 class BestEffortPriorityAdFrameExperimentTest : public FrameSchedulerImplTest {
  public:
   BestEffortPriorityAdFrameExperimentTest()
-      : FrameSchedulerImplTest({kBestEffortPriorityForAdFrame}, {}) {}
+      : FrameSchedulerImplTest({kBestEffortPriorityForAdFrame},
+                               {kAdFrameExperimentOnlyWhenLoading}) {}
 };
 
 TEST_F(BestEffortPriorityAdFrameExperimentTest, FrameQueuesPriorities) {
@@ -1313,7 +1315,7 @@ class BestEffortPriorityAdFrameDuringLoadingExperimentTest
  public:
   BestEffortPriorityAdFrameDuringLoadingExperimentTest()
       : FrameSchedulerImplTest(
-            {kBestEffortPriorityForAdFrame, kExperimentOnlyWhenLoading},
+            {kBestEffortPriorityForAdFrame, kAdFrameExperimentOnlyWhenLoading},
             {}) {}
 };
 
@@ -1367,8 +1369,8 @@ class ResourceFetchPriorityExperimentTest : public FrameSchedulerImplTest {
         {"HIGHEST", "HIGH"}, {"MEDIUM", "NORMAL"}, {"LOW", "NORMAL"},
         {"LOWEST", "LOW"},   {"IDLE", "LOW"},      {"THROTTLED", "LOW"}};
 
-    const char kStudyName[] = "BlinkSchedulerResourceFetchPriority";
-    const char kGroupName[] = "GroupName";
+    const char kStudyName[] = "ResourceFetchPriorityExperiment";
+    const char kGroupName[] = "GroupName1";
 
     field_trial_list_ = std::make_unique<base::FieldTrialList>(nullptr);
     base::AssociateFieldTrialParams(kStudyName, kGroupName, params);
@@ -1393,6 +1395,52 @@ TEST_F(ResourceFetchPriorityExperimentTest, DidChangePriority) {
             TaskQueue::QueuePriority::kHighPriority);
 }
 
+class ResourceFetchPriorityExperimentOnlyWhenLoadingTest
+    : public FrameSchedulerImplTest {
+ public:
+  ResourceFetchPriorityExperimentOnlyWhenLoadingTest()
+      : FrameSchedulerImplTest({kUseResourceFetchPriorityOnlyWhenLoading}, {}) {
+    std::map<std::string, std::string> params{
+        {"HIGHEST", "HIGH"}, {"MEDIUM", "NORMAL"}, {"LOW", "NORMAL"},
+        {"LOWEST", "LOW"},   {"IDLE", "LOW"},      {"THROTTLED", "LOW"}};
+
+    const char kStudyName[] = "ResourceFetchPriorityExperiment";
+    const char kGroupName[] = "GroupName2";
+
+    field_trial_list_ = std::make_unique<base::FieldTrialList>(nullptr);
+    base::AssociateFieldTrialParams(kStudyName, kGroupName, params);
+    base::FieldTrialList::CreateFieldTrial(kStudyName, kGroupName);
+  }
+};
+
+TEST_F(ResourceFetchPriorityExperimentOnlyWhenLoadingTest, DidChangePriority) {
+  std::unique_ptr<ResourceLoadingTaskRunnerHandleImpl> handle =
+      GetResourceLoadingTaskRunnerHandleImpl();
+  scoped_refptr<MainThreadTaskQueue> task_queue = handle->task_queue();
+
+  TaskQueue::QueuePriority priority = task_queue->GetQueuePriority();
+  EXPECT_EQ(priority, TaskQueue::QueuePriority::kNormalPriority);
+
+  // Experiment is only enabled during the loading phase.
+  DidChangeResourceLoadingPriority(task_queue, net::RequestPriority::LOWEST);
+  EXPECT_EQ(task_queue->GetQueuePriority(), priority);
+
+  // Main thread scheduler is in the loading use case.
+  scheduler_->DidStartProvisionalLoad(true);
+  EXPECT_TRUE(page_scheduler_->IsLoading());
+
+  handle = GetResourceLoadingTaskRunnerHandleImpl();
+  task_queue = handle->task_queue();
+
+  DidChangeResourceLoadingPriority(task_queue, net::RequestPriority::LOWEST);
+  EXPECT_EQ(task_queue->GetQueuePriority(),
+            TaskQueue::QueuePriority::kLowPriority);
+
+  DidChangeResourceLoadingPriority(task_queue, net::RequestPriority::HIGHEST);
+  EXPECT_EQ(task_queue->GetQueuePriority(),
+            TaskQueue::QueuePriority::kHighPriority);
+}
+
 TEST_F(
     FrameSchedulerImplTest,
     DidChangeResourceLoadingPriority_ResourceFecthPriorityExperimentDisabled) {
@@ -1415,8 +1463,7 @@ TEST_F(
 class LowPriorityCrossOriginTaskExperimentTest : public FrameSchedulerImplTest {
  public:
   LowPriorityCrossOriginTaskExperimentTest()
-      : FrameSchedulerImplTest({kLowPriorityForCrossOrigin},
-                               {kExperimentOnlyWhenLoading}) {}
+      : FrameSchedulerImplTest({kLowPriorityForCrossOrigin}, {}) {}
 };
 
 TEST_F(LowPriorityCrossOriginTaskExperimentTest, FrameQueuesPriorities) {
@@ -1457,8 +1504,7 @@ class LowPriorityCrossOriginTaskDuringLoadingExperimentTest
     : public FrameSchedulerImplTest {
  public:
   LowPriorityCrossOriginTaskDuringLoadingExperimentTest()
-      : FrameSchedulerImplTest(
-            {kLowPriorityForCrossOrigin, kExperimentOnlyWhenLoading},
+      : FrameSchedulerImplTest({kLowPriorityForCrossOriginOnlyWhenLoading},
                                {}) {}
 };
 

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

@@ -76,7 +76,7 @@ constexpr base::TimeDelta kDefaultWakeUpDuration =
 // Name of the finch study that enables using resource fetch priorities to
 // schedule tasks on Blink.
 constexpr const char kResourceFetchPriorityExperiment[] =
-    "BlinkSchedulerResourceFetchPriority";
+    "ResourceFetchPriorityExperiment";
 
 base::TimeDelta GetWakeUpDuration() {
   int duration_ms;
@@ -575,18 +575,27 @@ MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {
       base::FeatureList::IsEnabled(kLowPriorityForThrottleableTask);
   low_priority_subframe_throttleable =
       base::FeatureList::IsEnabled(kLowPriorityForSubFrameThrottleableTask);
+  use_frame_priorities_only_during_loading =
+      base::FeatureList::IsEnabled(kFrameExperimentOnlyWhenLoading);
 
   low_priority_ad_frame = base::FeatureList::IsEnabled(kLowPriorityForAdFrame);
   best_effort_ad_frame =
       base::FeatureList::IsEnabled(kBestEffortPriorityForAdFrame);
+  use_adframe_priorities_only_during_loading =
+      base::FeatureList::IsEnabled(kAdFrameExperimentOnlyWhenLoading);
 
   low_priority_cross_origin =
       base::FeatureList::IsEnabled(kLowPriorityForCrossOrigin);
+  low_priority_cross_origin_only_during_loading =
+      base::FeatureList::IsEnabled(kLowPriorityForCrossOriginOnlyWhenLoading);
 
   use_resource_fetch_priority =
       base::FeatureList::IsEnabled(kUseResourceFetchPriority);
+  use_resource_priorities_only_during_loading =
+      base::FeatureList::IsEnabled(kUseResourceFetchPriorityOnlyWhenLoading);
 
-  if (use_resource_fetch_priority) {
+  if (use_resource_fetch_priority ||
+      use_resource_priorities_only_during_loading) {
     std::map<std::string, std::string> params;
     base::GetFieldTrialParams(kResourceFetchPriorityExperiment, &params);
     for (size_t net_priority = 0;
@@ -603,9 +612,6 @@ MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {
     }
   }
 
-  experiment_only_when_loading =
-      base::FeatureList::IsEnabled(kExperimentOnlyWhenLoading);
-
   FrameSchedulerImpl::InitializeTaskTypeQueueTraitsMap(
       frame_task_types_to_queue_traits);
 }

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

@@ -100,16 +100,24 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
     bool low_priority_subframe_throttleable;
     bool low_priority_hidden_frame;
 
+    // Used along with |low_priority_subframe|, |low_priority_throttleable|,
+    // |low_priority_subframe_throttleable|, |low_priority_hidden_frame|
+    // to enable one of these experiments during the loading phase only.
+    bool use_frame_priorities_only_during_loading;
+
     // Ads priority experiment (crbug.com/856150).
     bool low_priority_ad_frame;
     bool best_effort_ad_frame;
+    bool use_adframe_priorities_only_during_loading;
 
     // Origin type priority experiment (crbug.com/856158).
     bool low_priority_cross_origin;
+    bool low_priority_cross_origin_only_during_loading;
 
     // Use resource fetch priority for resource loading tasks
     // (crbug.com/860545).
     bool use_resource_fetch_priority;
+    bool use_resource_priorities_only_during_loading;
 
     // Contains a mapping from net::RequestPriority to TaskQueue::QueuePriority
     // when use_resource_fetch_priority is enabled.