chromium/base/task/thread_pool/sequence.cc

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/task/thread_pool/sequence.h"

#include <utility>

#include "base/check.h"
#include "base/critical_closure.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/memory/ptr_util.h"
#include "base/memory/stack_allocated.h"
#include "base/task/task_features.h"
#include "base/time/time.h"

namespace base {
namespace internal {

namespace {

// Asserts that a lock is acquired and annotates the scope such that
// base/thread_annotations.h can recognize that the lock is acquired.
class SCOPED_LOCKABLE AnnotateLockAcquired { … };

void MaybeMakeCriticalClosure(TaskShutdownBehavior shutdown_behavior,
                              Task& task) { … }

}  // namespace

Sequence::Transaction::Transaction(Sequence* sequence)
    : … { … }

Sequence::Transaction::Transaction(Sequence::Transaction&& other) = default;

Sequence::Transaction::~Transaction() = default;

bool Sequence::Transaction::WillPushImmediateTask() { … }

void Sequence::Transaction::PushImmediateTask(Task task) { … }

bool Sequence::Transaction::PushDelayedTask(Task task) { … }

// Delayed tasks are ordered by latest_delayed_run_time(). The top task may
// not be the first task eligible to run, but tasks will always become ripe
// before their latest_delayed_run_time().
bool Sequence::DelayedTaskGreater::operator()(const Task& lhs,
                                              const Task& rhs) const { … }

TaskSource::RunStatus Sequence::WillRunTask() { … }

bool Sequence::OnBecomeReady() { … }

size_t Sequence::GetRemainingConcurrency() const { … }

Task Sequence::TakeNextImmediateTask() { … }

Task Sequence::TakeEarliestTask() { … }

void Sequence::UpdateReadyTimes() { … }

Task Sequence::TakeTask(TaskSource::Transaction* transaction) { … }

bool Sequence::DidProcessTask(TaskSource::Transaction* transaction) { … }

bool Sequence::WillReEnqueue(TimeTicks now,
                             TaskSource::Transaction* transaction) { … }

bool Sequence::DelayedSortKeyWillChange(const Task& delayed_task) const { … }

bool Sequence::HasReadyTasks(TimeTicks now) const { … }

bool Sequence::HasImmediateTasks() const { … }

TaskSourceSortKey Sequence::GetSortKey() const { … }

TimeTicks Sequence::GetDelayedSortKey() const { … }

std::optional<Task> Sequence::Clear(TaskSource::Transaction* transaction) { … }

void Sequence::ReleaseTaskRunner() { … }

Sequence::Sequence(const TaskTraits& traits,
                   SequencedTaskRunner* task_runner,
                   TaskSourceExecutionMode execution_mode)
    : … { … }

Sequence::~Sequence() = default;

Sequence::Transaction Sequence::BeginTransaction() { … }

ExecutionEnvironment Sequence::GetExecutionEnvironment() { … }

bool Sequence::IsEmpty() const { … }

}  // namespace internal
}  // namespace base