directory.mojom.cc | Explore in Territory

// components/services/storage/public/mojom/filesystem/directory.mojom.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 "components/services/storage/public/mojom/filesystem/directory.mojom.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 "components/services/storage/public/mojom/filesystem/directory.mojom-params-data.h"
#include "components/services/storage/public/mojom/filesystem/directory.mojom-shared-message-ids.h"

#include "components/services/storage/public/mojom/filesystem/directory.mojom-import-headers.h"
#include "components/services/storage/public/mojom/filesystem/directory.mojom-test-utils.h"


namespace storage::mojom {
StrictRelativePath::StrictRelativePath()
    : … { … }

StrictRelativePath::StrictRelativePath(
    const ::base::FilePath& path_in)
    : … { … }

StrictRelativePath::~StrictRelativePath() = default;

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

bool StrictRelativePath::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PathAccessInfo::PathAccessInfo()
    : … { … }

PathAccessInfo::PathAccessInfo(
    bool can_read_in,
    bool can_write_in)
    : … { … }

PathAccessInfo::~PathAccessInfo() = default;
size_t PathAccessInfo::Hash(size_t seed) const { … }

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t FileLock::Release_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool FileLock::Release(::base::File::Error* out_error) { … }
class FileLock_Release_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

FileLockProxy::FileLockProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool FileLockProxy::Release(
    ::base::File::Error* out_param_error) { … }

void FileLockProxy::Release(
    ReleaseCallback callback) { … }
class FileLock_Release_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void FileLock_Release_ProxyToResponder::Run(
    ::base::File::Error in_error) { … }
bool FileLock_Release_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t Directory::Clone_Sym::IPCStableHash() { … }
uint32_t Directory::PathExists_Sym::IPCStableHash() { … }
uint32_t Directory::GetEntries_Sym::IPCStableHash() { … }
uint32_t Directory::OpenFile_Sym::IPCStableHash() { … }
uint32_t Directory::CreateDirectory_Sym::IPCStableHash() { … }
uint32_t Directory::DeleteFile_Sym::IPCStableHash() { … }
uint32_t Directory::GetFileInfo_Sym::IPCStableHash() { … }
uint32_t Directory::GetPathAccess_Sym::IPCStableHash() { … }
uint32_t Directory::RenameFile_Sym::IPCStableHash() { … }
uint32_t Directory::LockFile_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool Directory::PathExists(const ::base::FilePath& path, bool* out_exists) { … }
bool Directory::GetEntries(const ::base::FilePath& path, GetEntriesMode mode, ::base::File::Error* out_error, std::vector<::base::FilePath>* out_entries) { … }
bool Directory::OpenFile(const ::base::FilePath& path, FileOpenMode mode, FileReadAccess read_access, FileWriteAccess write_access, ::base::File::Error* out_error, ::base::File* out_file) { … }
bool Directory::CreateDirectory(const ::base::FilePath& path, ::base::File::Error* out_error) { … }
bool Directory::DeleteFile(const ::base::FilePath& path, bool* out_success) { … }
bool Directory::GetFileInfo(const ::base::FilePath& path, std::optional<::base::File::Info>* out_info) { … }
bool Directory::GetPathAccess(const ::base::FilePath& path, PathAccessInfoPtr* out_info) { … }
bool Directory::RenameFile(const ::base::FilePath& old_path, const ::base::FilePath& new_path, ::base::File::Error* out_error) { … }
bool Directory::LockFile(const ::base::FilePath& path, ::base::File::Error* out_error, ::mojo::PendingRemote<FileLock>* out_lock) { … }
class Directory_PathExists_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_PathExists_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_GetEntries_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_GetEntries_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_OpenFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_OpenFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_CreateDirectory_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_CreateDirectory_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_DeleteFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_DeleteFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_GetFileInfo_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_GetFileInfo_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_GetPathAccess_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_GetPathAccess_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_RenameFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class Directory_RenameFile_ForwardToCallback
    : public mojo::MessageReceiver { … };
class Directory_LockFile_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

void DirectoryProxy::Clone(
    ::mojo::PendingReceiver<Directory> in_receiver) { … }
bool DirectoryProxy::PathExists(
    const ::base::FilePath& param_path, bool* out_param_exists) { … }

void DirectoryProxy::PathExists(
    const ::base::FilePath& in_path, PathExistsCallback callback) { … }
bool DirectoryProxy::GetEntries(
    const ::base::FilePath& param_path, GetEntriesMode param_mode, ::base::File::Error* out_param_error, std::vector<::base::FilePath>* out_param_entries) { … }

void DirectoryProxy::GetEntries(
    const ::base::FilePath& in_path, GetEntriesMode in_mode, GetEntriesCallback callback) { … }
bool DirectoryProxy::OpenFile(
    const ::base::FilePath& param_path, FileOpenMode param_mode, FileReadAccess param_read_access, FileWriteAccess param_write_access, ::base::File::Error* out_param_error, ::base::File* out_param_file) { … }

void DirectoryProxy::OpenFile(
    const ::base::FilePath& in_path, FileOpenMode in_mode, FileReadAccess in_read_access, FileWriteAccess in_write_access, OpenFileCallback callback) { … }
bool DirectoryProxy::CreateDirectory(
    const ::base::FilePath& param_path, ::base::File::Error* out_param_error) { … }

void DirectoryProxy::CreateDirectory(
    const ::base::FilePath& in_path, CreateDirectoryCallback callback) { … }
bool DirectoryProxy::DeleteFile(
    const ::base::FilePath& param_path, bool* out_param_success) { … }

void DirectoryProxy::DeleteFile(
    const ::base::FilePath& in_path, DeleteFileCallback callback) { … }
bool DirectoryProxy::GetFileInfo(
    const ::base::FilePath& param_path, std::optional<::base::File::Info>* out_param_info) { … }

void DirectoryProxy::GetFileInfo(
    const ::base::FilePath& in_path, GetFileInfoCallback callback) { … }
bool DirectoryProxy::GetPathAccess(
    const ::base::FilePath& param_path, PathAccessInfoPtr* out_param_info) { … }

void DirectoryProxy::GetPathAccess(
    const ::base::FilePath& in_path, GetPathAccessCallback callback) { … }
bool DirectoryProxy::RenameFile(
    const ::base::FilePath& param_old_path, const ::base::FilePath& param_new_path, ::base::File::Error* out_param_error) { … }

void DirectoryProxy::RenameFile(
    const ::base::FilePath& in_old_path, const ::base::FilePath& in_new_path, RenameFileCallback callback) { … }
bool DirectoryProxy::LockFile(
    const ::base::FilePath& param_path, ::base::File::Error* out_param_error, ::mojo::PendingRemote<FileLock>* out_param_lock) { … }

void DirectoryProxy::LockFile(
    const ::base::FilePath& in_path, LockFileCallback callback) { … }
class Directory_PathExists_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Directory_PathExists_ProxyToResponder::Run(
    bool in_exists) { … }
bool Directory_PathExists_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_GetEntries_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Directory_GetEntries_ProxyToResponder::Run(
    ::base::File::Error in_error, const std::vector<::base::FilePath>& in_entries) { … }
bool Directory_GetEntries_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_OpenFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

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

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

void Directory_CreateDirectory_ProxyToResponder::Run(
    ::base::File::Error in_error) { … }
bool Directory_CreateDirectory_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_DeleteFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Directory_DeleteFile_ProxyToResponder::Run(
    bool in_success) { … }
bool Directory_DeleteFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_GetFileInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

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

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

void Directory_GetPathAccess_ProxyToResponder::Run(
    PathAccessInfoPtr in_info) { … }
bool Directory_GetPathAccess_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_RenameFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Directory_RenameFile_ProxyToResponder::Run(
    ::base::File::Error in_error) { … }
bool Directory_RenameFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class Directory_LockFile_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void Directory_LockFile_ProxyToResponder::Run(
    ::base::File::Error in_error, ::mojo::PendingRemote<FileLock> in_lock) { … }
bool Directory_LockFile_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

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

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

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

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


}  // storage::mojom


