media_controller.mojom.cc | Explore in Territory

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

#include "services/media_session/public/mojom/media_controller.mojom-import-headers.h"
#include "services/media_session/public/mojom/media_controller.mojom-test-utils.h"


namespace media_session::mojom {
const char MediaControllerManager::Name_[] = …;
constexpr base::Token MediaControllerManager::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaControllerManager::CreateMediaControllerForSession_Sym::IPCStableHash() { … }
uint32_t MediaControllerManager::CreateActiveMediaController_Sym::IPCStableHash() { … }
uint32_t MediaControllerManager::SuspendAllSessions_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void MediaControllerManagerProxy::CreateMediaControllerForSession(
    ::mojo::PendingReceiver<MediaController> in_receiver, const ::base::UnguessableToken& in_request_id) { … }

void MediaControllerManagerProxy::CreateActiveMediaController(
    ::mojo::PendingReceiver<MediaController> in_receiver) { … }

void MediaControllerManagerProxy::SuspendAllSessions(
    ) { … }

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

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

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

const char MediaController::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaController::Suspend_Sym::IPCStableHash() { … }
uint32_t MediaController::Resume_Sym::IPCStableHash() { … }
uint32_t MediaController::Stop_Sym::IPCStableHash() { … }
uint32_t MediaController::ToggleSuspendResume_Sym::IPCStableHash() { … }
uint32_t MediaController::AddObserver_Sym::IPCStableHash() { … }
uint32_t MediaController::PreviousTrack_Sym::IPCStableHash() { … }
uint32_t MediaController::NextTrack_Sym::IPCStableHash() { … }
uint32_t MediaController::Seek_Sym::IPCStableHash() { … }
uint32_t MediaController::ObserveImages_Sym::IPCStableHash() { … }
uint32_t MediaController::SeekTo_Sym::IPCStableHash() { … }
uint32_t MediaController::ScrubTo_Sym::IPCStableHash() { … }
uint32_t MediaController::EnterPictureInPicture_Sym::IPCStableHash() { … }
uint32_t MediaController::ExitPictureInPicture_Sym::IPCStableHash() { … }
uint32_t MediaController::SetAudioSinkId_Sym::IPCStableHash() { … }
uint32_t MediaController::ToggleMicrophone_Sym::IPCStableHash() { … }
uint32_t MediaController::ToggleCamera_Sym::IPCStableHash() { … }
uint32_t MediaController::HangUp_Sym::IPCStableHash() { … }
uint32_t MediaController::Raise_Sym::IPCStableHash() { … }
uint32_t MediaController::SetMute_Sym::IPCStableHash() { … }
uint32_t MediaController::RequestMediaRemoting_Sym::IPCStableHash() { … }
uint32_t MediaController::EnterAutoPictureInPicture_Sym::IPCStableHash() { … }
uint32_t MediaController::SkipAd_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void MediaControllerProxy::Suspend(
    ) { … }

void MediaControllerProxy::Resume(
    ) { … }

void MediaControllerProxy::Stop(
    ) { … }

void MediaControllerProxy::ToggleSuspendResume(
    ) { … }

void MediaControllerProxy::AddObserver(
    ::mojo::PendingRemote<MediaControllerObserver> in_observer) { … }

void MediaControllerProxy::PreviousTrack(
    ) { … }

void MediaControllerProxy::NextTrack(
    ) { … }

void MediaControllerProxy::Seek(
    ::base::TimeDelta in_seek_time) { … }

void MediaControllerProxy::ObserveImages(
    ::media_session::mojom::MediaSessionImageType in_type, int32_t in_minimum_size_px, int32_t in_desired_size_px, ::mojo::PendingRemote<MediaControllerImageObserver> in_observer) { … }

void MediaControllerProxy::SeekTo(
    ::base::TimeDelta in_seek_time) { … }

void MediaControllerProxy::ScrubTo(
    ::base::TimeDelta in_seek_time) { … }

void MediaControllerProxy::EnterPictureInPicture(
    ) { … }

void MediaControllerProxy::ExitPictureInPicture(
    ) { … }

void MediaControllerProxy::SetAudioSinkId(
    const std::optional<std::string>& in_id) { … }

void MediaControllerProxy::ToggleMicrophone(
    ) { … }

void MediaControllerProxy::ToggleCamera(
    ) { … }

void MediaControllerProxy::HangUp(
    ) { … }

void MediaControllerProxy::Raise(
    ) { … }

void MediaControllerProxy::SetMute(
    bool in_mute) { … }

void MediaControllerProxy::RequestMediaRemoting(
    ) { … }

void MediaControllerProxy::EnterAutoPictureInPicture(
    ) { … }

void MediaControllerProxy::SkipAd(
    ) { … }

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

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

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

const char MediaControllerObserver::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaControllerObserver::MediaSessionInfoChanged_Sym::IPCStableHash() { … }
uint32_t MediaControllerObserver::MediaSessionMetadataChanged_Sym::IPCStableHash() { … }
uint32_t MediaControllerObserver::MediaSessionActionsChanged_Sym::IPCStableHash() { … }
uint32_t MediaControllerObserver::MediaSessionChanged_Sym::IPCStableHash() { … }
uint32_t MediaControllerObserver::MediaSessionPositionChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void MediaControllerObserverProxy::MediaSessionInfoChanged(
    ::media_session::mojom::MediaSessionInfoPtr in_info) { … }

void MediaControllerObserverProxy::MediaSessionMetadataChanged(
    const std::optional<::media_session::MediaMetadata>& in_metadata) { … }

void MediaControllerObserverProxy::MediaSessionActionsChanged(
    const std::vector<::media_session::mojom::MediaSessionAction>& in_action) { … }

void MediaControllerObserverProxy::MediaSessionChanged(
    const std::optional<::base::UnguessableToken>& in_request_id) { … }

void MediaControllerObserverProxy::MediaSessionPositionChanged(
    const std::optional<::media_session::MediaPosition>& in_position) { … }

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

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

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

const char MediaControllerImageObserver::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaControllerImageObserver::MediaControllerImageChanged_Sym::IPCStableHash() { … }
uint32_t MediaControllerImageObserver::MediaControllerChapterImageChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void MediaControllerImageObserverProxy::MediaControllerImageChanged(
    ::media_session::mojom::MediaSessionImageType in_type, const ::SkBitmap& in_bitmap) { … }

void MediaControllerImageObserverProxy::MediaControllerChapterImageChanged(
    int32_t in_index, const ::SkBitmap& in_bitmap) { … }

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

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

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



}  // media_session::mojom


