chromium/base/task/thread_pool/task_source.cc

// Copyright 2019 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/task_source.h"

#include <utility>

#include "base/check_op.h"
#include "base/feature_list.h"
#include "base/memory/ptr_util.h"
#include "base/task/task_features.h"
#include "base/task/thread_pool/task_tracker.h"

namespace base {
namespace internal {

ExecutionEnvironment::~ExecutionEnvironment() = default;

TaskSource::Transaction::Transaction(TaskSource* task_source)
    : … { … }

TaskSource::Transaction::Transaction(TaskSource::Transaction&& other)
    : … { … }

TaskSource::Transaction::~Transaction() { … }

void TaskSource::Transaction::UpdatePriority(TaskPriority priority) { … }

void TaskSource::Transaction::Release() NO_THREAD_SAFETY_ANALYSIS { … }

void TaskSource::SetImmediateHeapHandle(const HeapHandle& handle) { … }

void TaskSource::ClearImmediateHeapHandle() { … }

void TaskSource::SetDelayedHeapHandle(const HeapHandle& handle) { … }

void TaskSource::ClearDelayedHeapHandle() { … }

TaskSource::TaskSource(const TaskTraits& traits,
                       TaskSourceExecutionMode execution_mode)
    : … { … }

TaskSource::~TaskSource() { … }

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

void TaskSource::ClearForTesting() { … }

RegisteredTaskSource::RegisteredTaskSource() = default;

RegisteredTaskSource::RegisteredTaskSource(std::nullptr_t)
    : … { … }

RegisteredTaskSource::RegisteredTaskSource(
    RegisteredTaskSource&& other) noexcept
    : … { … }

RegisteredTaskSource::~RegisteredTaskSource() { … }

//  static
RegisteredTaskSource RegisteredTaskSource::CreateForTesting(
    scoped_refptr<TaskSource> task_source,
    TaskTracker* task_tracker) { … }

scoped_refptr<TaskSource> RegisteredTaskSource::Unregister() { … }

RegisteredTaskSource& RegisteredTaskSource::operator=(
    RegisteredTaskSource&& other) { … }

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

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

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

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

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

RegisteredTaskSource::RegisteredTaskSource(
    scoped_refptr<TaskSource> task_source,
    TaskTracker* task_tracker)
    : … { … }

RegisteredTaskSourceAndTransaction::RegisteredTaskSourceAndTransaction(
    RegisteredTaskSource task_source_in,
    TaskSource::Transaction transaction_in)
    : … { … }

// static:
RegisteredTaskSourceAndTransaction
RegisteredTaskSourceAndTransaction::FromTaskSource(
    RegisteredTaskSource task_source_in) { … }

TaskSourceAndTransaction::TaskSourceAndTransaction(
    TaskSourceAndTransaction&& other) = default;

TaskSourceAndTransaction::~TaskSourceAndTransaction() = default;

TaskSourceAndTransaction::TaskSourceAndTransaction(
    scoped_refptr<TaskSource> task_source_in,
    TaskSource::Transaction transaction_in)
    : … { … }

// static:
TaskSourceAndTransaction TaskSourceAndTransaction::FromTaskSource(
    scoped_refptr<TaskSource> task_source_in) { … }

}  // namespace internal
}  // namespace base