namespace mojo {


// static
bool StructTraits<::storage::mojom::StrictRelativePath::DataView, ::storage::mojom::StrictRelativePathPtr>::Read(
    ::storage::mojom::StrictRelativePath::DataView input,
    ::storage::mojom::StrictRelativePathPtr* output) { … }


// static
bool StructTraits<::storage::mojom::PathAccessInfo::DataView, ::storage::mojom::PathAccessInfoPtr>::Read(
    ::storage::mojom::PathAccessInfo::DataView input,
    ::storage::mojom::PathAccessInfoPtr* 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 storage::mojom {


void FileLockInterceptorForTesting::Release(ReleaseCallback callback) { … }
FileLockAsyncWaiter::FileLockAsyncWaiter(
    FileLock* proxy) : … { … }

FileLockAsyncWaiter::~FileLockAsyncWaiter() = default;

void FileLockAsyncWaiter::Release(
    ::base::File::Error* out_error) { … }

::base::File::Error FileLockAsyncWaiter::Release(
    ) { … }




void DirectoryInterceptorForTesting::Clone(::mojo::PendingReceiver<Directory> receiver) { … }
void DirectoryInterceptorForTesting::PathExists(const ::base::FilePath& path, PathExistsCallback callback) { … }
void DirectoryInterceptorForTesting::GetEntries(const ::base::FilePath& path, GetEntriesMode mode, GetEntriesCallback callback) { … }
void DirectoryInterceptorForTesting::OpenFile(const ::base::FilePath& path, FileOpenMode mode, FileReadAccess read_access, FileWriteAccess write_access, OpenFileCallback callback) { … }
void DirectoryInterceptorForTesting::CreateDirectory(const ::base::FilePath& path, CreateDirectoryCallback callback) { … }
void DirectoryInterceptorForTesting::DeleteFile(const ::base::FilePath& path, DeleteFileCallback callback) { … }
void DirectoryInterceptorForTesting::GetFileInfo(const ::base::FilePath& path, GetFileInfoCallback callback) { … }
void DirectoryInterceptorForTesting::GetPathAccess(const ::base::FilePath& path, GetPathAccessCallback callback) { … }
void DirectoryInterceptorForTesting::RenameFile(const ::base::FilePath& old_path, const ::base::FilePath& new_path, RenameFileCallback callback) { … }
void DirectoryInterceptorForTesting::LockFile(const ::base::FilePath& path, LockFileCallback callback) { … }
DirectoryAsyncWaiter::DirectoryAsyncWaiter(
    Directory* proxy) : … { … }

DirectoryAsyncWaiter::~DirectoryAsyncWaiter() = default;

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

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

void DirectoryAsyncWaiter::GetEntries(
    const ::base::FilePath& path, GetEntriesMode mode, ::base::File::Error* out_error, std::vector<::base::FilePath>* out_entries) { … }



void DirectoryAsyncWaiter::OpenFile(
    const ::base::FilePath& path, FileOpenMode mode, FileReadAccess read_access, FileWriteAccess write_access, ::base::File::Error* out_error, ::base::File* out_file) { … }



void DirectoryAsyncWaiter::CreateDirectory(
    const ::base::FilePath& path, ::base::File::Error* out_error) { … }

::base::File::Error DirectoryAsyncWaiter::CreateDirectory(
    const ::base::FilePath& path) { … }

void DirectoryAsyncWaiter::DeleteFile(
    const ::base::FilePath& path, bool* out_success) { … }

bool DirectoryAsyncWaiter::DeleteFile(
    const ::base::FilePath& path) { … }

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

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

void DirectoryAsyncWaiter::GetPathAccess(
    const ::base::FilePath& path, PathAccessInfoPtr* out_info) { … }

PathAccessInfoPtr DirectoryAsyncWaiter::GetPathAccess(
    const ::base::FilePath& path) { … }

void DirectoryAsyncWaiter::RenameFile(
    const ::base::FilePath& old_path, const ::base::FilePath& new_path, ::base::File::Error* out_error) { … }

::base::File::Error DirectoryAsyncWaiter::RenameFile(
    const ::base::FilePath& old_path, const ::base::FilePath& new_path) { … }

void DirectoryAsyncWaiter::LockFile(
    const ::base::FilePath& path, ::base::File::Error* out_error, ::mojo::PendingRemote<FileLock>* out_lock) { … }








}  // storage::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/components/services/storage/public/mojom/filesystem/directory.mojom.cc
