Skip to content

GitLab

T
tangled
Commit 84e15aa2 authored by Tal Pressman's avatar Tal Pressman Committed by Commit Bot
Browse files
Options

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: default avatarScott Haseley <shaseley@chromium.org>
Reviewed-by: default avatarKouhei Ueno <kouhei@chromium.org>
Reviewed-by: default avatarAlexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#756946}
parent 853d7a68
Show whitespace changes
Inline Side-by-side
Showing with 36 additions and 292 deletions
third_party/blink/renderer/platform/scheduler/BUILD.gn
View file @ 84e15aa2
......@@ -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
View file @ 84e15aa2
......@@ -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
View file @ 84e15aa2
......@@ -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
View file @ 84e15aa2
......@@ -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;
......@@ -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
View file @ 84e15aa2
......@@ -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;
......@@ -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 deleted 100644 → 0
View file @ 853d7a68
// 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 deleted 100644 → 0
View file @ 853d7a68
// 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_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment