0

[v8] Differentiate between UserVisible and BestEffort task runners

This is a no-op since there are no use of BestEffort yet.

Change-Id: Ie4bd672f6a82fe1f22df065cf8f5527f43eaade9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5829085
Commit-Queue: Etienne Pierre-Doray <etiennep@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Francois Pierre Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1351025}
This commit is contained in:
Etienne Pierre-doray
2024-09-04 20:26:27 +00:00
committed by Chromium LUCI CQ
parent 3e1e041f5c
commit 8e42980ed5
21 changed files with 123 additions and 57 deletions

@ -768,9 +768,10 @@ message RendererMainThreadTaskExecution {
TASK_TYPE_LOW_PRIORITY_SCRIPT_EXECUTION = 81;
TASK_TYPE_STORAGE = 82;
TASK_TYPE_NETWORKING_UNFREEZABLE_RENDER_BLOCKING_LOADING = 83;
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_LOW_PRIORITY = 84;
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_USER_VISIBLE = 84;
TASK_TYPE_CLIPBOARD = 85;
TASK_TYPE_MACHINE_LEARNING = 86;
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_BEST_EFFORT = 87;
}
enum FrameType {
@ -978,7 +979,8 @@ message SequenceManagerTask {
UI_BEFORE_UNLOAD_BROWSER_RESPONSE_TQ = 54;
IO_BEFORE_UNLOAD_BROWSER_RESPONSE_TQ = 55;
V8_LOW_PRIORITY_TQ = 56;
V8_USER_VISIBLE_TQ = 56;
V8_BEST_EFFORT_TQ = 57;
}
optional Priority priority = 1;

@ -75,7 +75,8 @@ IsolateHolder::IsolateHolder(
IsolateCreationMode isolate_creation_mode,
v8::CreateHistogramCallback create_histogram_callback,
v8::AddHistogramSampleCallback add_histogram_sample_callback,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner)
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner)
: IsolateHolder(std::move(task_runner),
access_mode,
isolate_type,
@ -84,7 +85,8 @@ IsolateHolder::IsolateHolder(
create_histogram_callback,
add_histogram_sample_callback),
isolate_creation_mode,
std::move(low_priority_task_runner)) {}
std::move(user_visible_task_runner),
std::move(best_effort_task_runner)) {}
IsolateHolder::IsolateHolder(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@ -92,7 +94,8 @@ IsolateHolder::IsolateHolder(
IsolateType isolate_type,
std::unique_ptr<v8::Isolate::CreateParams> params,
IsolateCreationMode isolate_creation_mode,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner)
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner)
: access_mode_(access_mode), isolate_type_(isolate_type) {
CHECK(Initialized())
<< "You need to invoke gin::IsolateHolder::Initialize first";
@ -106,7 +109,7 @@ IsolateHolder::IsolateHolder(
isolate_ = v8::Isolate::Allocate();
isolate_data_ = std::make_unique<PerIsolateData>(
isolate_, allocator, access_mode_, task_runner,
std::move(low_priority_task_runner));
std::move(user_visible_task_runner), std::move(best_effort_task_runner));
// TODO(crbug.com/40854483): Refactor such that caller need not
// provide params when creating a snapshot.
if (isolate_creation_mode == IsolateCreationMode::kCreateSnapshot) {

@ -44,16 +44,21 @@ PerIsolateData::PerIsolateData(
ArrayBuffer::Allocator* allocator,
IsolateHolder::AccessMode access_mode,
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner)
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner)
: isolate_(isolate), allocator_(allocator) {
isolate_->SetData(kEmbedderNativeGin, this);
DCHECK(task_runner);
task_runner_ = CreateV8ForegroundTaskRunner(isolate_, std::move(task_runner),
access_mode);
if (low_priority_task_runner) {
low_priority_task_runner_ = CreateV8ForegroundTaskRunner(
isolate_, std::move(low_priority_task_runner), access_mode);
if (user_visible_task_runner) {
user_visible_task_runner_ = CreateV8ForegroundTaskRunner(
isolate_, std::move(user_visible_task_runner), access_mode);
}
if (best_effort_task_runner) {
best_effort_task_runner_ = CreateV8ForegroundTaskRunner(
isolate_, std::move(best_effort_task_runner), access_mode);
}
}

@ -46,7 +46,8 @@ class GIN_EXPORT PerIsolateData {
v8::ArrayBuffer::Allocator* allocator,
IsolateHolder::AccessMode access_mode,
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner);
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner);
PerIsolateData(const PerIsolateData&) = delete;
PerIsolateData& operator=(const PerIsolateData&) = delete;
~PerIsolateData();
@ -94,8 +95,11 @@ class GIN_EXPORT PerIsolateData {
v8::Isolate* isolate() { return isolate_; }
v8::ArrayBuffer::Allocator* allocator() { return allocator_; }
std::shared_ptr<v8::TaskRunner> task_runner() { return task_runner_; }
std::shared_ptr<v8::TaskRunner> low_priority_task_runner() {
return low_priority_task_runner_;
std::shared_ptr<v8::TaskRunner> user_visible_task_runner() {
return user_visible_task_runner_;
}
std::shared_ptr<v8::TaskRunner> best_effort_task_runner() {
return best_effort_task_runner_;
}
private:
@ -118,7 +122,8 @@ class GIN_EXPORT PerIsolateData {
NamedPropertyInterceptorMap named_interceptors_;
base::ObserverList<DisposeObserver> dispose_observers_;
std::shared_ptr<V8ForegroundTaskRunnerBase> task_runner_;
std::shared_ptr<V8ForegroundTaskRunnerBase> low_priority_task_runner_;
std::shared_ptr<V8ForegroundTaskRunnerBase> user_visible_task_runner_;
std::shared_ptr<V8ForegroundTaskRunnerBase> best_effort_task_runner_;
};
} // namespace gin

@ -84,7 +84,9 @@ class GIN_EXPORT IsolateHolder {
IsolateCreationMode isolate_creation_mode = IsolateCreationMode::kNormal,
v8::CreateHistogramCallback create_histogram_callback = nullptr,
v8::AddHistogramSampleCallback add_histogram_sample_callback = nullptr,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner =
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner =
nullptr,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner =
nullptr);
IsolateHolder(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@ -92,7 +94,9 @@ class GIN_EXPORT IsolateHolder {
IsolateType isolate_type,
std::unique_ptr<v8::Isolate::CreateParams> params,
IsolateCreationMode isolate_creation_mode = IsolateCreationMode::kNormal,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner =
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner =
nullptr,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner =
nullptr);
IsolateHolder(const IsolateHolder&) = delete;
IsolateHolder& operator=(const IsolateHolder&) = delete;

@ -217,18 +217,22 @@ std::shared_ptr<v8::TaskRunner> V8Platform::GetForegroundTaskRunner(
v8::Isolate* isolate,
v8::TaskPriority priority) {
PerIsolateData* data = PerIsolateData::From(isolate);
if (!data->low_priority_task_runner()) {
return data->task_runner();
}
switch (priority) {
case v8::TaskPriority::kBestEffort:
// blink::scheduler::TaskPriority::kLowPriority
if (data->best_effort_task_runner()) {
return data->best_effort_task_runner();
}
[[fallthrough]];
case v8::TaskPriority::kUserVisible:
// blink::scheduler::TaskPriority::kLowPriority
if (data->user_visible_task_runner()) {
return data->user_visible_task_runner();
}
[[fallthrough]];
case v8::TaskPriority::kUserBlocking:
// blink::scheduler::TaskPriority::kDefaultPriority
return data->task_runner();
case v8::TaskPriority::kUserVisible:
case v8::TaskPriority::kBestEffort:
// blink::scheduler::TaskPriority::kLowPriority
return data->low_priority_task_runner();
default:
NOTREACHED_IN_MIGRATION() << "Unsupported TaskPriority.";
return data->task_runner();

@ -18,7 +18,7 @@ namespace blink {
// * Increment "Next value"
// * Update TaskTypes.md
//
// Next value: 87
// Next value: 88
enum class TaskType : unsigned char {
///////////////////////////////////////
// Speced tasks should use one of the following task types
@ -292,7 +292,8 @@ enum class TaskType : unsigned char {
// get a task queue/runner.
kMainThreadTaskQueueV8 = 37,
kMainThreadTaskQueueV8LowPriority = 84,
kMainThreadTaskQueueV8UserVisible = 84,
kMainThreadTaskQueueV8BestEffort = 87,
kMainThreadTaskQueueCompositor = 38,
kMainThreadTaskQueueDefault = 39,
kMainThreadTaskQueueInput = 40,
@ -311,7 +312,7 @@ enum class TaskType : unsigned char {
kWorkerThreadTaskQueueV8 = 47,
kWorkerThreadTaskQueueCompositor = 48,
kMaxValue = kMachineLearning,
kMaxValue = kMainThreadTaskQueueV8BestEffort,
};
} // namespace blink

@ -905,8 +905,9 @@ v8::Isolate* V8Initializer::InitializeMainThread() {
add_histogram_sample_callback = AddHistogramSample;
}
v8::Isolate* isolate = V8PerIsolateData::Initialize(
scheduler->V8TaskRunner(), scheduler->V8LowPriorityTaskRunner(),
snapshot_mode, create_histogram_callback, add_histogram_sample_callback);
scheduler->V8TaskRunner(), scheduler->V8UserVisibleTaskRunner(),
scheduler->V8BestEffortTaskRunner(), snapshot_mode,
create_histogram_callback, add_histogram_sample_callback);
scheduler->SetV8Isolate(isolate);
// ThreadState::isolate_ needs to be set before setting the EmbedderHeapTracer

@ -123,7 +123,8 @@ void WorkerBackingThread::InitializeOnBackingThread(
DCHECK(!isolate_);
ThreadScheduler* scheduler = BackingThread().Scheduler();
isolate_ = V8PerIsolateData::Initialize(
scheduler->V8TaskRunner(), scheduler->V8LowPriorityTaskRunner(),
scheduler->V8TaskRunner(), scheduler->V8UserVisibleTaskRunner(),
scheduler->V8BestEffortTaskRunner(),
V8PerIsolateData::V8ContextSnapshotMode::kDontUseSnapshot, nullptr,
nullptr);
scheduler->SetV8Isolate(isolate_);

@ -125,7 +125,8 @@ static bool AllowAtomicWaits(
V8PerIsolateData::V8PerIsolateData(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner,
V8ContextSnapshotMode v8_context_snapshot_mode,
v8::CreateHistogramCallback create_histogram_callback,
v8::AddHistogramSampleCallback add_histogram_sample_callback)
@ -144,7 +145,8 @@ V8PerIsolateData::V8PerIsolateData(
: gin::IsolateHolder::IsolateCreationMode::kNormal,
create_histogram_callback,
add_histogram_sample_callback,
std::move(low_priority_task_runner)),
std::move(user_visible_task_runner),
std::move(best_effort_task_runner)),
string_cache_(std::make_unique<StringCache>(GetIsolate())),
private_property_(std::make_unique<V8PrivateProperty>()),
constructor_mode_(ConstructorMode::kCreateNewObject),
@ -176,14 +178,16 @@ V8PerIsolateData::~V8PerIsolateData() = default;
v8::Isolate* V8PerIsolateData::Initialize(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
scoped_refptr<base::SingleThreadTaskRunner> low_priority_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> user_visible_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> best_effort_task_runner,
V8ContextSnapshotMode context_mode,
v8::CreateHistogramCallback create_histogram_callback,
v8::AddHistogramSampleCallback add_histogram_sample_callback) {
TRACE_EVENT1("v8", "V8PerIsolateData::Initialize", "V8ContextSnapshotMode",
context_mode);
V8PerIsolateData* data = new V8PerIsolateData(
std::move(task_runner), std::move(low_priority_task_runner), context_mode,
std::move(task_runner), std::move(user_visible_task_runner),
std::move(best_effort_task_runner), context_mode,
create_histogram_callback, add_histogram_sample_callback);
DCHECK(data);

@ -107,6 +107,7 @@ class PLATFORM_EXPORT V8PerIsolateData final {
};
static v8::Isolate* Initialize(scoped_refptr<base::SingleThreadTaskRunner>,
scoped_refptr<base::SingleThreadTaskRunner>,
scoped_refptr<base::SingleThreadTaskRunner>,
V8ContextSnapshotMode,
v8::CreateHistogramCallback,
@ -252,6 +253,7 @@ class PLATFORM_EXPORT V8PerIsolateData final {
private:
V8PerIsolateData(scoped_refptr<base::SingleThreadTaskRunner>,
scoped_refptr<base::SingleThreadTaskRunner>,
scoped_refptr<base::SingleThreadTaskRunner>,
V8ContextSnapshotMode,
v8::CreateHistogramCallback,

@ -96,9 +96,12 @@ RendererMainThreadTaskExecution::TaskType TaskTypeToProto(TaskType task_type) {
case TaskType::kMainThreadTaskQueueV8:
return RendererMainThreadTaskExecution::
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8;
case TaskType::kMainThreadTaskQueueV8LowPriority:
case TaskType::kMainThreadTaskQueueV8UserVisible:
return RendererMainThreadTaskExecution::
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_LOW_PRIORITY;
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_USER_VISIBLE;
case TaskType::kMainThreadTaskQueueV8BestEffort:
return RendererMainThreadTaskExecution::
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_V8_BEST_EFFORT;
case TaskType::kMainThreadTaskQueueCompositor:
return RendererMainThreadTaskExecution::
TASK_TYPE_MAIN_THREAD_TASK_QUEUE_COMPOSITOR;

@ -613,7 +613,8 @@ QueueTraits FrameSchedulerImpl::CreateQueueTraitsForTaskType(TaskType type) {
QueueTraits::PrioritisationType::kPostMessageForwarding);
case TaskType::kDeprecatedNone:
case TaskType::kMainThreadTaskQueueV8:
case TaskType::kMainThreadTaskQueueV8LowPriority:
case TaskType::kMainThreadTaskQueueV8UserVisible:
case TaskType::kMainThreadTaskQueueV8BestEffort:
case TaskType::kMainThreadTaskQueueCompositor:
case TaskType::kMainThreadTaskQueueDefault:
case TaskType::kMainThreadTaskQueueInput:

@ -175,7 +175,7 @@ constexpr TaskType kAllFrameTaskTypes[] = {
TaskType::kInternalNavigationCancellation};
static_assert(
static_cast<int>(TaskType::kMaxValue) == 86,
static_cast<int>(TaskType::kMaxValue) == 87,
"When adding a TaskType, make sure that kAllFrameTaskTypes is updated.");
void AppendToVectorTestTask(Vector<String>* vector, String value) {

@ -304,13 +304,20 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
v8_task_queue_ = NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
MainThreadTaskQueue::QueueType::kV8));
v8_low_priority_task_queue_ = NewTaskQueue(
v8_user_visible_task_queue_ = NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
MainThreadTaskQueue::QueueType::kV8LowPriority)
MainThreadTaskQueue::QueueType::kV8UserVisible)
.SetPrioritisationType(
MainThreadTaskQueue::QueueTraits::PrioritisationType::kLow)
.SetCanBeDeferredForRendering(base::FeatureList::IsEnabled(
features::kDeferRendererTasksAfterInput)));
v8_best_effort_task_queue_ = NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
MainThreadTaskQueue::QueueType::kV8BestEffort)
.SetPrioritisationType(
MainThreadTaskQueue::QueueTraits::PrioritisationType::kBestEffort)
.SetCanBeDeferredForRendering(base::FeatureList::IsEnabled(
features::kDeferRendererTasksAfterInput)));
non_waking_task_queue_ =
NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
MainThreadTaskQueue::QueueType::kNonWaking)
@ -318,8 +325,10 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
v8_task_runner_ =
v8_task_queue_->CreateTaskRunner(TaskType::kMainThreadTaskQueueV8);
v8_low_priority_task_runner_ = v8_low_priority_task_queue_->CreateTaskRunner(
TaskType::kMainThreadTaskQueueV8LowPriority);
v8_user_visible_task_runner_ = v8_user_visible_task_queue_->CreateTaskRunner(
TaskType::kMainThreadTaskQueueV8UserVisible);
v8_best_effort_task_runner_ = v8_best_effort_task_queue_->CreateTaskRunner(
TaskType::kMainThreadTaskQueueV8BestEffort);
control_task_runner_ = helper_.ControlMainThreadTaskQueue()->CreateTaskRunner(
TaskType::kMainThreadTaskQueueControl);
non_waking_task_runner_ = non_waking_task_queue_->CreateTaskRunner(
@ -2126,8 +2135,13 @@ MainThreadSchedulerImpl::V8TaskRunner() {
}
scoped_refptr<base::SingleThreadTaskRunner>
MainThreadSchedulerImpl::V8LowPriorityTaskRunner() {
return v8_low_priority_task_runner_;
MainThreadSchedulerImpl::V8UserVisibleTaskRunner() {
return v8_user_visible_task_runner_;
}
scoped_refptr<base::SingleThreadTaskRunner>
MainThreadSchedulerImpl::V8BestEffortTaskRunner() {
return v8_best_effort_task_runner_;
}
scoped_refptr<base::SingleThreadTaskRunner>

@ -209,8 +209,9 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
base::TimeDelta delay,
Thread::IdleTask) override;
scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
scoped_refptr<base::SingleThreadTaskRunner> V8LowPriorityTaskRunner()
scoped_refptr<base::SingleThreadTaskRunner> V8UserVisibleTaskRunner()
override;
scoped_refptr<base::SingleThreadTaskRunner> V8BestEffortTaskRunner() override;
scoped_refptr<base::SingleThreadTaskRunner> CleanupTaskRunner() override;
base::TimeTicks MonotonicallyIncreasingVirtualTime() override;
void AddTaskObserver(base::TaskObserver* task_observer) override;
@ -684,12 +685,14 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
TaskQueueVoterMap task_runners_;
scoped_refptr<MainThreadTaskQueue> v8_task_queue_;
scoped_refptr<MainThreadTaskQueue> v8_low_priority_task_queue_;
scoped_refptr<MainThreadTaskQueue> v8_user_visible_task_queue_;
scoped_refptr<MainThreadTaskQueue> v8_best_effort_task_queue_;
scoped_refptr<MainThreadTaskQueue> memory_purge_task_queue_;
scoped_refptr<MainThreadTaskQueue> non_waking_task_queue_;
scoped_refptr<base::SingleThreadTaskRunner> v8_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> v8_low_priority_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> v8_user_visible_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> v8_best_effort_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> non_waking_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner>

@ -58,8 +58,10 @@ QueueName MainThreadTaskQueue::NameForQueueType(
return QueueName::FRAME_LOADING_CONTROL_TQ;
case MainThreadTaskQueue::QueueType::kV8:
return QueueName::V8_TQ;
case MainThreadTaskQueue::QueueType::kV8LowPriority:
return QueueName::V8_LOW_PRIORITY_TQ;
case MainThreadTaskQueue::QueueType::kV8UserVisible:
return QueueName::V8_USER_VISIBLE_TQ;
case MainThreadTaskQueue::QueueType::kV8BestEffort:
return QueueName::V8_BEST_EFFORT_TQ;
case MainThreadTaskQueue::QueueType::kInput:
return QueueName::INPUT_TQ;
case MainThreadTaskQueue::QueueType::kDetached:
@ -99,7 +101,8 @@ bool MainThreadTaskQueue::IsPerFrameTaskQueue(
case MainThreadTaskQueue::QueueType::kCompositor:
case MainThreadTaskQueue::QueueType::kTest:
case MainThreadTaskQueue::QueueType::kV8:
case MainThreadTaskQueue::QueueType::kV8LowPriority:
case MainThreadTaskQueue::QueueType::kV8UserVisible:
case MainThreadTaskQueue::QueueType::kV8BestEffort:
case MainThreadTaskQueue::QueueType::kInput:
case MainThreadTaskQueue::QueueType::kDetached:
case MainThreadTaskQueue::QueueType::kNonWaking:

@ -76,7 +76,8 @@ class PLATFORM_EXPORT MainThreadTaskQueue
kFramePausable = 14,
kFrameUnpausable = 15,
kV8 = 16,
kV8LowPriority = 27,
kV8UserVisible = 27,
kV8BestEffort = 28,
// 17 : kIPC, obsolete
kInput = 18,
@ -96,7 +97,7 @@ class PLATFORM_EXPORT MainThreadTaskQueue
// Used to group multiple types when calculating Expected Queueing Time.
kOther = 23,
kCount = 28
kCount = 29
};
// The ThrottleHandle controls throttling and unthrottling the queue. When

@ -105,8 +105,10 @@ const char* TaskTypeNames::TaskTypeToString(TaskType task_type) {
return "InternalInspector";
case TaskType::kMainThreadTaskQueueV8:
return "MainThreadTaskQueueV8";
case TaskType::kMainThreadTaskQueueV8LowPriority:
return "MainThreadTaskQueueV8LowPriority";
case TaskType::kMainThreadTaskQueueV8UserVisible:
return "MainThreadTaskQueueV8UserVisible";
case TaskType::kMainThreadTaskQueueV8BestEffort:
return "MainThreadTaskQueueV8BestEffort";
case TaskType::kMainThreadTaskQueueCompositor:
return "MainThreadTaskQueueCompositor";
case TaskType::kMainThreadTaskQueueDefault:

@ -68,10 +68,16 @@ class PLATFORM_EXPORT ThreadScheduler {
// Returns a task runner for kV8 tasks. Can be called from any thread.
virtual scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() = 0;
// Returns a task runner for kV8LowPriority tasks. Can be called from any
// Returns a task runner for V8 user visible tasks. Can be called from any
// thread.
virtual scoped_refptr<base::SingleThreadTaskRunner>
V8LowPriorityTaskRunner() {
V8UserVisibleTaskRunner() {
return nullptr;
}
// Returns a task runner for V8 best effort tasks. Can be called from any
// thread.
virtual scoped_refptr<base::SingleThreadTaskRunner> V8BestEffortTaskRunner() {
return nullptr;
}

@ -223,7 +223,8 @@ scoped_refptr<base::SingleThreadTaskRunner> WorkerSchedulerImpl::GetTaskRunner(
? unpausable_task_queue_->CreateTaskRunner(type)
: pausable_non_vt_task_queue_->CreateTaskRunner(type);
case TaskType::kMainThreadTaskQueueV8:
case TaskType::kMainThreadTaskQueueV8LowPriority:
case TaskType::kMainThreadTaskQueueV8UserVisible:
case TaskType::kMainThreadTaskQueueV8BestEffort:
case TaskType::kMainThreadTaskQueueCompositor:
case TaskType::kMainThreadTaskQueueDefault:
case TaskType::kMainThreadTaskQueueInput: