chromium/out/Default/gen/third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.cc

// third_party/blink/public/mojom/indexeddb/indexeddb.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 "third_party/blink/public/mojom/indexeddb/indexeddb.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 "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-params-data.h"
#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink-import-headers.h"
#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"
#include "third_party/blink/renderer/modules/indexeddb/indexed_db_blink_mojom_traits.h"


namespace blink::mojom::blink {
IDBKeyPath::IDBKeyPath()
    : … { … }

IDBKeyPath::IDBKeyPath(
    IDBKeyPathDataPtr data_in)
    : … { … }

IDBKeyPath::~IDBKeyPath() = default;

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

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

IDBKeyRange::IDBKeyRange(
    ::std::unique_ptr<::blink::IDBKey> lower_in,
    ::std::unique_ptr<::blink::IDBKey> upper_in,
    bool lower_open_in,
    bool upper_open_in)
    : … { … }

IDBKeyRange::~IDBKeyRange() = default;

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

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

IDBIndexMetadata::IDBIndexMetadata(
    int64_t id_in,
    const ::WTF::String& name_in,
    const ::blink::IDBKeyPath& key_path_in,
    bool unique_in,
    bool multi_entry_in)
    : … { … }

IDBIndexMetadata::~IDBIndexMetadata() = default;

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

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

IDBObjectStoreMetadata::IDBObjectStoreMetadata(
    int64_t id_in,
    const ::WTF::String& name_in,
    const ::blink::IDBKeyPath& key_path_in,
    bool auto_increment_in,
    int64_t max_index_id_in,
    const WTF::HashMap<int64_t, ::scoped_refptr<::blink::IDBIndexMetadata>>& indexes_in)
    : … { … }

IDBObjectStoreMetadata::~IDBObjectStoreMetadata() = default;

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

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

IDBDatabaseMetadata::IDBDatabaseMetadata(
    int64_t id_in,
    const ::WTF::String& name_in,
    int64_t version_in,
    int64_t max_object_store_id_in,
    const WTF::HashMap<int64_t, ::scoped_refptr<::blink::IDBObjectStoreMetadata>>& object_stores_in,
    bool was_cold_open_in)
    : … { … }

IDBDatabaseMetadata::~IDBDatabaseMetadata() = default;

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

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

IDBNameAndVersion::IDBNameAndVersion(
    const ::WTF::String& name_in,
    int64_t version_in)
    : … { … }

IDBNameAndVersion::~IDBNameAndVersion() = default;

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

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

IDBIndexKeys::IDBIndexKeys(
    int64_t index_id_in,
    WTF::Vector<::std::unique_ptr<::blink::IDBKey>> index_keys_in)
    : … { … }

IDBIndexKeys::~IDBIndexKeys() = default;

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

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

IDBFileInfo::IDBFileInfo(
    const ::WTF::String& name_in,
    ::base::Time last_modified_in)
    : … { … }

IDBFileInfo::~IDBFileInfo() = default;

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

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

IDBBlobInfo::IDBBlobInfo(
    ::mojo::PendingRemote<::blink::mojom::blink::Blob> blob_in,
    const WTF::String& uuid_in,
    const ::WTF::String& mime_type_in,
    int64_t size_in,
    IDBFileInfoPtr file_in)
    : … { … }

IDBBlobInfo::~IDBBlobInfo() = default;

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

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

IDBValue::IDBValue(
    WTF::Vector<uint8_t> bits_in,
    WTF::Vector<IDBExternalObjectPtr> external_objects_in)
    : … { … }

IDBValue::~IDBValue() = default;

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

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

IDBReturnValue::IDBReturnValue(
    ::std::unique_ptr<::blink::IDBValue> value_in,
    ::std::unique_ptr<::blink::IDBKey> primary_key_in,
    const ::blink::IDBKeyPath& key_path_in)
    : … { … }

IDBReturnValue::~IDBReturnValue() = default;

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

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

IDBError::IDBError(
    IDBException error_code_in,
    const ::WTF::String& error_message_in)
    : … { … }

IDBError::~IDBError() = default;

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

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

IDBCursorValue::IDBCursorValue(
    WTF::Vector<::std::unique_ptr<::blink::IDBKey>> keys_in,
    WTF::Vector<::std::unique_ptr<::blink::IDBKey>> primary_keys_in,
    WTF::Vector<::std::unique_ptr<::blink::IDBValue>> values_in)
    : … { … }

IDBCursorValue::~IDBCursorValue() = default;

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

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

IDBDatabaseOpenCursorValue::IDBDatabaseOpenCursorValue(
    ::mojo::PendingAssociatedRemote<IDBCursor> cursor_in,
    ::std::unique_ptr<::blink::IDBKey> key_in,
    ::std::unique_ptr<::blink::IDBKey> primary_key_in,
    std::optional<::std::unique_ptr<::blink::IDBValue>> value_in)
    : … { … }

IDBDatabaseOpenCursorValue::~IDBDatabaseOpenCursorValue() = default;

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

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

IDBKey::~IDBKey() { … }


void IDBKey::set_key_array(
    WTF::Vector<::std::unique_ptr<::blink::IDBKey>> key_array) { … }
void IDBKey::set_binary(
    WTF::Vector<uint8_t> binary) { … }
void IDBKey::set_string(
    const ::WTF::String& string) { … }
void IDBKey::set_date(
    double date) { … }
void IDBKey::set_number(
    double number) { … }
void IDBKey::set_other_none(
    bool other_none) { … }

void IDBKey::DestroyActive() { … }

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

IDBKeyPathData::~IDBKeyPathData() { … }


void IDBKeyPathData::set_string(
    const ::WTF::String& string) { … }
void IDBKeyPathData::set_string_array(
    WTF::Vector<::WTF::String> string_array) { … }

void IDBKeyPathData::DestroyActive() { … }

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

IDBExternalObject::~IDBExternalObject() { … }


void IDBExternalObject::set_blob_or_file(
    IDBBlobInfoPtr blob_or_file) { … }
void IDBExternalObject::set_file_system_access_token(
    ::mojo::PendingRemote<::blink::mojom::blink::FileSystemAccessTransferToken> file_system_access_token) { … }

void IDBExternalObject::DestroyActive() { … }

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

IDBCursorResult::~IDBCursorResult() { … }


void IDBCursorResult::set_error_result(
    IDBErrorPtr error_result) { … }
void IDBCursorResult::set_empty(
    bool empty) { … }
void IDBCursorResult::set_values(
    IDBCursorValuePtr values) { … }

void IDBCursorResult::DestroyActive() { … }

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

IDBTransactionPutResult::~IDBTransactionPutResult() { … }


void IDBTransactionPutResult::set_error_result(
    IDBErrorPtr error_result) { … }
void IDBTransactionPutResult::set_key(
    ::std::unique_ptr<::blink::IDBKey> key) { … }

void IDBTransactionPutResult::DestroyActive() { … }

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

IDBDatabaseGetResult::~IDBDatabaseGetResult() { … }


void IDBDatabaseGetResult::set_error_result(
    IDBErrorPtr error_result) { … }
void IDBDatabaseGetResult::set_empty(
    bool empty) { … }
void IDBDatabaseGetResult::set_key(
    ::std::unique_ptr<::blink::IDBKey> key) { … }
void IDBDatabaseGetResult::set_value(
    IDBReturnValuePtr value) { … }

void IDBDatabaseGetResult::DestroyActive() { … }

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

IDBDatabaseOpenCursorResult::~IDBDatabaseOpenCursorResult() { … }


void IDBDatabaseOpenCursorResult::set_error_result(
    IDBErrorPtr error_result) { … }
void IDBDatabaseOpenCursorResult::set_empty(
    bool empty) { … }
void IDBDatabaseOpenCursorResult::set_value(
    IDBDatabaseOpenCursorValuePtr value) { … }

void IDBDatabaseOpenCursorResult::DestroyActive() { … }

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBFactoryClient::Error_Sym::IPCStableHash() { … }
uint32_t IDBFactoryClient::Blocked_Sym::IPCStableHash() { … }
uint32_t IDBFactoryClient::UpgradeNeeded_Sym::IPCStableHash() { … }
uint32_t IDBFactoryClient::OpenSuccess_Sym::IPCStableHash() { … }
uint32_t IDBFactoryClient::DeleteSuccess_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void IDBFactoryClientProxy::Error(
    IDBException in_code, const ::WTF::String& in_message) { … }

void IDBFactoryClientProxy::Blocked(
    int64_t in_existing_version) { … }

void IDBFactoryClientProxy::UpgradeNeeded(
    ::mojo::PendingAssociatedRemote<IDBDatabase> in_pending_database, int64_t in_old_version, IDBDataLoss in_data_loss, const WTF::String& in_data_loss_message, const ::blink::IDBDatabaseMetadata& in_db_metadata) { … }

void IDBFactoryClientProxy::OpenSuccess(
    ::mojo::PendingAssociatedRemote<IDBDatabase> in_pending_database, const ::blink::IDBDatabaseMetadata& in_metadata) { … }

void IDBFactoryClientProxy::DeleteSuccess(
    int64_t in_old_version) { … }

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

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

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

const char IDBDatabaseCallbacks::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBDatabaseCallbacks::ForcedClose_Sym::IPCStableHash() { … }
uint32_t IDBDatabaseCallbacks::VersionChange_Sym::IPCStableHash() { … }
uint32_t IDBDatabaseCallbacks::Abort_Sym::IPCStableHash() { … }
uint32_t IDBDatabaseCallbacks::Complete_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void IDBDatabaseCallbacksProxy::ForcedClose(
    ) { … }

void IDBDatabaseCallbacksProxy::VersionChange(
    int64_t in_old_version, int64_t in_new_version) { … }

void IDBDatabaseCallbacksProxy::Abort(
    int64_t in_transaction_id, IDBException in_code, const ::WTF::String& in_message) { … }

void IDBDatabaseCallbacksProxy::Complete(
    int64_t in_transaction_id) { … }

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

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

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

const char IDBCursor::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBCursor::Advance_Sym::IPCStableHash() { … }
uint32_t IDBCursor::Continue_Sym::IPCStableHash() { … }
uint32_t IDBCursor::Prefetch_Sym::IPCStableHash() { … }
uint32_t IDBCursor::PrefetchReset_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void IDBCursorProxy::Advance(
    uint32_t in_count, AdvanceCallback callback) { … }

void IDBCursorProxy::Continue(
    ::std::unique_ptr<::blink::IDBKey> in_key, ::std::unique_ptr<::blink::IDBKey> in_primary_key, ContinueCallback callback) { … }

void IDBCursorProxy::Prefetch(
    int32_t in_count, PrefetchCallback callback) { … }

void IDBCursorProxy::PrefetchReset(
    int32_t in_used_prefetches) { … }
class IDBCursor_Advance_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBCursor_Advance_ProxyToResponder::Run(
    IDBCursorResultPtr in_result) { … }
class IDBCursor_Continue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBCursor_Continue_ProxyToResponder::Run(
    IDBCursorResultPtr in_result) { … }
class IDBCursor_Prefetch_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBCursor_Prefetch_ProxyToResponder::Run(
    IDBCursorResultPtr in_result) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBTransaction::CreateObjectStore_Sym::IPCStableHash() { … }
uint32_t IDBTransaction::DeleteObjectStore_Sym::IPCStableHash() { … }
uint32_t IDBTransaction::Put_Sym::IPCStableHash() { … }
uint32_t IDBTransaction::Commit_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void IDBTransactionProxy::CreateObjectStore(
    int64_t in_object_store_id, const ::WTF::String& in_name, const ::blink::IDBKeyPath& in_key_path, bool in_auto_increment) { … }

void IDBTransactionProxy::DeleteObjectStore(
    int64_t in_object_store_id) { … }

void IDBTransactionProxy::Put(
    int64_t in_object_store_id, ::std::unique_ptr<::blink::IDBValue> in_value, ::std::unique_ptr<::blink::IDBKey> in_key, IDBPutMode in_mode, WTF::Vector<::blink::IDBIndexKeys> in_index_keys, PutCallback callback) { … }

void IDBTransactionProxy::Commit(
    int64_t in_num_errors_handled) { … }
class IDBTransaction_Put_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBTransaction_Put_ProxyToResponder::Run(
    IDBTransactionPutResultPtr in_result) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBDatabaseGetAllResultSink::ReceiveValues_Sym::IPCStableHash() { … }
uint32_t IDBDatabaseGetAllResultSink::ReceiveKeys_Sym::IPCStableHash() { … }
uint32_t IDBDatabaseGetAllResultSink::OnError_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void IDBDatabaseGetAllResultSinkProxy::ReceiveValues(
    WTF::Vector<IDBReturnValuePtr> in_values, bool in_done) { … }

void IDBDatabaseGetAllResultSinkProxy::ReceiveKeys(
    WTF::Vector<::std::unique_ptr<::blink::IDBKey>> in_keys, bool in_done) { … }

void IDBDatabaseGetAllResultSinkProxy::OnError(
    IDBErrorPtr in_error) { … }

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

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

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

const char IDBDatabase::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBDatabase::RenameObjectStore_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::CreateTransaction_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::VersionChangeIgnored_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::Get_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::GetAll_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::SetIndexKeys_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::SetIndexesReady_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::OpenCursor_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::Count_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::DeleteRange_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::GetKeyGeneratorCurrentNumber_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::Clear_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::CreateIndex_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::DeleteIndex_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::RenameIndex_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::Abort_Sym::IPCStableHash() { … }
uint32_t IDBDatabase::DidBecomeInactive_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

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

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

void IDBDatabaseProxy::RenameObjectStore(
    int64_t in_transaction_id, int64_t in_object_store_id, const ::WTF::String& in_new_name) { … }

void IDBDatabaseProxy::CreateTransaction(
    ::mojo::PendingAssociatedReceiver<IDBTransaction> in_transaction_receiver, int64_t in_transaction_id, const WTF::Vector<int64_t>& in_object_store_ids, IDBTransactionMode in_mode, IDBTransactionDurability in_durability) { … }

void IDBDatabaseProxy::VersionChangeIgnored(
    ) { … }

void IDBDatabaseProxy::Get(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, IDBKeyRangePtr in_key_range, bool in_key_only, GetCallback callback) { … }

void IDBDatabaseProxy::GetAll(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, IDBKeyRangePtr in_key_range, bool in_key_only, int64_t in_max_count, GetAllCallback callback) { … }

void IDBDatabaseProxy::SetIndexKeys(
    int64_t in_transaction_id, int64_t in_object_store_id, ::std::unique_ptr<::blink::IDBKey> in_primary_key, WTF::Vector<::blink::IDBIndexKeys> in_index_keys) { … }

void IDBDatabaseProxy::SetIndexesReady(
    int64_t in_transaction_id, int64_t in_object_store_id, const WTF::Vector<int64_t>& in_index_ids) { … }

void IDBDatabaseProxy::OpenCursor(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, IDBKeyRangePtr in_key_range, IDBCursorDirection in_direction, bool in_key_only, IDBTaskType in_task_type, OpenCursorCallback callback) { … }

void IDBDatabaseProxy::Count(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, IDBKeyRangePtr in_key_range, CountCallback callback) { … }

void IDBDatabaseProxy::DeleteRange(
    int64_t in_transaction_id, int64_t in_object_store_id, IDBKeyRangePtr in_key_range, DeleteRangeCallback callback) { … }

void IDBDatabaseProxy::GetKeyGeneratorCurrentNumber(
    int64_t in_transaction_id, int64_t in_object_store_id, GetKeyGeneratorCurrentNumberCallback callback) { … }

void IDBDatabaseProxy::Clear(
    int64_t in_transaction_id, int64_t in_object_store_id, ClearCallback callback) { … }

void IDBDatabaseProxy::CreateIndex(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, const ::WTF::String& in_name, const ::blink::IDBKeyPath& in_key_path, bool in_unique, bool in_multi_entry) { … }

void IDBDatabaseProxy::DeleteIndex(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id) { … }

void IDBDatabaseProxy::RenameIndex(
    int64_t in_transaction_id, int64_t in_object_store_id, int64_t in_index_id, const ::WTF::String& in_new_name) { … }

void IDBDatabaseProxy::Abort(
    int64_t in_transaction_id) { … }

void IDBDatabaseProxy::DidBecomeInactive(
    ) { … }
class IDBDatabase_Get_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_Get_ProxyToResponder::Run(
    IDBDatabaseGetResultPtr in_result) { … }
class IDBDatabase_GetAll_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_GetAll_ProxyToResponder::Run(
    ::mojo::PendingAssociatedReceiver<IDBDatabaseGetAllResultSink> in_receiver) { … }
class IDBDatabase_OpenCursor_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_OpenCursor_ProxyToResponder::Run(
    IDBDatabaseOpenCursorResultPtr in_result) { … }
class IDBDatabase_Count_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_Count_ProxyToResponder::Run(
    bool in_success, uint32_t in_count) { … }
class IDBDatabase_DeleteRange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_DeleteRange_ProxyToResponder::Run(
    bool in_success) { … }
class IDBDatabase_GetKeyGeneratorCurrentNumber_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_GetKeyGeneratorCurrentNumber_ProxyToResponder::Run(
    int64_t in_result, IDBErrorPtr in_error) { … }
class IDBDatabase_Clear_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBDatabase_Clear_ProxyToResponder::Run(
    bool in_success) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IDBFactory::GetDatabaseInfo_Sym::IPCStableHash() { … }
uint32_t IDBFactory::Open_Sym::IPCStableHash() { … }
uint32_t IDBFactory::DeleteDatabase_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void IDBFactoryProxy::GetDatabaseInfo(
    GetDatabaseInfoCallback callback) { … }

void IDBFactoryProxy::Open(
    ::mojo::PendingAssociatedRemote<IDBFactoryClient> in_client, ::mojo::PendingAssociatedRemote<IDBDatabaseCallbacks> in_database_callbacks, const ::WTF::String& in_name, int64_t in_version, ::mojo::PendingAssociatedReceiver<IDBTransaction> in_version_change_transaction_receiver, int64_t in_transaction_id) { … }

void IDBFactoryProxy::DeleteDatabase(
    ::mojo::PendingAssociatedRemote<IDBFactoryClient> in_client, const ::WTF::String& in_name, bool in_force_close) { … }
class IDBFactory_GetDatabaseInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void IDBFactory_GetDatabaseInfo_ProxyToResponder::Run(
    WTF::Vector<IDBNameAndVersionPtr> in_names_and_versions, IDBErrorPtr in_error) { … }

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

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

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

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


}  // blink::mojom::blink