namespace mojo {

}  // namespace mojo


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


namespace media_session::mojom {


void MediaControllerManagerInterceptorForTesting::CreateMediaControllerForSession(::mojo::PendingReceiver<MediaController> receiver, const ::base::UnguessableToken& request_id) { … }
void MediaControllerManagerInterceptorForTesting::CreateActiveMediaController(::mojo::PendingReceiver<MediaController> receiver) { … }
void MediaControllerManagerInterceptorForTesting::SuspendAllSessions() { … }
MediaControllerManagerAsyncWaiter::MediaControllerManagerAsyncWaiter(
    MediaControllerManager* proxy) : … { … }

MediaControllerManagerAsyncWaiter::~MediaControllerManagerAsyncWaiter() = default;




void MediaControllerInterceptorForTesting::Suspend() { … }
void MediaControllerInterceptorForTesting::Resume() { … }
void MediaControllerInterceptorForTesting::Stop() { … }
void MediaControllerInterceptorForTesting::ToggleSuspendResume() { … }
void MediaControllerInterceptorForTesting::AddObserver(::mojo::PendingRemote<MediaControllerObserver> observer) { … }
void MediaControllerInterceptorForTesting::PreviousTrack() { … }
void MediaControllerInterceptorForTesting::NextTrack() { … }
void MediaControllerInterceptorForTesting::Seek(::base::TimeDelta seek_time) { … }
void MediaControllerInterceptorForTesting::ObserveImages(::media_session::mojom::MediaSessionImageType type, int32_t minimum_size_px, int32_t desired_size_px, ::mojo::PendingRemote<MediaControllerImageObserver> observer) { … }
void MediaControllerInterceptorForTesting::SeekTo(::base::TimeDelta seek_time) { … }
void MediaControllerInterceptorForTesting::ScrubTo(::base::TimeDelta seek_time) { … }
void MediaControllerInterceptorForTesting::EnterPictureInPicture() { … }
void MediaControllerInterceptorForTesting::ExitPictureInPicture() { … }
void MediaControllerInterceptorForTesting::SetAudioSinkId(const std::optional<std::string>& id) { … }
void MediaControllerInterceptorForTesting::ToggleMicrophone() { … }
void MediaControllerInterceptorForTesting::ToggleCamera() { … }
void MediaControllerInterceptorForTesting::HangUp() { … }
void MediaControllerInterceptorForTesting::Raise() { … }
void MediaControllerInterceptorForTesting::SetMute(bool mute) { … }
void MediaControllerInterceptorForTesting::RequestMediaRemoting() { … }
void MediaControllerInterceptorForTesting::EnterAutoPictureInPicture() { … }
void MediaControllerInterceptorForTesting::SkipAd() { … }
MediaControllerAsyncWaiter::MediaControllerAsyncWaiter(
    MediaController* proxy) : … { … }

MediaControllerAsyncWaiter::~MediaControllerAsyncWaiter() = default;




void MediaControllerObserverInterceptorForTesting::MediaSessionInfoChanged(::media_session::mojom::MediaSessionInfoPtr info) { … }
void MediaControllerObserverInterceptorForTesting::MediaSessionMetadataChanged(const std::optional<::media_session::MediaMetadata>& metadata) { … }
void MediaControllerObserverInterceptorForTesting::MediaSessionActionsChanged(const std::vector<::media_session::mojom::MediaSessionAction>& action) { … }
void MediaControllerObserverInterceptorForTesting::MediaSessionChanged(const std::optional<::base::UnguessableToken>& request_id) { … }
void MediaControllerObserverInterceptorForTesting::MediaSessionPositionChanged(const std::optional<::media_session::MediaPosition>& position) { … }
MediaControllerObserverAsyncWaiter::MediaControllerObserverAsyncWaiter(
    MediaControllerObserver* proxy) : … { … }

MediaControllerObserverAsyncWaiter::~MediaControllerObserverAsyncWaiter() = default;




void MediaControllerImageObserverInterceptorForTesting::MediaControllerImageChanged(::media_session::mojom::MediaSessionImageType type, const ::SkBitmap& bitmap) { … }
void MediaControllerImageObserverInterceptorForTesting::MediaControllerChapterImageChanged(int32_t index, const ::SkBitmap& bitmap) { … }
MediaControllerImageObserverAsyncWaiter::MediaControllerImageObserverAsyncWaiter(
    MediaControllerImageObserver* proxy) : … { … }

MediaControllerImageObserverAsyncWaiter::~MediaControllerImageObserverAsyncWaiter() = default;






}  // media_session::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/services/media_session/public/mojom/media_controller.mojom.cc
