in_flight_backend_io.cc | Explore in Territory

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

#include "net/disk_cache/blockfile/in_flight_backend_io.h"

#include <utility>

#include "base/check_op.h"
#include "base/compiler_specific.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/task/single_thread_task_runner.h"
#include "net/base/net_errors.h"
#include "net/disk_cache/blockfile/backend_impl.h"
#include "net/disk_cache/blockfile/entry_impl.h"

namespace disk_cache {

namespace {

// Used to leak a strong reference to an EntryImpl to the user of disk_cache.
EntryImpl* LeakEntryImpl(scoped_refptr<EntryImpl> entry) { … }

}  // namespace

BackendIO::BackendIO(InFlightBackendIO* controller,
                     BackendImpl* backend,
                     net::CompletionOnceCallback callback)
    : … { … }

BackendIO::BackendIO(InFlightBackendIO* controller,
                     BackendImpl* backend,
                     EntryResultCallback callback)
    : … { … }

BackendIO::BackendIO(InFlightBackendIO* controller,
                     BackendImpl* backend,
                     RangeResultCallback callback)
    : … { … }

BackendIO::BackendIO(InFlightBackendIO* controller, BackendImpl* backend)
    : … { … }

// Runs on the background thread.
void BackendIO::ExecuteOperation() { … }

// Runs on the background thread.
void BackendIO::OnIOComplete(int result) { … }

// Runs on the primary thread.
void BackendIO::OnDone(bool cancel) { … }

bool BackendIO::IsEntryOperation() { … }

void BackendIO::RunCallback(int result) { … }

void BackendIO::RunEntryResultCallback() { … }

void BackendIO::RunRangeResultCallback() { … }

void BackendIO::Init() { … }

void BackendIO::OpenOrCreateEntry(const std::string& key) { … }

void BackendIO::OpenEntry(const std::string& key) { … }

void BackendIO::CreateEntry(const std::string& key) { … }

void BackendIO::DoomEntry(const std::string& key) { … }

void BackendIO::DoomAllEntries() { … }

void BackendIO::DoomEntriesBetween(const base::Time initial_time,
                                   const base::Time end_time) { … }

void BackendIO::DoomEntriesSince(const base::Time initial_time) { … }

void BackendIO::CalculateSizeOfAllEntries() { … }

void BackendIO::OpenNextEntry(Rankings::Iterator* iterator) { … }

void BackendIO::EndEnumeration(std::unique_ptr<Rankings::Iterator> iterator) { … }

void BackendIO::OnExternalCacheHit(const std::string& key) { … }

void BackendIO::CloseEntryImpl(EntryImpl* entry) { … }

void BackendIO::DoomEntryImpl(EntryImpl* entry) { … }

void BackendIO::FlushQueue() { … }

void BackendIO::RunTask(base::OnceClosure task) { … }

void BackendIO::ReadData(EntryImpl* entry, int index, int offset,
                         net::IOBuffer* buf, int buf_len) { … }

void BackendIO::WriteData(EntryImpl* entry, int index, int offset,
                          net::IOBuffer* buf, int buf_len, bool truncate) { … }

void BackendIO::ReadSparseData(EntryImpl* entry,
                               int64_t offset,
                               net::IOBuffer* buf,
                               int buf_len) { … }

void BackendIO::WriteSparseData(EntryImpl* entry,
                                int64_t offset,
                                net::IOBuffer* buf,
                                int buf_len) { … }

void BackendIO::GetAvailableRange(EntryImpl* entry, int64_t offset, int len) { … }

void BackendIO::CancelSparseIO(EntryImpl* entry) { … }

void BackendIO::ReadyForSparseIO(EntryImpl* entry) { … }

BackendIO::~BackendIO() { … }

bool BackendIO::ReturnsEntry() { … }

base::TimeDelta BackendIO::ElapsedTime() const { … }

// Runs on the background thread.
void BackendIO::ExecuteBackendOperation() { … }

// Runs on the background thread.
void BackendIO::ExecuteEntryOperation() { … }

InFlightBackendIO::InFlightBackendIO(
    BackendImpl* backend,
    const scoped_refptr<base::SingleThreadTaskRunner>& background_thread)
    : … { … }

InFlightBackendIO::~InFlightBackendIO() = default;

void InFlightBackendIO::Init(net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::OpenOrCreateEntry(const std::string& key,
                                          EntryResultCallback callback) { … }

void InFlightBackendIO::OpenEntry(const std::string& key,
                                  EntryResultCallback callback) { … }

void InFlightBackendIO::CreateEntry(const std::string& key,
                                    EntryResultCallback callback) { … }

void InFlightBackendIO::DoomEntry(const std::string& key,
                                  net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::DoomAllEntries(net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::DoomEntriesBetween(
    const base::Time initial_time,
    const base::Time end_time,
    net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::CalculateSizeOfAllEntries(
    net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::DoomEntriesSince(const base::Time initial_time,
                                         net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::OpenNextEntry(Rankings::Iterator* iterator,
                                      EntryResultCallback callback) { … }

void InFlightBackendIO::EndEnumeration(
    std::unique_ptr<Rankings::Iterator> iterator) { … }

void InFlightBackendIO::OnExternalCacheHit(const std::string& key) { … }

void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) { … }

void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) { … }

void InFlightBackendIO::FlushQueue(net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::RunTask(base::OnceClosure task,
                                net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::ReadData(EntryImpl* entry,
                                 int index,
                                 int offset,
                                 net::IOBuffer* buf,
                                 int buf_len,
                                 net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::WriteData(EntryImpl* entry,
                                  int index,
                                  int offset,
                                  net::IOBuffer* buf,
                                  int buf_len,
                                  bool truncate,
                                  net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::ReadSparseData(EntryImpl* entry,
                                       int64_t offset,
                                       net::IOBuffer* buf,
                                       int buf_len,
                                       net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::WriteSparseData(EntryImpl* entry,
                                        int64_t offset,
                                        net::IOBuffer* buf,
                                        int buf_len,
                                        net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::GetAvailableRange(EntryImpl* entry,
                                          int64_t offset,
                                          int len,
                                          RangeResultCallback callback) { … }

void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) { … }

void InFlightBackendIO::ReadyForSparseIO(EntryImpl* entry,
                                         net::CompletionOnceCallback callback) { … }

void InFlightBackendIO::WaitForPendingIO() { … }

void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
                                            bool cancel) { … }

void InFlightBackendIO::PostOperation(const base::Location& from_here,
                                      BackendIO* operation) { … }

base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() { … }

}  // namespace disk_cache
chromium/net/disk_cache/blockfile/in_flight_backend_io.cc