namespace mojo {


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


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


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


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


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


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


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


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


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


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


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


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


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


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

// static
bool UnionTraits<::blink::mojom::blink::IDBKey::DataView, ::blink::mojom::blink::IDBKeyPtr>::Read(
    ::blink::mojom::blink::IDBKey::DataView input,
    ::blink::mojom::blink::IDBKeyPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBKeyPathData::DataView, ::blink::mojom::blink::IDBKeyPathDataPtr>::Read(
    ::blink::mojom::blink::IDBKeyPathData::DataView input,
    ::blink::mojom::blink::IDBKeyPathDataPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBExternalObject::DataView, ::blink::mojom::blink::IDBExternalObjectPtr>::Read(
    ::blink::mojom::blink::IDBExternalObject::DataView input,
    ::blink::mojom::blink::IDBExternalObjectPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBCursorResult::DataView, ::blink::mojom::blink::IDBCursorResultPtr>::Read(
    ::blink::mojom::blink::IDBCursorResult::DataView input,
    ::blink::mojom::blink::IDBCursorResultPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBTransactionPutResult::DataView, ::blink::mojom::blink::IDBTransactionPutResultPtr>::Read(
    ::blink::mojom::blink::IDBTransactionPutResult::DataView input,
    ::blink::mojom::blink::IDBTransactionPutResultPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBDatabaseGetResult::DataView, ::blink::mojom::blink::IDBDatabaseGetResultPtr>::Read(
    ::blink::mojom::blink::IDBDatabaseGetResult::DataView input,
    ::blink::mojom::blink::IDBDatabaseGetResultPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::blink::IDBDatabaseOpenCursorResult::DataView, ::blink::mojom::blink::IDBDatabaseOpenCursorResultPtr>::Read(
    ::blink::mojom::blink::IDBDatabaseOpenCursorResult::DataView input,
    ::blink::mojom::blink::IDBDatabaseOpenCursorResultPtr* 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 blink::mojom::blink {


void IDBFactoryClientInterceptorForTesting::Error(IDBException code, const ::WTF::String& message) { … }
void IDBFactoryClientInterceptorForTesting::Blocked(int64_t existing_version) { … }
void IDBFactoryClientInterceptorForTesting::UpgradeNeeded(::mojo::PendingAssociatedRemote<IDBDatabase> pending_database, int64_t old_version, IDBDataLoss data_loss, const WTF::String& data_loss_message, const ::blink::IDBDatabaseMetadata& db_metadata) { … }
void IDBFactoryClientInterceptorForTesting::OpenSuccess(::mojo::PendingAssociatedRemote<IDBDatabase> pending_database, const ::blink::IDBDatabaseMetadata& metadata) { … }
void IDBFactoryClientInterceptorForTesting::DeleteSuccess(int64_t old_version) { … }
IDBFactoryClientAsyncWaiter::IDBFactoryClientAsyncWaiter(
    IDBFactoryClient* proxy) : … { … }

IDBFactoryClientAsyncWaiter::~IDBFactoryClientAsyncWaiter() = default;




void IDBDatabaseCallbacksInterceptorForTesting::ForcedClose() { … }
void IDBDatabaseCallbacksInterceptorForTesting::VersionChange(int64_t old_version, int64_t new_version) { … }
void IDBDatabaseCallbacksInterceptorForTesting::Abort(int64_t transaction_id, IDBException code, const ::WTF::String& message) { … }
void IDBDatabaseCallbacksInterceptorForTesting::Complete(int64_t transaction_id) { … }
IDBDatabaseCallbacksAsyncWaiter::IDBDatabaseCallbacksAsyncWaiter(
    IDBDatabaseCallbacks* proxy) : … { … }

IDBDatabaseCallbacksAsyncWaiter::~IDBDatabaseCallbacksAsyncWaiter() = default;




void IDBCursorInterceptorForTesting::Advance(uint32_t count, AdvanceCallback callback) { … }
void IDBCursorInterceptorForTesting::Continue(::std::unique_ptr<::blink::IDBKey> key, ::std::unique_ptr<::blink::IDBKey> primary_key, ContinueCallback callback) { … }
void IDBCursorInterceptorForTesting::Prefetch(int32_t count, PrefetchCallback callback) { … }
void IDBCursorInterceptorForTesting::PrefetchReset(int32_t used_prefetches) { … }
IDBCursorAsyncWaiter::IDBCursorAsyncWaiter(
    IDBCursor* proxy) : … { … }

IDBCursorAsyncWaiter::~IDBCursorAsyncWaiter() = default;

void IDBCursorAsyncWaiter::Advance(
    uint32_t count, IDBCursorResultPtr* out_result) { … }

IDBCursorResultPtr IDBCursorAsyncWaiter::Advance(
    uint32_t count) { … }

void IDBCursorAsyncWaiter::Continue(
    ::std::unique_ptr<::blink::IDBKey> key, ::std::unique_ptr<::blink::IDBKey> primary_key, IDBCursorResultPtr* out_result) { … }

IDBCursorResultPtr IDBCursorAsyncWaiter::Continue(
    ::std::unique_ptr<::blink::IDBKey> key, ::std::unique_ptr<::blink::IDBKey> primary_key) { … }

void IDBCursorAsyncWaiter::Prefetch(
    int32_t count, IDBCursorResultPtr* out_result) { … }

IDBCursorResultPtr IDBCursorAsyncWaiter::Prefetch(
    int32_t count) { … }




void IDBTransactionInterceptorForTesting::CreateObjectStore(int64_t object_store_id, const ::WTF::String& name, const ::blink::IDBKeyPath& key_path, bool auto_increment) { … }
void IDBTransactionInterceptorForTesting::DeleteObjectStore(int64_t object_store_id) { … }
void IDBTransactionInterceptorForTesting::Put(int64_t object_store_id, ::std::unique_ptr<::blink::IDBValue> value, ::std::unique_ptr<::blink::IDBKey> key, IDBPutMode mode, WTF::Vector<::blink::IDBIndexKeys> index_keys, PutCallback callback) { … }
void IDBTransactionInterceptorForTesting::Commit(int64_t num_errors_handled) { … }
IDBTransactionAsyncWaiter::IDBTransactionAsyncWaiter(
    IDBTransaction* proxy) : … { … }

IDBTransactionAsyncWaiter::~IDBTransactionAsyncWaiter() = default;

void IDBTransactionAsyncWaiter::Put(
    int64_t object_store_id, ::std::unique_ptr<::blink::IDBValue> value, ::std::unique_ptr<::blink::IDBKey> key, IDBPutMode mode, WTF::Vector<::blink::IDBIndexKeys> index_keys, IDBTransactionPutResultPtr* out_result) { … }

IDBTransactionPutResultPtr IDBTransactionAsyncWaiter::Put(
    int64_t object_store_id, ::std::unique_ptr<::blink::IDBValue> value, ::std::unique_ptr<::blink::IDBKey> key, IDBPutMode mode, WTF::Vector<::blink::IDBIndexKeys> index_keys) { … }




void IDBDatabaseGetAllResultSinkInterceptorForTesting::ReceiveValues(WTF::Vector<IDBReturnValuePtr> values, bool done) { … }
void IDBDatabaseGetAllResultSinkInterceptorForTesting::ReceiveKeys(WTF::Vector<::std::unique_ptr<::blink::IDBKey>> keys, bool done) { … }
void IDBDatabaseGetAllResultSinkInterceptorForTesting::OnError(IDBErrorPtr error) { … }
IDBDatabaseGetAllResultSinkAsyncWaiter::IDBDatabaseGetAllResultSinkAsyncWaiter(
    IDBDatabaseGetAllResultSink* proxy) : … { … }

IDBDatabaseGetAllResultSinkAsyncWaiter::~IDBDatabaseGetAllResultSinkAsyncWaiter() = default;




void IDBDatabaseInterceptorForTesting::RenameObjectStore(int64_t transaction_id, int64_t object_store_id, const ::WTF::String& new_name) { … }
void IDBDatabaseInterceptorForTesting::CreateTransaction(::mojo::PendingAssociatedReceiver<IDBTransaction> transaction_receiver, int64_t transaction_id, const WTF::Vector<int64_t>& object_store_ids, IDBTransactionMode mode, IDBTransactionDurability durability) { … }
void IDBDatabaseInterceptorForTesting::VersionChangeIgnored() { … }
void IDBDatabaseInterceptorForTesting::Get(int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only, GetCallback callback) { … }
void IDBDatabaseInterceptorForTesting::GetAll(int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only, int64_t max_count, GetAllCallback callback) { … }
void IDBDatabaseInterceptorForTesting::SetIndexKeys(int64_t transaction_id, int64_t object_store_id, ::std::unique_ptr<::blink::IDBKey> primary_key, WTF::Vector<::blink::IDBIndexKeys> index_keys) { … }
void IDBDatabaseInterceptorForTesting::SetIndexesReady(int64_t transaction_id, int64_t object_store_id, const WTF::Vector<int64_t>& index_ids) { … }
void IDBDatabaseInterceptorForTesting::OpenCursor(int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, IDBCursorDirection direction, bool key_only, IDBTaskType task_type, OpenCursorCallback callback) { … }
void IDBDatabaseInterceptorForTesting::Count(int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, CountCallback callback) { … }
void IDBDatabaseInterceptorForTesting::DeleteRange(int64_t transaction_id, int64_t object_store_id, IDBKeyRangePtr key_range, DeleteRangeCallback callback) { … }
void IDBDatabaseInterceptorForTesting::GetKeyGeneratorCurrentNumber(int64_t transaction_id, int64_t object_store_id, GetKeyGeneratorCurrentNumberCallback callback) { … }
void IDBDatabaseInterceptorForTesting::Clear(int64_t transaction_id, int64_t object_store_id, ClearCallback callback) { … }
void IDBDatabaseInterceptorForTesting::CreateIndex(int64_t transaction_id, int64_t object_store_id, int64_t index_id, const ::WTF::String& name, const ::blink::IDBKeyPath& key_path, bool unique, bool multi_entry) { … }
void IDBDatabaseInterceptorForTesting::DeleteIndex(int64_t transaction_id, int64_t object_store_id, int64_t index_id) { … }
void IDBDatabaseInterceptorForTesting::RenameIndex(int64_t transaction_id, int64_t object_store_id, int64_t index_id, const ::WTF::String& new_name) { … }
void IDBDatabaseInterceptorForTesting::Abort(int64_t transaction_id) { … }
void IDBDatabaseInterceptorForTesting::DidBecomeInactive() { … }
IDBDatabaseAsyncWaiter::IDBDatabaseAsyncWaiter(
    IDBDatabase* proxy) : … { … }

IDBDatabaseAsyncWaiter::~IDBDatabaseAsyncWaiter() = default;

void IDBDatabaseAsyncWaiter::Get(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only, IDBDatabaseGetResultPtr* out_result) { … }

IDBDatabaseGetResultPtr IDBDatabaseAsyncWaiter::Get(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only) { … }

void IDBDatabaseAsyncWaiter::GetAll(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only, int64_t max_count, ::mojo::PendingAssociatedReceiver<IDBDatabaseGetAllResultSink>* out_receiver) { … }

::mojo::PendingAssociatedReceiver<IDBDatabaseGetAllResultSink> IDBDatabaseAsyncWaiter::GetAll(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool key_only, int64_t max_count) { … }

void IDBDatabaseAsyncWaiter::OpenCursor(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, IDBCursorDirection direction, bool key_only, IDBTaskType task_type, IDBDatabaseOpenCursorResultPtr* out_result) { … }

IDBDatabaseOpenCursorResultPtr IDBDatabaseAsyncWaiter::OpenCursor(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, IDBCursorDirection direction, bool key_only, IDBTaskType task_type) { … }

void IDBDatabaseAsyncWaiter::Count(
    int64_t transaction_id, int64_t object_store_id, int64_t index_id, IDBKeyRangePtr key_range, bool* out_success, uint32_t* out_count) { … }



void IDBDatabaseAsyncWaiter::DeleteRange(
    int64_t transaction_id, int64_t object_store_id, IDBKeyRangePtr key_range, bool* out_success) { … }

bool IDBDatabaseAsyncWaiter::DeleteRange(
    int64_t transaction_id, int64_t object_store_id, IDBKeyRangePtr key_range) { … }

void IDBDatabaseAsyncWaiter::GetKeyGeneratorCurrentNumber(
    int64_t transaction_id, int64_t object_store_id, int64_t* out_result, IDBErrorPtr* out_error) { … }



void IDBDatabaseAsyncWaiter::Clear(
    int64_t transaction_id, int64_t object_store_id, bool* out_success) { … }

bool IDBDatabaseAsyncWaiter::Clear(
    int64_t transaction_id, int64_t object_store_id) { … }




void IDBFactoryInterceptorForTesting::GetDatabaseInfo(GetDatabaseInfoCallback callback) { … }
void IDBFactoryInterceptorForTesting::Open(::mojo::PendingAssociatedRemote<IDBFactoryClient> client, ::mojo::PendingAssociatedRemote<IDBDatabaseCallbacks> database_callbacks, const ::WTF::String& name, int64_t version, ::mojo::PendingAssociatedReceiver<IDBTransaction> version_change_transaction_receiver, int64_t transaction_id) { … }
void IDBFactoryInterceptorForTesting::DeleteDatabase(::mojo::PendingAssociatedRemote<IDBFactoryClient> client, const ::WTF::String& name, bool force_close) { … }
IDBFactoryAsyncWaiter::IDBFactoryAsyncWaiter(
    IDBFactory* proxy) : … { … }

IDBFactoryAsyncWaiter::~IDBFactoryAsyncWaiter() = default;

void IDBFactoryAsyncWaiter::GetDatabaseInfo(
    WTF::Vector<IDBNameAndVersionPtr>* out_names_and_versions, IDBErrorPtr* out_error) { … }








}  // blink::mojom::blink


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