device_service.mojom.cc | Explore in Territory

// components/global_media_controls/public/mojom/device_service.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/global_media_controls/public/mojom/device_service.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/global_media_controls/public/mojom/device_service.mojom-params-data.h"
#include "components/global_media_controls/public/mojom/device_service.mojom-shared-message-ids.h"

#include "components/global_media_controls/public/mojom/device_service.mojom-import-headers.h"
#include "components/global_media_controls/public/mojom/device_service.mojom-test-utils.h"


namespace global_media_controls::mojom {
Device::Device()
    : … { … }

Device::Device(
    const std::string& id_in,
    const std::string& name_in,
    const std::string& status_text_in,
    IconType icon_in)
    : … { … }

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

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

bool Device::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char DeviceListHost::Name_[] = …;
constexpr base::Token DeviceListHost::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceListHost::SelectDevice_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void DeviceListHostProxy::SelectDevice(
    const std::string& in_device_id) { … }

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

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

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

const char DeviceListClient::Name_[] = …;
constexpr base::Token DeviceListClient::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceListClient::OnDevicesUpdated_Sym::IPCStableHash() { … }
uint32_t DeviceListClient::OnPermissionRejected_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void DeviceListClientProxy::OnDevicesUpdated(
    std::vector<DevicePtr> in_devices) { … }

void DeviceListClientProxy::OnPermissionRejected(
    ) { … }

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

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

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

const char DeviceService::Name_[] = …;
constexpr base::Token DeviceService::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceService::GetDeviceListHostForSession_Sym::IPCStableHash() { … }
uint32_t DeviceService::GetDeviceListHostForPresentation_Sym::IPCStableHash() { … }
uint32_t DeviceService::SetDevicePickerProvider_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void DeviceServiceProxy::GetDeviceListHostForSession(
    const std::string& in_session_id, ::mojo::PendingReceiver<DeviceListHost> in_host_receiver, ::mojo::PendingRemote<DeviceListClient> in_client_remote) { … }

void DeviceServiceProxy::GetDeviceListHostForPresentation(
    ::mojo::PendingReceiver<DeviceListHost> in_host_receiver, ::mojo::PendingRemote<DeviceListClient> in_client_remote) { … }

void DeviceServiceProxy::SetDevicePickerProvider(
    ::mojo::PendingRemote<DevicePickerProvider> in_provider_remote) { … }

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

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

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

const char DevicePickerProvider::Name_[] = …;
constexpr base::Token DevicePickerProvider::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevicePickerProvider::CreateItem_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::DeleteItem_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::ShowItem_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::HideItem_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::OnMetadataChanged_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::OnArtworkImageChanged_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::OnFaviconImageChanged_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::AddObserver_Sym::IPCStableHash() { … }
uint32_t DevicePickerProvider::HideMediaUI_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void DevicePickerProviderProxy::CreateItem(
    const ::base::UnguessableToken& in_source_id) { … }

void DevicePickerProviderProxy::DeleteItem(
    ) { … }

void DevicePickerProviderProxy::ShowItem(
    ) { … }

void DevicePickerProviderProxy::HideItem(
    ) { … }

void DevicePickerProviderProxy::OnMetadataChanged(
    const ::media_session::MediaMetadata& in_metadata) { … }

void DevicePickerProviderProxy::OnArtworkImageChanged(
    const ::gfx::ImageSkia& in_artwork_image) { … }

void DevicePickerProviderProxy::OnFaviconImageChanged(
    const ::gfx::ImageSkia& in_favicon_image) { … }

void DevicePickerProviderProxy::AddObserver(
    ::mojo::PendingRemote<DevicePickerObserver> in_observer) { … }

void DevicePickerProviderProxy::HideMediaUI(
    ) { … }

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

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

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

const char DevicePickerObserver::Name_[] = …;
constexpr base::Token DevicePickerObserver::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevicePickerObserver::OnMediaUIOpened_Sym::IPCStableHash() { … }
uint32_t DevicePickerObserver::OnMediaUIClosed_Sym::IPCStableHash() { … }
uint32_t DevicePickerObserver::OnMediaUIUpdated_Sym::IPCStableHash() { … }
uint32_t DevicePickerObserver::OnPickerDismissed_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void DevicePickerObserverProxy::OnMediaUIOpened(
    ) { … }

void DevicePickerObserverProxy::OnMediaUIClosed(
    ) { … }

void DevicePickerObserverProxy::OnMediaUIUpdated(
    ) { … }

void DevicePickerObserverProxy::OnPickerDismissed(
    ) { … }

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

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

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



}  // global_media_controls::mojom


namespace mojo {


// static
bool StructTraits<::global_media_controls::mojom::Device::DataView, ::global_media_controls::mojom::DevicePtr>::Read(
    ::global_media_controls::mojom::Device::DataView input,
    ::global_media_controls::mojom::DevicePtr* 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 global_media_controls::mojom {


void DeviceListHostInterceptorForTesting::SelectDevice(const std::string& device_id) { … }
DeviceListHostAsyncWaiter::DeviceListHostAsyncWaiter(
    DeviceListHost* proxy) : … { … }

DeviceListHostAsyncWaiter::~DeviceListHostAsyncWaiter() = default;




void DeviceListClientInterceptorForTesting::OnDevicesUpdated(std::vector<DevicePtr> devices) { … }
void DeviceListClientInterceptorForTesting::OnPermissionRejected() { … }
DeviceListClientAsyncWaiter::DeviceListClientAsyncWaiter(
    DeviceListClient* proxy) : … { … }

DeviceListClientAsyncWaiter::~DeviceListClientAsyncWaiter() = default;




void DeviceServiceInterceptorForTesting::GetDeviceListHostForSession(const std::string& session_id, ::mojo::PendingReceiver<DeviceListHost> host_receiver, ::mojo::PendingRemote<DeviceListClient> client_remote) { … }
void DeviceServiceInterceptorForTesting::GetDeviceListHostForPresentation(::mojo::PendingReceiver<DeviceListHost> host_receiver, ::mojo::PendingRemote<DeviceListClient> client_remote) { … }
void DeviceServiceInterceptorForTesting::SetDevicePickerProvider(::mojo::PendingRemote<DevicePickerProvider> provider_remote) { … }
DeviceServiceAsyncWaiter::DeviceServiceAsyncWaiter(
    DeviceService* proxy) : … { … }

DeviceServiceAsyncWaiter::~DeviceServiceAsyncWaiter() = default;




void DevicePickerProviderInterceptorForTesting::CreateItem(const ::base::UnguessableToken& source_id) { … }
void DevicePickerProviderInterceptorForTesting::DeleteItem() { … }
void DevicePickerProviderInterceptorForTesting::ShowItem() { … }
void DevicePickerProviderInterceptorForTesting::HideItem() { … }
void DevicePickerProviderInterceptorForTesting::OnMetadataChanged(const ::media_session::MediaMetadata& metadata) { … }
void DevicePickerProviderInterceptorForTesting::OnArtworkImageChanged(const ::gfx::ImageSkia& artwork_image) { … }
void DevicePickerProviderInterceptorForTesting::OnFaviconImageChanged(const ::gfx::ImageSkia& favicon_image) { … }
void DevicePickerProviderInterceptorForTesting::AddObserver(::mojo::PendingRemote<DevicePickerObserver> observer) { … }
void DevicePickerProviderInterceptorForTesting::HideMediaUI() { … }
DevicePickerProviderAsyncWaiter::DevicePickerProviderAsyncWaiter(
    DevicePickerProvider* proxy) : … { … }

DevicePickerProviderAsyncWaiter::~DevicePickerProviderAsyncWaiter() = default;




void DevicePickerObserverInterceptorForTesting::OnMediaUIOpened() { … }
void DevicePickerObserverInterceptorForTesting::OnMediaUIClosed() { … }
void DevicePickerObserverInterceptorForTesting::OnMediaUIUpdated() { … }
void DevicePickerObserverInterceptorForTesting::OnPickerDismissed() { … }
DevicePickerObserverAsyncWaiter::DevicePickerObserverAsyncWaiter(
    DevicePickerObserver* proxy) : … { … }

DevicePickerObserverAsyncWaiter::~DevicePickerObserverAsyncWaiter() = default;






}  // global_media_controls::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/components/global_media_controls/public/mojom/device_service.mojom.cc
