chromium/out/Default/gen/services/device/public/mojom/nfc.mojom.cc

// services/device/public/mojom/nfc.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 "services/device/public/mojom/nfc.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 "services/device/public/mojom/nfc.mojom-params-data.h"
#include "services/device/public/mojom/nfc.mojom-shared-message-ids.h"

#include "services/device/public/mojom/nfc.mojom-import-headers.h"
#include "services/device/public/mojom/nfc.mojom-test-utils.h"


namespace device::mojom {
NDEFError::NDEFError()
    : … { … }

NDEFError::NDEFError(
    NDEFErrorType error_type_in,
    const std::string& error_message_in)
    : … { … }

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

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

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

NDEFRecord::NDEFRecord(
    NDEFRecordTypeCategory category_in,
    const std::string& record_type_in,
    const std::optional<std::string>& media_type_in,
    const std::optional<std::string>& id_in,
    const std::optional<std::string>& encoding_in,
    const std::optional<std::string>& lang_in,
    std::vector<uint8_t> data_in,
    NDEFMessagePtr payload_message_in)
    : … { … }

NDEFRecord::~NDEFRecord() = default;

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

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

NDEFMessage::NDEFMessage(
    std::vector<NDEFRecordPtr> data_in)
    : … { … }

NDEFMessage::~NDEFMessage() = default;

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

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

NDEFWriteOptions::NDEFWriteOptions(
    bool overwrite_in)
    : … { … }

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t NFC::SetClient_Sym::IPCStableHash() { … }
uint32_t NFC::Push_Sym::IPCStableHash() { … }
uint32_t NFC::CancelPush_Sym::IPCStableHash() { … }
uint32_t NFC::MakeReadOnly_Sym::IPCStableHash() { … }
uint32_t NFC::CancelMakeReadOnly_Sym::IPCStableHash() { … }
uint32_t NFC::Watch_Sym::IPCStableHash() { … }
uint32_t NFC::CancelWatch_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void NFCProxy::SetClient(
    ::mojo::PendingRemote<NFCClient> in_client) { … }

void NFCProxy::Push(
    NDEFMessagePtr in_message, NDEFWriteOptionsPtr in_options, PushCallback callback) { … }

void NFCProxy::CancelPush(
    ) { … }

void NFCProxy::MakeReadOnly(
    MakeReadOnlyCallback callback) { … }

void NFCProxy::CancelMakeReadOnly(
    ) { … }

void NFCProxy::Watch(
    uint32_t in_id, WatchCallback callback) { … }

void NFCProxy::CancelWatch(
    uint32_t in_id) { … }
class NFC_Push_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NFC_Push_ProxyToResponder::Run(
    NDEFErrorPtr in_error) { … }
class NFC_MakeReadOnly_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NFC_MakeReadOnly_ProxyToResponder::Run(
    NDEFErrorPtr in_error) { … }
class NFC_Watch_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void NFC_Watch_ProxyToResponder::Run(
    NDEFErrorPtr in_error) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t NFCClient::OnWatch_Sym::IPCStableHash() { … }
uint32_t NFCClient::OnError_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void NFCClientProxy::OnWatch(
    const std::vector<uint32_t>& in_watch_ids, const std::optional<std::string>& in_serial_number, NDEFMessagePtr in_message) { … }

void NFCClientProxy::OnError(
    NDEFErrorPtr in_error) { … }

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

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

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



}  // device::mojom


namespace mojo {


// static
bool StructTraits<::device::mojom::NDEFError::DataView, ::device::mojom::NDEFErrorPtr>::Read(
    ::device::mojom::NDEFError::DataView input,
    ::device::mojom::NDEFErrorPtr* output) { … }


// static
bool StructTraits<::device::mojom::NDEFRecord::DataView, ::device::mojom::NDEFRecordPtr>::Read(
    ::device::mojom::NDEFRecord::DataView input,
    ::device::mojom::NDEFRecordPtr* output) { … }


// static
bool StructTraits<::device::mojom::NDEFMessage::DataView, ::device::mojom::NDEFMessagePtr>::Read(
    ::device::mojom::NDEFMessage::DataView input,
    ::device::mojom::NDEFMessagePtr* output) { … }


// static
bool StructTraits<::device::mojom::NDEFWriteOptions::DataView, ::device::mojom::NDEFWriteOptionsPtr>::Read(
    ::device::mojom::NDEFWriteOptions::DataView input,
    ::device::mojom::NDEFWriteOptionsPtr* 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 device::mojom {


void NFCInterceptorForTesting::SetClient(::mojo::PendingRemote<NFCClient> client) { … }
void NFCInterceptorForTesting::Push(NDEFMessagePtr message, NDEFWriteOptionsPtr options, PushCallback callback) { … }
void NFCInterceptorForTesting::CancelPush() { … }
void NFCInterceptorForTesting::MakeReadOnly(MakeReadOnlyCallback callback) { … }
void NFCInterceptorForTesting::CancelMakeReadOnly() { … }
void NFCInterceptorForTesting::Watch(uint32_t id, WatchCallback callback) { … }
void NFCInterceptorForTesting::CancelWatch(uint32_t id) { … }
NFCAsyncWaiter::NFCAsyncWaiter(
    NFC* proxy) : … { … }

NFCAsyncWaiter::~NFCAsyncWaiter() = default;

void NFCAsyncWaiter::Push(
    NDEFMessagePtr message, NDEFWriteOptionsPtr options, NDEFErrorPtr* out_error) { … }

NDEFErrorPtr NFCAsyncWaiter::Push(
    NDEFMessagePtr message, NDEFWriteOptionsPtr options) { … }

void NFCAsyncWaiter::MakeReadOnly(
    NDEFErrorPtr* out_error) { … }

NDEFErrorPtr NFCAsyncWaiter::MakeReadOnly(
    ) { … }

void NFCAsyncWaiter::Watch(
    uint32_t id, NDEFErrorPtr* out_error) { … }

NDEFErrorPtr NFCAsyncWaiter::Watch(
    uint32_t id) { … }




void NFCClientInterceptorForTesting::OnWatch(const std::vector<uint32_t>& watch_ids, const std::optional<std::string>& serial_number, NDEFMessagePtr message) { … }
void NFCClientInterceptorForTesting::OnError(NDEFErrorPtr error) { … }
NFCClientAsyncWaiter::NFCClientAsyncWaiter(
    NFCClient* proxy) : … { … }

NFCClientAsyncWaiter::~NFCClientAsyncWaiter() = default;






}  // device::mojom


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