blob_reader.cc | Explore in Territory

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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "storage/browser/blob/blob_reader.h"

#include <stddef.h>
#include <stdint.h>

#include <algorithm>
#include <limits>
#include <memory>
#include <utility>

#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/ptr_util.h"
#include "base/task/thread_pool.h"
#include "base/trace_event/trace_event.h"
#include "components/file_access/scoped_file_access_delegate.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "storage/browser/blob/blob_data_handle.h"
#include "storage/browser/blob/blob_data_snapshot.h"
#include "storage/browser/file_system/file_stream_reader.h"
#include "storage/browser/file_system/file_system_backend.h"
#include "storage/browser/file_system/file_system_context.h"
#include "storage/browser/file_system/file_system_url.h"
#include "third_party/blink/public/common/blob/blob_utils.h"

namespace storage {
namespace {

bool IsFileType(BlobDataItem::Type type) { … }

int ConvertBlobErrorToNetError(BlobStatus reason) { … }
}  // namespace

BlobReader::FileStreamReaderProvider::~FileStreamReaderProvider() = default;

BlobReader::BlobReader(const BlobDataHandle* blob_handle)
    : … { … }

BlobReader::~BlobReader() = default;

BlobReader::Status BlobReader::CalculateSize(net::CompletionOnceCallback done) { … }

bool BlobReader::has_side_data() const { … }

void BlobReader::ReadSideData(StatusCallback done) { … }

std::optional<mojo_base::BigBuffer> BlobReader::TakeSideData() { … }

void BlobReader::DidReadSideData(StatusCallback done,
                                 int expected_size,
                                 int result,
                                 mojo_base::BigBuffer data) { … }

BlobReader::Status BlobReader::SetReadRange(uint64_t offset, uint64_t length) { … }

BlobReader::Status BlobReader::Read(net::IOBuffer* buffer,
                                    size_t dest_size,
                                    int* bytes_read,
                                    net::CompletionOnceCallback done) { … }

bool BlobReader::IsSingleMojoDataItem() const { … }

void BlobReader::ReadSingleMojoDataItem(
    mojo::ScopedDataPipeProducerHandle producer,
    net::CompletionOnceCallback done) { … }

void BlobReader::Kill() { … }

bool BlobReader::IsInMemory() const { … }

void BlobReader::InvalidateCallbacksAndDone(int net_error,
                                            net::CompletionOnceCallback done) { … }

BlobReader::Status BlobReader::ReportError(int net_error) { … }

void BlobReader::AsyncCalculateSize(net::CompletionOnceCallback done,
                                    BlobStatus status) { … }

BlobReader::Status BlobReader::CalculateSizeImpl(
    net::CompletionOnceCallback* done) { … }

bool BlobReader::AddItemLength(size_t index, uint64_t item_length) { … }

bool BlobReader::ResolveFileItemLength(const BlobDataItem& item,
                                       int64_t total_length,
                                       uint64_t* output_length) { … }

void BlobReader::DidGetFileItemLength(size_t index, int64_t result) { … }

void BlobReader::DidCountSize() { … }

BlobReader::Status BlobReader::ReadLoop(int* bytes_read) { … }

BlobReader::Status BlobReader::ReadItem() { … }

void BlobReader::AdvanceItem() { … }

void BlobReader::AdvanceBytesRead(int result) { … }

void BlobReader::ReadBytesItem(const BlobDataItem& item, int bytes_to_read) { … }

BlobReader::Status BlobReader::ReadFileItem(
    FileStreamReader* reader,
    int bytes_to_read,
    file_access::ScopedFileAccessDelegate::RequestFilesAccessIOCallback
        file_access) { … }

void BlobReader::DidReadFile(int result) { … }

void BlobReader::ContinueAsyncReadLoop() { … }

void BlobReader::DeleteItemReaders() { … }

BlobReader::Status BlobReader::ReadReadableDataHandle(const BlobDataItem& item,
                                                      int bytes_to_read) { … }

void BlobReader::DidReadReadableDataHandle(int result) { … }

void BlobReader::DidReadItem(int result) { … }

int BlobReader::BytesReadCompleted() { … }

int BlobReader::ComputeBytesToRead() const { … }

FileStreamReader* BlobReader::GetOrCreateFileReaderAtIndex(size_t index) { … }

std::unique_ptr<FileStreamReader> BlobReader::CreateFileStreamReader(
    const BlobDataItem& item,
    uint64_t additional_offset) { … }

void BlobReader::SetFileReaderAtIndex(
    size_t index,
    std::unique_ptr<FileStreamReader> reader) { … }

network::DataPipeToSourceStream* BlobReader::GetOrCreateDataPipeAtIndex(
    size_t index) { … }

void BlobReader::SetDataPipeAtIndex(
    size_t index,
    std::unique_ptr<network::DataPipeToSourceStream> pipe) { … }

std::unique_ptr<network::DataPipeToSourceStream> BlobReader::CreateDataPipe(
    const BlobDataItem& item,
    uint64_t additional_offset) { … }

void BlobReader::RecordBytesReadFromDataHandle(int item_index, int result) { … }

}  // namespace storage
chromium/storage/browser/blob/blob_reader.cc
