Cleanup BlinkSchedulerPrioritizeCompositingAfterInput experiment.

The experiment had positive results, so it is being enabled going
forward.

Change-Id: I68caf49902b0f24770c27f76541beba450c1321e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2132022
Commit-Queue: Tal Pressman <talp@chromium.org>
Reviewed-by: Scott Haseley <shaseley@chromium.org>
Reviewed-by: Kouhei Ueno <kouhei@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#756946}

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -99,8 +99,6 @@ blink_platform_sources("scheduler") {
     "main_thread/page_visibility_state.h",
     "main_thread/pending_user_input.cc",
     "main_thread/pending_user_input.h",
-    "main_thread/prioritize_compositing_after_input_experiment.cc",
-    "main_thread/prioritize_compositing_after_input_experiment.h",
     "main_thread/queueing_time_estimator.cc",
     "main_thread/queueing_time_estimator.h",
     "main_thread/render_widget_signals.cc",

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

@@ -25,33 +25,6 @@ const base::Feature kBestEffortPriorityForFindInPage{
 
 // COMPOSITING PRIORITY EXPERIMENT CONTROLS
 
-// Enables experiment to increase priority of the compositing tasks during
-// input handling. Other features in this section do not have any effect
-// when this feature is disabled.
-const base::Feature kPrioritizeCompositingAfterInput{
-    "BlinkSchedulerPrioritizeCompositingAfterInput",
-    base::FEATURE_DISABLED_BY_DEFAULT};
-
-// Use kHighestPriority for compositing tasks during the experiment.
-// kHighPriority is used otherwise.
-const base::Feature kHighestPriorityForCompositingAfterInput{
-    "BlinkSchedulerHighestPriorityForCompostingAfterInput",
-    base::FEATURE_DISABLED_BY_DEFAULT};
-
-// If enabled, MainFrameSchedulerImpl::OnRequestMainFrameForInput is used as
-// triggering signal for the experiment. If disabled, the presence of an input
-// task is used as trigger.
-const base::Feature kUseExplicitSignalForTriggeringCompositingPrioritization{
-    "BlinkSchedulerUseExplicitSignalForTriggeringCompositingPrioritization",
-    base::FEATURE_DISABLED_BY_DEFAULT};
-
-// If enabled, the increased priority continues until we get the appropriate
-// number of WillBeginMainFrame signals. If disabled, the priority is increased
-// for the fixed number of compositing tasks.
-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{

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

@@ -395,12 +395,6 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
           main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
-      have_seen_a_begin_main_frame(
-          false,
-          "Scheduler.HasSeenBeginMainFrame",
-          main_thread_scheduler_impl,
-          &main_thread_scheduler_impl->tracing_controller_,
-          YesNoStateToString),
       have_reported_blocking_intervention_in_current_policy(
           false,
           "Scheduler.HasReportedBlockingInterventionInCurrentPolicy",
@@ -419,12 +413,6 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
           main_thread_scheduler_impl,
           &main_thread_scheduler_impl->tracing_controller_,
           YesNoStateToString),
-      begin_frame_not_expected_soon(
-          false,
-          "Scheduler.BeginFrameNotExpectedSoon",
-          main_thread_scheduler_impl,
-          &main_thread_scheduler_impl->tracing_controller_,
-          YesNoStateToString),
       in_idle_period_for_testing(
           false,
           "Scheduler.InIdlePeriod",
@@ -486,8 +474,12 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
       max_virtual_time_task_starvation_count(0),
       virtual_time_stopped(false),
       nested_runloop(false),
-      compositing_experiment(main_thread_scheduler_impl),
-      should_prioritize_compositing(false),
+      prioritize_compositing_after_input(
+          false,
+          "Scheduler.PrioritizeCompositingAfterInput",
+          main_thread_scheduler_impl,
+          &main_thread_scheduler_impl->tracing_controller_,
+          YesNoStateToString),
       compositor_priority_experiments(main_thread_scheduler_impl),
       main_thread_compositing_is_fast(false) {}
 
@@ -817,6 +809,9 @@ void MainThreadSchedulerImpl::RemoveTaskObserver(
 }
 
 void MainThreadSchedulerImpl::WillBeginFrame(const viz::BeginFrameArgs& args) {
+  // TODO(crbug/1068426): Figure out when and if |UpdatePolicy| should be called
+  //  and, if needed, remove the call to it from
+  //  |SetPrioritizeCompositingAfterInput|.
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "MainThreadSchedulerImpl::WillBeginFrame", "args",
                args.AsValue());
@@ -827,14 +822,12 @@ void MainThreadSchedulerImpl::WillBeginFrame(const viz::BeginFrameArgs& args) {
   EndIdlePeriod();
   main_thread_only().estimated_next_frame_begin =
       args.frame_time + args.interval;
-  main_thread_only().have_seen_a_begin_main_frame = true;
-  main_thread_only().begin_frame_not_expected_soon = false;
   main_thread_only().compositor_frame_interval = args.interval;
   {
     base::AutoLock lock(any_thread_lock_);
     any_thread().begin_main_frame_on_critical_path = args.on_critical_path;
   }
-  main_thread_only().compositing_experiment.OnWillBeginMainFrame();
+  SetPrioritizeCompositingAfterInput(false);
   main_thread_only().compositor_priority_experiments.OnWillBeginMainFrame();
 }
 
@@ -858,13 +851,13 @@ void MainThreadSchedulerImpl::DidCommitFrameToCompositor() {
 }
 
 void MainThreadSchedulerImpl::BeginFrameNotExpectedSoon() {
+  // TODO(crbug/1068426): Should this call |UpdatePolicy|?
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "MainThreadSchedulerImpl::BeginFrameNotExpectedSoon");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
-  main_thread_only().begin_frame_not_expected_soon = true;
   idle_helper_.EnableLongIdlePeriod();
   {
     base::AutoLock lock(any_thread_lock_);
@@ -1000,7 +993,7 @@ void MainThreadSchedulerImpl::SetSchedulerKeepActive(bool keep_active) {
 }
 
 void MainThreadSchedulerImpl::OnMainFrameRequestedForInput() {
-  main_thread_only().compositing_experiment.OnMainFrameRequestedForInput();
+  SetPrioritizeCompositingAfterInput(true);
 }
 
 bool MainThreadSchedulerImpl::SchedulerKeepActive() {
@@ -1498,10 +1491,9 @@ void MainThreadSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
       NOTREACHED();
   }
 
-  if (main_thread_only().should_prioritize_compositing) {
+  if (main_thread_only().prioritize_compositing_after_input) {
     new_policy.compositor_priority() =
-        main_thread_only()
-            .compositing_experiment.GetIncreasedCompositingPriority();
+        base::sequence_manager::TaskQueue::QueuePriority::kVeryHighPriority;
   } else if (scheduling_settings_
                  .prioritize_compositing_and_loading_during_early_loading &&
              current_use_case() == UseCase::kEarlyLoading) {
@@ -1978,8 +1970,6 @@ void MainThreadSchedulerImpl::AsValueIntoLocked(
       main_thread_only().has_visible_render_widget_with_touch_handler);
   state->SetString("current_use_case",
                    UseCaseToString(main_thread_only().current_use_case));
-  state->SetBoolean("begin_frame_not_expected_soon",
-                    main_thread_only().begin_frame_not_expected_soon);
   state->SetBoolean(
       "compositor_will_send_main_frame_not_expected",
       main_thread_only().compositor_will_send_main_frame_not_expected);
@@ -1989,8 +1979,6 @@ void MainThreadSchedulerImpl::AsValueIntoLocked(
                    IdleHelper::IdlePeriodStateToString(
                        idle_helper_.SchedulerIdlePeriodState()));
   state->SetBoolean("renderer_hidden", main_thread_only().renderer_hidden);
-  state->SetBoolean("have_seen_a_begin_main_frame",
-                    main_thread_only().have_seen_a_begin_main_frame);
   state->SetBoolean("waiting_for_contentful_paint",
                     any_thread().waiting_for_contentful_paint);
   state->SetBoolean("waiting_for_meaningful_paint",
@@ -2244,7 +2232,6 @@ void MainThreadSchedulerImpl::ResetForNavigationLocked() {
   any_thread().waiting_for_meaningful_paint = true;
   any_thread().have_seen_input_since_navigation = false;
   main_thread_only().idle_time_estimator.Clear();
-  main_thread_only().have_seen_a_begin_main_frame = false;
   main_thread_only().have_reported_blocking_intervention_since_navigation =
       false;
   for (PageSchedulerImpl* page_scheduler : main_thread_only().page_schedulers) {
@@ -2484,8 +2471,6 @@ void MainThreadSchedulerImpl::OnTaskCompleted(
         queue.get(), task_timing->start_time(), task_timing->end_time());
   }
 
-  main_thread_only().compositing_experiment.OnTaskCompleted(queue.get());
-
   // TODO(altimin): Per-page metrics should also be considered.
   main_thread_only().metrics_helper.RecordTaskMetrics(queue.get(), task,
                                                       *task_timing);
@@ -2769,14 +2754,14 @@ MainThreadSchedulerImpl::scheduling_settings() const {
   return scheduling_settings_;
 }
 
-void MainThreadSchedulerImpl::SetShouldPrioritizeCompositing(
-    bool should_prioritize_compositing) {
-  if (main_thread_only().should_prioritize_compositing ==
-      should_prioritize_compositing) {
+void MainThreadSchedulerImpl::SetPrioritizeCompositingAfterInput(
+    bool prioritize_compositing_after_input) {
+  if (main_thread_only().prioritize_compositing_after_input ==
+      prioritize_compositing_after_input) {
     return;
   }
-  main_thread_only().should_prioritize_compositing =
-      should_prioritize_compositing;
+  main_thread_only().prioritize_compositing_after_input =
+      prioritize_compositing_after_input;
   UpdatePolicy();
 }
 

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

@@ -41,7 +41,6 @@
 #include "third_party/blink/renderer/platform/scheduler/main_thread/non_waking_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/pending_user_input.h"
-#include "third_party/blink/renderer/platform/scheduler/main_thread/prioritize_compositing_after_input_experiment.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/queueing_time_estimator.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/render_widget_signals.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/use_case.h"
@@ -396,7 +395,8 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
 
   const SchedulingSettings& scheduling_settings() const;
 
-  void SetShouldPrioritizeCompositing(bool should_prioritize_compositing);
+  void SetPrioritizeCompositingAfterInput(
+      bool prioritize_compositing_after_input);
 
   void OnCompositorPriorityExperimentUpdateCompositorPriority();
 
@@ -884,16 +884,12 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
         keep_active_fetch_or_worker;
     TraceableState<bool, TracingCategoryName::kDefault>
         blocking_input_expected_soon;
-    TraceableState<bool, TracingCategoryName::kDebug>
-        have_seen_a_begin_main_frame;
     TraceableState<bool, TracingCategoryName::kDebug>
         have_reported_blocking_intervention_in_current_policy;
     TraceableState<bool, TracingCategoryName::kDebug>
         have_reported_blocking_intervention_since_navigation;
     TraceableState<bool, TracingCategoryName::kDebug>
         has_visible_render_widget_with_touch_handler;
-    TraceableState<bool, TracingCategoryName::kDebug>
-        begin_frame_not_expected_soon;
     TraceableState<bool, TracingCategoryName::kDebug>
         in_idle_period_for_testing;
     TraceableState<bool, TracingCategoryName::kInfo> use_virtual_time;
@@ -907,8 +903,8 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
     base::TimeTicks background_status_changed_at;
     HashSet<PageSchedulerImpl*> page_schedulers;  // Not owned.
     base::ObserverList<RAILModeObserver>::Unchecked
-        rail_mode_observers;                                      // Not owned.
-    WakeUpBudgetPool* wake_up_budget_pool;                        // Not owned.
+        rail_mode_observers;                // Not owned.
+    WakeUpBudgetPool* wake_up_budget_pool;  // Not owned.
     MainThreadMetricsHelper metrics_helper;
     TraceableState<WebRendererProcessType, TracingCategoryName::kTopLevel>
         process_type;
@@ -948,9 +944,11 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
     // True if a nested RunLoop is running.
     bool nested_runloop;
 
-    // High-priority for compositing events after input experiment.
-    PrioritizeCompositingAfterInputExperiment compositing_experiment;
-    bool should_prioritize_compositing;
+    // High-priority for compositing events after input. This will cause
+    // compositing events get a higher priority until the start of the next
+    // animation frame.
+    TraceableState<bool, TracingCategoryName::kDefault>
+        prioritize_compositing_after_input;
 
     // List of callbacks to execute after the current task.
     WTF::Vector<base::OnceClosure> on_task_completion_callbacks;

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

@@ -323,8 +323,7 @@ class MainThreadSchedulerImplTest : public testing::Test {
     feature_list_.InitWithFeatures(features_to_enable, features_to_disable);
   }
 
-  MainThreadSchedulerImplTest()
-      : MainThreadSchedulerImplTest({}, {kPrioritizeCompositingAfterInput}) {}
+  MainThreadSchedulerImplTest() : MainThreadSchedulerImplTest({}, {}) {}
 
   ~MainThreadSchedulerImplTest() override = default;
 
@@ -376,7 +375,7 @@ class MainThreadSchedulerImplTest : public testing::Test {
     loading_control_task_runner_ =
         main_frame_scheduler_->FrameTaskQueueControllerForTest()
             ->GetTaskQueue(
-             main_frame_scheduler_->LoadingControlTaskQueueTraits())
+                main_frame_scheduler_->LoadingControlTaskQueueTraits())
             ->task_runner();
     timer_task_runner_ = timer_task_queue()->task_runner();
     find_in_page_task_runner_ = main_frame_scheduler_->GetTaskRunner(
@@ -386,15 +385,15 @@ class MainThreadSchedulerImplTest : public testing::Test {
   TaskQueue* loading_task_queue() {
     auto queue_traits = FrameSchedulerImpl::LoadingTaskQueueTraits();
     return main_frame_scheduler_->FrameTaskQueueControllerForTest()
-        ->GetTaskQueue(queue_traits).get();
+        ->GetTaskQueue(queue_traits)
+        .get();
   }
 
   TaskQueue* timer_task_queue() {
     auto* frame_task_queue_controller =
         main_frame_scheduler_->FrameTaskQueueControllerForTest();
     return frame_task_queue_controller
-        ->GetTaskQueue(
-            main_frame_scheduler_->ThrottleableTaskQueueTraits())
+        ->GetTaskQueue(main_frame_scheduler_->ThrottleableTaskQueueTraits())
         .get();
   }
 
@@ -645,18 +644,10 @@ class MainThreadSchedulerImplTest : public testing::Test {
     return scheduler_->main_thread_only().current_policy.rail_mode();
   }
 
-  bool BeginFrameNotExpectedSoon() {
-    return scheduler_->main_thread_only().begin_frame_not_expected_soon;
-  }
-
   bool BlockingInputExpectedSoon() {
     return scheduler_->main_thread_only().blocking_input_expected_soon;
   }
 
-  bool HaveSeenABeginMainframe() {
-    return scheduler_->main_thread_only().have_seen_a_begin_main_frame;
-  }
-
   base::TimeTicks EstimatedNextFrameBegin() {
     return scheduler_->main_thread_only().estimated_next_frame_begin;
   }
@@ -1326,9 +1317,7 @@ TEST_F(MainThreadSchedulerImplTest, TestTouchstartPolicy_MainThread) {
 
 class DefaultUseCaseTest : public MainThreadSchedulerImplTest {
  public:
-  DefaultUseCaseTest() : MainThreadSchedulerImplTest({}, {}) {
-    initially_ensure_usecase_none_ = false;
-  }
+  DefaultUseCaseTest() { initially_ensure_usecase_none_ = false; }
 };
 
 TEST_F(DefaultUseCaseTest, InitiallyInEarlyLoadingUseCase) {
@@ -2868,7 +2857,6 @@ TEST_F(MainThreadSchedulerImplTest, TestAnimateRAILMode) {
   scheduler_->AddRAILModeObserver(&observer);
   EXPECT_CALL(observer, OnRAILModeChanged(RAILMode::kAnimation)).Times(0);
 
-  EXPECT_FALSE(BeginFrameNotExpectedSoon());
   EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_EQ(RAILMode::kAnimation, GetRAILMode());
   scheduler_->RemoveRAILModeObserver(&observer);
@@ -3399,18 +3387,7 @@ TEST_F(MainThreadSchedulerImplWithInitalVirtualTimeTest, VirtualTimeOverride) {
   EXPECT_EQ(base::Time::Now(), base::Time::FromJsTime(1000000.0));
 }
 
-class CompositingExperimentWithExplicitSignalsTest
-    : public MainThreadSchedulerImplTest {
- public:
-  CompositingExperimentWithExplicitSignalsTest()
-      : MainThreadSchedulerImplTest(
-            {kPrioritizeCompositingAfterInput,
-             kUseExplicitSignalForTriggeringCompositingPrioritization,
-             kUseWillBeginMainFrameForCompositingPrioritization},
-            {}) {}
-};
-
-TEST_F(CompositingExperimentWithExplicitSignalsTest, CompositingAfterInput) {
+TEST_F(MainThreadSchedulerImplTest, CompositingAfterInput) {
   Vector<String> run_order;
   PostTestTasks(&run_order, "P1 T1 C1");
   base::RunLoop().RunUntilIdle();
@@ -3435,25 +3412,6 @@ TEST_F(CompositingExperimentWithExplicitSignalsTest, CompositingAfterInput) {
   run_order.clear();
 }
 
-class CompositingExperimentWithImplicitSignalsTest
-    : public MainThreadSchedulerImplTest {
- public:
-  CompositingExperimentWithImplicitSignalsTest()
-      : MainThreadSchedulerImplTest(
-            {kPrioritizeCompositingAfterInput},
-            {kHighestPriorityForCompositingAfterInput,
-             kUseExplicitSignalForTriggeringCompositingPrioritization,
-             kUseWillBeginMainFrameForCompositingPrioritization}) {}
-};
-
-TEST_F(CompositingExperimentWithImplicitSignalsTest, CompositingAfterInput) {
-  Vector<String> run_order;
-  PostTestTasks(&run_order, "T1 C1 C2 P1 P2");
-  base::RunLoop().RunUntilIdle();
-  // One compositing task should be prioritized after input.
-  EXPECT_THAT(run_order, testing::ElementsAre("P1", "P2", "C1", "T1", "C2"));
-}
-
 TEST_F(MainThreadSchedulerImplTest, EQTWithNestedLoop) {
   AdvanceMockTickClockBy(base::TimeDelta::FromMilliseconds(100));
 

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

-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/renderer/platform/scheduler/main_thread/prioritize_compositing_after_input_experiment.h"
-
-#include "base/metrics/field_trial_params.h"
-#include "base/strings/string_number_conversions.h"
-#include "third_party/blink/renderer/platform/scheduler/common/features.h"
-#include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
-#include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h"
-
-namespace blink {
-namespace scheduler {
-
-namespace {
-
-// Prioritize compositing after input trial.
-constexpr const char kPrioritizeCompositingAfterInputTrial[] =
-    "BlinkSchedulerPrioritizeCompositingAfterInput";
-constexpr const char kNumberOfCompositingTasksToPrioritizeAfterInputParam[] =
-    "number_of_tasks";
-
-constexpr int kDefaultNumberOfTasksToPrioritizeAfterInput = 1;
-
-int GetNumberOfCompositingTasksToPrioritizeAfterInput() {
-  if (!base::FeatureList::IsEnabled(kPrioritizeCompositingAfterInput))
-    return 0;
-  int number_of_tasks;
-  if (!base::StringToInt(
-          base::GetFieldTrialParamValue(
-              kPrioritizeCompositingAfterInputTrial,
-              kNumberOfCompositingTasksToPrioritizeAfterInputParam),
-          &number_of_tasks)) {
-    return kDefaultNumberOfTasksToPrioritizeAfterInput;
-  }
-  return number_of_tasks;
-}
-
-}  // namespace
-
-PrioritizeCompositingAfterInputExperiment::
-    PrioritizeCompositingAfterInputExperiment(
-        MainThreadSchedulerImpl* scheduler)
-    : scheduler_(scheduler),
-      increased_compositing_priority_(
-          base::FeatureList::IsEnabled(kHighestPriorityForCompositingAfterInput)
-              ? base::sequence_manager::TaskQueue::QueuePriority::
-                    kHighestPriority
-              : base::sequence_manager::TaskQueue::QueuePriority::
-                    kHighPriority),
-      number_of_tasks_to_prioritize_after_input_(
-          GetNumberOfCompositingTasksToPrioritizeAfterInput()),
-      trigger_type_(
-          base::FeatureList::IsEnabled(
-              kUseExplicitSignalForTriggeringCompositingPrioritization)
-              ? TriggerType::kExplicitSignal
-              : TriggerType::kInferredFromInput),
-      stop_signal_type_(base::FeatureList::IsEnabled(
-                            kUseWillBeginMainFrameForCompositingPrioritization)
-                            ? StopSignalType::kWillBeginMainFrameSignal
-                            : StopSignalType::kAllCompositingTasks),
-      number_of_tasks_to_prioritize_(0) {}
-
-PrioritizeCompositingAfterInputExperiment::
-    ~PrioritizeCompositingAfterInputExperiment() {}
-
-void PrioritizeCompositingAfterInputExperiment::
-    SetNumberOfCompositingTasksToPrioritize(int number_of_tasks) {
-  number_of_tasks = std::max(number_of_tasks, 0);
-  bool did_prioritize_compositing = number_of_tasks_to_prioritize_ > 0;
-  number_of_tasks_to_prioritize_ = number_of_tasks;
-  bool should_prioritize_compositing = number_of_tasks_to_prioritize_ > 0;
-  if (did_prioritize_compositing != should_prioritize_compositing)
-    scheduler_->SetShouldPrioritizeCompositing(should_prioritize_compositing);
-}
-
-base::sequence_manager::TaskQueue::QueuePriority
-PrioritizeCompositingAfterInputExperiment::GetIncreasedCompositingPriority() {
-  return increased_compositing_priority_;
-}
-
-void PrioritizeCompositingAfterInputExperiment::OnTaskCompleted(
-    MainThreadTaskQueue* queue) {
-  if (!queue)
-    return;
-  if (queue->queue_type() == MainThreadTaskQueue::QueueType::kInput &&
-      trigger_type_ == TriggerType::kInferredFromInput) {
-    SetNumberOfCompositingTasksToPrioritize(
-        number_of_tasks_to_prioritize_after_input_);
-  } else if (queue->queue_type() ==
-                 MainThreadTaskQueue::QueueType::kCompositor &&
-             stop_signal_type_ == StopSignalType::kAllCompositingTasks) {
-    SetNumberOfCompositingTasksToPrioritize(number_of_tasks_to_prioritize_ - 1);
-  }
-}
-
-void PrioritizeCompositingAfterInputExperiment::OnWillBeginMainFrame() {
-  if (stop_signal_type_ != StopSignalType::kWillBeginMainFrameSignal)
-    return;
-  SetNumberOfCompositingTasksToPrioritize(number_of_tasks_to_prioritize_ - 1);
-}
-
-void PrioritizeCompositingAfterInputExperiment::OnMainFrameRequestedForInput() {
-  if (trigger_type_ != TriggerType::kExplicitSignal)
-    return;
-  SetNumberOfCompositingTasksToPrioritize(
-      number_of_tasks_to_prioritize_after_input_);
-}
-
-}  // namespace scheduler
-}  // namespace blink

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

-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_PRIORITIZE_COMPOSITING_AFTER_INPUT_EXPERIMENT_H_
-#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_PRIORITIZE_COMPOSITING_AFTER_INPUT_EXPERIMENT_H_
-
-#include "base/task/sequence_manager/task_queue.h"
-#include "third_party/blink/renderer/platform/platform_export.h"
-#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
-
-namespace blink {
-namespace scheduler {
-
-class MainThreadSchedulerImpl;
-class MainThreadTaskQueue;
-
-class PLATFORM_EXPORT PrioritizeCompositingAfterInputExperiment {
-  DISALLOW_NEW();
-
- public:
-  explicit PrioritizeCompositingAfterInputExperiment(
-      MainThreadSchedulerImpl* scheduler);
-  ~PrioritizeCompositingAfterInputExperiment();
-
-  base::sequence_manager::TaskQueue::QueuePriority
-  GetIncreasedCompositingPriority();
-
-  void OnTaskCompleted(MainThreadTaskQueue* queue);
-
-  void OnWillBeginMainFrame();
-
-  void OnMainFrameRequestedForInput();
-
- private:
-  enum class TriggerType { kExplicitSignal, kInferredFromInput };
-
-  enum class StopSignalType { kAllCompositingTasks, kWillBeginMainFrameSignal };
-
-  void SetNumberOfCompositingTasksToPrioritize(int number_of_tasks);
-
-  MainThreadSchedulerImpl* scheduler_;  // Not owned.
-
-  const base::sequence_manager::TaskQueue::QueuePriority
-      increased_compositing_priority_;
-  const int number_of_tasks_to_prioritize_after_input_;
-  const TriggerType trigger_type_;
-  const StopSignalType stop_signal_type_;
-
-  int number_of_tasks_to_prioritize_;
-};
-
-}  // namespace scheduler
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_MAIN_THREAD_PRIORITIZE_COMPOSITING_AFTER_INPUT_EXPERIMENT_H_