chromium/out/Default/gen/services/network/public/mojom/http_cache_backend_file_operations.mojom-blink.cc

// services/network/public/mojom/http_cache_backend_file_operations.mojom-blink.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "services/network/public/mojom/http_cache_backend_file_operations.mojom-blink.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "services/network/public/mojom/http_cache_backend_file_operations.mojom-params-data.h"
#include "services/network/public/mojom/http_cache_backend_file_operations.mojom-shared-message-ids.h"

#include "services/network/public/mojom/http_cache_backend_file_operations.mojom-blink-import-headers.h"
#include "services/network/public/mojom/http_cache_backend_file_operations.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace network::mojom::blink {
FileEnumerationEntry::FileEnumerationEntry()
    : … { … }

FileEnumerationEntry::FileEnumerationEntry(
    const ::base::FilePath& path_in,
    int64_t size_in,
    ::base::Time last_accessed_in,
    ::base::Time last_modified_in)
    : … { … }

FileEnumerationEntry::~FileEnumerationEntry() = default;

void FileEnumerationEntry::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool FileEnumerationEntry::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char FileEnumerator::Name_[] = …;

FileEnumerator::IPCStableHashFunction FileEnumerator::MessageToMethodInfo_(mojo::Message& message) { … }


const char* FileEnumerator::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t FileEnumerator::GetNext_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool FileEnumerator::GetNext(uint32_t num_entries, WTF::Vector<FileEnumerationEntryPtr>* out_entries, bool* out_end, bool* out_error) { … }
class FileEnumerator_GetNext_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class FileEnumerator_GetNext_ForwardToCallback
    : public mojo::MessageReceiver { … };

FileEnumeratorProxy::FileEnumeratorProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool FileEnumeratorProxy::GetNext(
    uint32_t param_num_entries, WTF::Vector<FileEnumerationEntryPtr>* out_param_entries, bool* out_param_end, bool* out_param_error) { … }

void FileEnumeratorProxy::GetNext(
    uint32_t in_num_entries, GetNextCallback callback) { … }
class FileEnumerator_GetNext_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool FileEnumerator_GetNext_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void FileEnumerator_GetNext_ProxyToResponder::Run(
    WTF::Vector<FileEnumerationEntryPtr> in_entries, bool in_end, bool in_error) { … }
bool FileEnumerator_GetNext_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

// static
bool FileEnumeratorStubDispatch::Accept(
    FileEnumerator* impl,
    mojo::Message* message) { … }

