[scheduler] Experiment with prioritizing the compositor.

The first two experiments with compositing priorities:

+ Always set compositing priority to VeryHigh (unless it already is set to Highest).
+ Set compositing priority to VeryHigh when compositing is fast (unless it already is set to Highest).

Bug: 966177
Change-Id: Ic871b307de5caebad34dcda66f8d1ee360411df4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1626020
Commit-Queue: Katie Dillon <kdillon@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Scott Haseley <shaseley@chromium.org>
Cr-Commit-Position: refs/heads/master@{#664597}

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

@@ -50,6 +50,18 @@ const base::Feature kUseWillBeginMainFrameForCompositingPrioritization{
     "BlinkSchedulerUseWillBeginMainFrameForCompositingPrioritization",
     base::FEATURE_DISABLED_BY_DEFAULT};
 
+// If enabled, the compositor will always be set to kVeryHighPriority if it
+// is not already set to kHighestPriority.
+const base::Feature kVeryHighPriorityForCompositingAlways{
+    "BlinkSchedulerVeryHighPriorityForCompositingAlways",
+    base::FEATURE_DISABLED_BY_DEFAULT};
+
+// If enabled, compositor priority will be set to kVeryHighPriority if it will
+// be fast and is not already set to kHighestPriority.
+const base::Feature kVeryHighPriorityForCompositingWhenFast{
+    "BlinkSchedulerVeryHighPriorityForCompositingWhenFast",
+    base::FEATURE_DISABLED_BY_DEFAULT};
+
 // LOAD PRIORITY EXPERIMENT CONTROLS
 
 // Enables setting the priority of background (with no audio) pages'

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

@@ -563,6 +563,11 @@ MainThreadSchedulerImpl::SchedulingSettings::SchedulingSettings() {
   use_resource_priorities_only_during_loading =
       base::FeatureList::IsEnabled(kUseResourceFetchPriorityOnlyWhenLoading);
 
+  compositor_very_high_priority_always =
+      base::FeatureList::IsEnabled(kVeryHighPriorityForCompositingAlways);
+  compositor_very_high_priority_when_fast =
+      base::FeatureList::IsEnabled(kVeryHighPriorityForCompositingWhenFast);
+
   if (use_resource_fetch_priority ||
       use_resource_priorities_only_during_loading) {
     base::FieldTrialParams params;
@@ -1490,6 +1495,21 @@ void MainThreadSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
       NOTREACHED();
   }
 
+  if (scheduling_settings_.compositor_very_high_priority_always &&
+      new_policy.compositor_priority() !=
+          TaskQueue::QueuePriority::kHighestPriority) {
+    new_policy.compositor_priority() =
+        TaskQueue::QueuePriority::kVeryHighPriority;
+  }
+
+  if (scheduling_settings_.compositor_very_high_priority_when_fast &&
+      main_thread_compositing_is_fast &&
+      new_policy.compositor_priority() !=
+          TaskQueue::QueuePriority::kHighestPriority) {
+    new_policy.compositor_priority() =
+        TaskQueue::QueuePriority::kVeryHighPriority;
+  }
+
   // TODO(skyostil): Add an idle state for foreground tabs too.
   if (main_thread_only().renderer_hidden)
     new_policy.rail_mode() = RAILMode::kIdle;

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

@@ -121,6 +121,10 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
     bool use_resource_fetch_priority;
     bool use_resource_priorities_only_during_loading;
 
+    // Compositor priority experiment (crbug.com/966177).
+    bool compositor_very_high_priority_always;
+    bool compositor_very_high_priority_when_fast;
+
     // Contains a mapping from net::RequestPriority to TaskQueue::QueuePriority
     // when use_resource_fetch_priority is enabled.
     std::array<base::sequence_manager::TaskQueue::QueuePriority,

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

@@ -3620,6 +3620,83 @@ TEST_F(MainThreadSchedulerImplTest, MicrotaskCheckpointTiming) {
             observer.result().front().second);
 }
 
+class VeryHighPriorityForCompositingAlwaysExperimentTest
+    : public MainThreadSchedulerImplTest {
+ public:
+  VeryHighPriorityForCompositingAlwaysExperimentTest()
+      : MainThreadSchedulerImplTest({kVeryHighPriorityForCompositingAlways},
+                                    {}) {}
+};
+
+TEST_F(VeryHighPriorityForCompositingAlwaysExperimentTest,
+       TestCompositorPolicy) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
+
+  EnableIdleTasks();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("P1"), std::string("C1"),
+                                   std::string("C2"), std::string("D1"),
+                                   std::string("D2"), std::string("I1")));
+  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
+}
+
+class VeryHighPriorityForCompositingWhenFastExperimentTest
+    : public MainThreadSchedulerImplTest {
+ public:
+  VeryHighPriorityForCompositingWhenFastExperimentTest()
+      : MainThreadSchedulerImplTest({kVeryHighPriorityForCompositingWhenFast},
+                                    {}) {}
+};
+
+TEST_F(VeryHighPriorityForCompositingWhenFastExperimentTest,
+       TestCompositorPolicy_FastCompositing) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
+
+  EnableIdleTasks();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("P1"), std::string("C1"),
+                                   std::string("C2"), std::string("D1"),
+                                   std::string("D2"), std::string("I1")));
+  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
+}
+
+TEST_F(VeryHighPriorityForCompositingWhenFastExperimentTest,
+       TestCompositorPolicy_SlowCompositing) {
+  RunSlowCompositorTask();
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "I1 D1 C1 D2 C2 P1");
+
+  EnableIdleTasks();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("P1"), std::string("D1"),
+                                   std::string("C1"), std::string("D2"),
+                                   std::string("C2"), std::string("I1")));
+  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
+}
+
+TEST_F(VeryHighPriorityForCompositingWhenFastExperimentTest,
+       TestCompositorPolicy_CompositingStaysAtHighest) {
+  std::vector<std::string> run_order;
+  PostTestTasks(&run_order, "L1 I1 D1 C1 D2 P1 C2");
+
+  scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
+  EnableIdleTasks();
+  SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
+                                 blink::WebInputEvent::kGestureScrollBegin);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("C1"), std::string("P1"),
+                                   std::string("C2"), std::string("L1"),
+                                   std::string("D1"), std::string("D2"),
+                                   std::string("I1")));
+  EXPECT_EQ(UseCase::kMainThreadCustomInputHandling, CurrentUseCase());
+}
+
 }  // namespace main_thread_scheduler_impl_unittest
 }  // namespace scheduler
 }  // namespace blink