[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:

committed by
Chromium LUCI CQ

parent
3e1e041f5c
commit
8e42980ed5
base/tracing/protos
gin
third_party/blink
public
platform
renderer
bindings
core
core
workers
platform
bindings
scheduler
@ -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:
|
||||
|
2
third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl_unittest.cc
vendored
2
third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl_unittest.cc
vendored
@ -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:
|
||||
|
Reference in New Issue
Block a user