// static
bool FileEnumeratorStubDispatch::AcceptWithResponder(
    FileEnumerator* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kFileEnumeratorValidationInfo[] = …;

bool FileEnumeratorRequestValidator::Accept(mojo::Message* message) { … }

bool FileEnumeratorResponseValidator::Accept(mojo::Message* message) { … }
const char HttpCacheBackendFileOperations::Name_[] = …;

HttpCacheBackendFileOperations::IPCStableHashFunction HttpCacheBackendFileOperations::MessageToMethodInfo_(mojo::Message& message) { … }


const char* HttpCacheBackendFileOperations::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HttpCacheBackendFileOperations::CreateDirectory_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::PathExists_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::DirectoryExists_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::OpenFile_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::DeleteFile_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::RenameFile_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::GetFileInfo_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::EnumerateFiles_Sym::IPCStableHash() { … }
uint32_t HttpCacheBackendFileOperations::CleanupDirectory_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool HttpCacheBackendFileOperations::CreateDirectory(const ::base::FilePath& path, bool* out_result) { … }
bool HttpCacheBackendFileOperations::PathExists(const ::base::FilePath& path, bool* out_result) { … }
bool HttpCacheBackendFileOperations::DirectoryExists(const ::base::FilePath& path, bool* out_result) { … }
bool HttpCacheBackendFileOperations::OpenFile(const ::base::FilePath& path, HttpCacheBackendOpenFileFlags flags, ::base::File* out_file, ::base::File::Error* out_error) { … }
bool HttpCacheBackendFileOperations::DeleteFile(const ::base::FilePath& path, HttpCacheBackendDeleteFileMode mode, bool* out_result) { … }
bool HttpCacheBackendFileOperations::RenameFile(const ::base::FilePath& from_path, const ::base::FilePath& to_path, ::base::File::Error* out_error) { … }
bool HttpCacheBackendFileOperations::GetFileInfo(const ::base::FilePath& path, std::optional<::base::File::Info>* out_info) { … }
class HttpCacheBackendFileOperations_CreateDirectory_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_CreateDirectory_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_PathExists_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_PathExists_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_DirectoryExists_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_DirectoryExists_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_OpenFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_OpenFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_DeleteFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_DeleteFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_RenameFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_RenameFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class HttpCacheBackendFileOperations_GetFileInfo_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_GetFileInfo_ForwardToCallback
    : public mojo::MessageReceiver { … };

class HttpCacheBackendFileOperations_CleanupDirectory_ForwardToCallback
    : public mojo::MessageReceiver { … };

HttpCacheBackendFileOperationsProxy::HttpCacheBackendFileOperationsProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool HttpCacheBackendFileOperationsProxy::CreateDirectory(
    const ::base::FilePath& param_path, bool* out_param_result) { … }

void HttpCacheBackendFileOperationsProxy::CreateDirectory(
    const ::base::FilePath& in_path, CreateDirectoryCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::PathExists(
    const ::base::FilePath& param_path, bool* out_param_result) { … }

void HttpCacheBackendFileOperationsProxy::PathExists(
    const ::base::FilePath& in_path, PathExistsCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::DirectoryExists(
    const ::base::FilePath& param_path, bool* out_param_result) { … }

void HttpCacheBackendFileOperationsProxy::DirectoryExists(
    const ::base::FilePath& in_path, DirectoryExistsCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::OpenFile(
    const ::base::FilePath& param_path, HttpCacheBackendOpenFileFlags param_flags, ::base::File* out_param_file, ::base::File::Error* out_param_error) { … }

void HttpCacheBackendFileOperationsProxy::OpenFile(
    const ::base::FilePath& in_path, HttpCacheBackendOpenFileFlags in_flags, OpenFileCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::DeleteFile(
    const ::base::FilePath& param_path, HttpCacheBackendDeleteFileMode param_mode, bool* out_param_result) { … }

void HttpCacheBackendFileOperationsProxy::DeleteFile(
    const ::base::FilePath& in_path, HttpCacheBackendDeleteFileMode in_mode, DeleteFileCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::RenameFile(
    const ::base::FilePath& param_from_path, const ::base::FilePath& param_to_path, ::base::File::Error* out_param_error) { … }

void HttpCacheBackendFileOperationsProxy::RenameFile(
    const ::base::FilePath& in_from_path, const ::base::FilePath& in_to_path, RenameFileCallback callback) { … }
bool HttpCacheBackendFileOperationsProxy::GetFileInfo(
    const ::base::FilePath& param_path, std::optional<::base::File::Info>* out_param_info) { … }

void HttpCacheBackendFileOperationsProxy::GetFileInfo(
    const ::base::FilePath& in_path, GetFileInfoCallback callback) { … }

void HttpCacheBackendFileOperationsProxy::EnumerateFiles(
    const ::base::FilePath& in_path, ::mojo::PendingReceiver<FileEnumerator> in_receiver) { … }

void HttpCacheBackendFileOperationsProxy::CleanupDirectory(
    const ::base::FilePath& in_path, CleanupDirectoryCallback callback) { … }
class HttpCacheBackendFileOperations_CreateDirectory_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_CreateDirectory_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_CreateDirectory_ProxyToResponder::Run(
    bool in_result) { … }
bool HttpCacheBackendFileOperations_CreateDirectory_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_PathExists_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_PathExists_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_PathExists_ProxyToResponder::Run(
    bool in_result) { … }
bool HttpCacheBackendFileOperations_PathExists_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_DirectoryExists_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_DirectoryExists_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_DirectoryExists_ProxyToResponder::Run(
    bool in_result) { … }
bool HttpCacheBackendFileOperations_DirectoryExists_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_OpenFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_OpenFile_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_OpenFile_ProxyToResponder::Run(
    ::base::File in_file, ::base::File::Error in_error) { … }
bool HttpCacheBackendFileOperations_OpenFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_DeleteFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_DeleteFile_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_DeleteFile_ProxyToResponder::Run(
    bool in_result) { … }
bool HttpCacheBackendFileOperations_DeleteFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_RenameFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_RenameFile_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_RenameFile_ProxyToResponder::Run(
    ::base::File::Error in_error) { … }
bool HttpCacheBackendFileOperations_RenameFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_GetFileInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_GetFileInfo_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_GetFileInfo_ProxyToResponder::Run(
    const std::optional<::base::File::Info>& in_info) { … }
bool HttpCacheBackendFileOperations_GetFileInfo_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class HttpCacheBackendFileOperations_CleanupDirectory_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool HttpCacheBackendFileOperations_CleanupDirectory_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void HttpCacheBackendFileOperations_CleanupDirectory_ProxyToResponder::Run(
    bool in_result) { … }

// static
bool HttpCacheBackendFileOperationsStubDispatch::Accept(
    HttpCacheBackendFileOperations* impl,
    mojo::Message* message) { … }

// static
bool HttpCacheBackendFileOperationsStubDispatch::AcceptWithResponder(
    HttpCacheBackendFileOperations* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kHttpCacheBackendFileOperationsValidationInfo[] = …;

bool HttpCacheBackendFileOperationsRequestValidator::Accept(mojo::Message* message) { … }

bool HttpCacheBackendFileOperationsResponseValidator::Accept(mojo::Message* message) { … }
const char HttpCacheBackendFileOperationsFactory::Name_[] = …;

HttpCacheBackendFileOperationsFactory::IPCStableHashFunction HttpCacheBackendFileOperationsFactory::MessageToMethodInfo_(mojo::Message& message) { … }


const char* HttpCacheBackendFileOperationsFactory::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HttpCacheBackendFileOperationsFactory::Create_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

HttpCacheBackendFileOperationsFactoryProxy::HttpCacheBackendFileOperationsFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void HttpCacheBackendFileOperationsFactoryProxy::Create(
    ::mojo::PendingReceiver<HttpCacheBackendFileOperations> in_receiver) { … }

// static
bool HttpCacheBackendFileOperationsFactoryStubDispatch::Accept(
    HttpCacheBackendFileOperationsFactory* impl,
    mojo::Message* message) { … }

// static
bool HttpCacheBackendFileOperationsFactoryStubDispatch::AcceptWithResponder(
    HttpCacheBackendFileOperationsFactory* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kHttpCacheBackendFileOperationsFactoryValidationInfo[] = …;

bool HttpCacheBackendFileOperationsFactoryRequestValidator::Accept(mojo::Message* message) { … }



}  // network::mojom::blink


namespace mojo {


// static
bool StructTraits<::network::mojom::blink::FileEnumerationEntry::DataView, ::network::mojom::blink::FileEnumerationEntryPtr>::Read(
    ::network::mojom::blink::FileEnumerationEntry::DataView input,
    ::network::mojom::blink::FileEnumerationEntryPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace network::mojom::blink {


void FileEnumeratorInterceptorForTesting::GetNext(uint32_t num_entries, GetNextCallback callback) { … }
FileEnumeratorAsyncWaiter::FileEnumeratorAsyncWaiter(
    FileEnumerator* proxy) : … { … }

FileEnumeratorAsyncWaiter::~FileEnumeratorAsyncWaiter() = default;

void FileEnumeratorAsyncWaiter::GetNext(
    uint32_t num_entries, WTF::Vector<FileEnumerationEntryPtr>* out_entries, bool* out_end, bool* out_error) { … }






void HttpCacheBackendFileOperationsInterceptorForTesting::CreateDirectory(const ::base::FilePath& path, CreateDirectoryCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::PathExists(const ::base::FilePath& path, PathExistsCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::DirectoryExists(const ::base::FilePath& path, DirectoryExistsCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::OpenFile(const ::base::FilePath& path, HttpCacheBackendOpenFileFlags flags, OpenFileCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::DeleteFile(const ::base::FilePath& path, HttpCacheBackendDeleteFileMode mode, DeleteFileCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::RenameFile(const ::base::FilePath& from_path, const ::base::FilePath& to_path, RenameFileCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::GetFileInfo(const ::base::FilePath& path, GetFileInfoCallback callback) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::EnumerateFiles(const ::base::FilePath& path, ::mojo::PendingReceiver<FileEnumerator> receiver) { … }
void HttpCacheBackendFileOperationsInterceptorForTesting::CleanupDirectory(const ::base::FilePath& path, CleanupDirectoryCallback callback) { … }
HttpCacheBackendFileOperationsAsyncWaiter::HttpCacheBackendFileOperationsAsyncWaiter(
    HttpCacheBackendFileOperations* proxy) : … { … }

HttpCacheBackendFileOperationsAsyncWaiter::~HttpCacheBackendFileOperationsAsyncWaiter() = default;

void HttpCacheBackendFileOperationsAsyncWaiter::CreateDirectory(
    const ::base::FilePath& path, bool* out_result) { … }

bool HttpCacheBackendFileOperationsAsyncWaiter::CreateDirectory(
    const ::base::FilePath& path) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::PathExists(
    const ::base::FilePath& path, bool* out_result) { … }

bool HttpCacheBackendFileOperationsAsyncWaiter::PathExists(
    const ::base::FilePath& path) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::DirectoryExists(
    const ::base::FilePath& path, bool* out_result) { … }

bool HttpCacheBackendFileOperationsAsyncWaiter::DirectoryExists(
    const ::base::FilePath& path) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::OpenFile(
    const ::base::FilePath& path, HttpCacheBackendOpenFileFlags flags, ::base::File* out_file, ::base::File::Error* out_error) { … }



void HttpCacheBackendFileOperationsAsyncWaiter::DeleteFile(
    const ::base::FilePath& path, HttpCacheBackendDeleteFileMode mode, bool* out_result) { … }

bool HttpCacheBackendFileOperationsAsyncWaiter::DeleteFile(
    const ::base::FilePath& path, HttpCacheBackendDeleteFileMode mode) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::RenameFile(
    const ::base::FilePath& from_path, const ::base::FilePath& to_path, ::base::File::Error* out_error) { … }

::base::File::Error HttpCacheBackendFileOperationsAsyncWaiter::RenameFile(
    const ::base::FilePath& from_path, const ::base::FilePath& to_path) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::GetFileInfo(
    const ::base::FilePath& path, std::optional<::base::File::Info>* out_info) { … }

std::optional<::base::File::Info> HttpCacheBackendFileOperationsAsyncWaiter::GetFileInfo(
    const ::base::FilePath& path) { … }

void HttpCacheBackendFileOperationsAsyncWaiter::CleanupDirectory(
    const ::base::FilePath& path, bool* out_result) { … }

bool HttpCacheBackendFileOperationsAsyncWaiter::CleanupDirectory(
    const ::base::FilePath& path) { … }




void HttpCacheBackendFileOperationsFactoryInterceptorForTesting::Create(::mojo::PendingReceiver<HttpCacheBackendFileOperations> receiver) { … }
HttpCacheBackendFileOperationsFactoryAsyncWaiter::HttpCacheBackendFileOperationsFactoryAsyncWaiter(
    HttpCacheBackendFileOperationsFactory* proxy) : … { … }

HttpCacheBackendFileOperationsFactoryAsyncWaiter::~HttpCacheBackendFileOperationsFactoryAsyncWaiter() = default;






}  // network::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif