stable_video_decoder.mojom.cc | Explore in Territory

// media/mojo/mojom/stable/stable_video_decoder.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 "media/mojo/mojom/stable/stable_video_decoder.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 "media/mojo/mojom/stable/stable_video_decoder.mojom-params-data.h"
#include "media/mojo/mojom/stable/stable_video_decoder.mojom-shared-message-ids.h"

#include "media/mojo/mojom/stable/stable_video_decoder.mojom-import-headers.h"
#include "media/mojo/mojom/stable/stable_video_decoder.mojom-test-utils.h"


namespace media::stable::mojom {
const char MediaLog::Name_[] = …;
constexpr base::Token MediaLog::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaLog::AddLogRecord_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void MediaLogProxy::AddLogRecord(
    const ::media::MediaLogRecord& in_event) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoFrameHandleReleaser::ReleaseVideoFrame_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void VideoFrameHandleReleaserProxy::ReleaseVideoFrame(
    const ::base::UnguessableToken& in_release_token) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoDecoderClient::OnVideoFrameDecoded_Sym::IPCStableHash() { … }
uint32_t VideoDecoderClient::OnWaiting_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void VideoDecoderClientProxy::OnVideoFrameDecoded(
    ::media::stable::mojom::VideoFramePtr in_frame, bool in_can_read_without_stalling, const ::base::UnguessableToken& in_release_token) { … }

void VideoDecoderClientProxy::OnWaiting(
    ::media::WaitingReason in_reason) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t CdmContextEventCallback::EventCallback_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void CdmContextEventCallbackProxy::EventCallback(
    ::media::CdmContext::Event in_event) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t StableCdmContext::GetHwKeyData_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::RegisterEventCallback_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::GetHwConfigData_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::GetScreenResolutions_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::AllocateSecureBuffer_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::ParseEncryptedSliceHeader_Sym::IPCStableHash() { … }
uint32_t StableCdmContext::DecryptVideoBuffer_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

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

void StableCdmContextProxy::GetHwKeyData(
    ::std::unique_ptr<::media::DecryptConfig> in_decrypt_config, const std::vector<uint8_t>& in_hw_identifier, GetHwKeyDataCallback callback) { … }

void StableCdmContextProxy::RegisterEventCallback(
    ::mojo::PendingRemote<CdmContextEventCallback> in_callback) { … }

void StableCdmContextProxy::GetHwConfigData(
    GetHwConfigDataCallback callback) { … }

void StableCdmContextProxy::GetScreenResolutions(
    GetScreenResolutionsCallback callback) { … }

void StableCdmContextProxy::AllocateSecureBuffer(
    uint32_t in_size, AllocateSecureBufferCallback callback) { … }

void StableCdmContextProxy::ParseEncryptedSliceHeader(
    uint64_t in_secure_handle, uint32_t in_offset, const std::vector<uint8_t>& in_stream_data, ParseEncryptedSliceHeaderCallback callback) { … }

void StableCdmContextProxy::DecryptVideoBuffer(
    const ::scoped_refptr<::media::DecoderBuffer>& in_buffer, const std::vector<uint8_t>& in_bytes, DecryptVideoBufferCallback callback) { … }
class StableCdmContext_GetHwKeyData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_GetHwKeyData_ProxyToResponder::Run(
    ::media::Decryptor::Status in_status, const std::vector<uint8_t>& in_key_data) { … }
class StableCdmContext_GetHwConfigData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_GetHwConfigData_ProxyToResponder::Run(
    bool in_success, const std::vector<uint8_t>& in_config_data) { … }
class StableCdmContext_GetScreenResolutions_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_GetScreenResolutions_ProxyToResponder::Run(
    const std::vector<::gfx::Size>& in_resolutions) { … }
class StableCdmContext_AllocateSecureBuffer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_AllocateSecureBuffer_ProxyToResponder::Run(
    ::mojo::PlatformHandle in_secure_buffer) { … }
class StableCdmContext_ParseEncryptedSliceHeader_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_ParseEncryptedSliceHeader_ProxyToResponder::Run(
    bool in_success, const std::vector<uint8_t>& in_slice_header) { … }
class StableCdmContext_DecryptVideoBuffer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableCdmContext_DecryptVideoBuffer_ProxyToResponder::Run(
    ::media::Decryptor::Status in_status, const ::scoped_refptr<::media::DecoderBuffer>& in_decoder_buffer, const std::vector<uint8_t>& in_bytes) { … }

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

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

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

bool StableCdmContextResponseValidator::Accept(mojo::Message* message) { … }
const char StableVideoDecoder::Name_[] = …;
constexpr base::Token StableVideoDecoder::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t StableVideoDecoder::GetSupportedConfigs_Sym::IPCStableHash() { … }
uint32_t StableVideoDecoder::Construct_Sym::IPCStableHash() { … }
uint32_t StableVideoDecoder::Initialize_Sym::IPCStableHash() { … }
uint32_t StableVideoDecoder::Decode_Sym::IPCStableHash() { … }
uint32_t StableVideoDecoder::Reset_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool StableVideoDecoder::GetSupportedConfigs(std::vector<::media::SupportedVideoDecoderConfig>* out_supported_configs, ::media::VideoDecoderType* out_decoder_type) { … }
class StableVideoDecoder_GetSupportedConfigs_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

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

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

StableVideoDecoderProxy::StableVideoDecoderProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool StableVideoDecoderProxy::GetSupportedConfigs(
    std::vector<::media::SupportedVideoDecoderConfig>* out_param_supported_configs, ::media::VideoDecoderType* out_param_decoder_type) { … }

void StableVideoDecoderProxy::GetSupportedConfigs(
    GetSupportedConfigsCallback callback) { … }

void StableVideoDecoderProxy::Construct(
    ::mojo::PendingAssociatedRemote<VideoDecoderClient> in_client, ::mojo::PendingRemote<MediaLog> in_media_log, ::mojo::PendingReceiver<VideoFrameHandleReleaser> in_video_frame_handle_releaser, ::mojo::ScopedDataPipeConsumerHandle in_decoder_buffer_pipe, const ::gfx::ColorSpace& in_target_color_space) { … }

void StableVideoDecoderProxy::Initialize(
    const ::media::VideoDecoderConfig& in_config, bool in_low_delay, ::mojo::PendingRemote<StableCdmContext> in_cdm_context, InitializeCallback callback) { … }

void StableVideoDecoderProxy::Decode(
    const ::scoped_refptr<::media::DecoderBuffer>& in_buffer, DecodeCallback callback) { … }

void StableVideoDecoderProxy::Reset(
    ResetCallback callback) { … }
class StableVideoDecoder_GetSupportedConfigs_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableVideoDecoder_GetSupportedConfigs_ProxyToResponder::Run(
    const std::vector<::media::SupportedVideoDecoderConfig>& in_supported_configs, ::media::VideoDecoderType in_decoder_type) { … }
bool StableVideoDecoder_GetSupportedConfigs_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class StableVideoDecoder_Initialize_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableVideoDecoder_Initialize_ProxyToResponder::Run(
    const ::media::DecoderStatus& in_status, bool in_needs_bitstream_conversion, int32_t in_max_decode_requests, ::media::VideoDecoderType in_decoder_type, bool in_needs_transcryption) { … }
class StableVideoDecoder_Decode_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableVideoDecoder_Decode_ProxyToResponder::Run(
    const ::media::DecoderStatus& in_status) { … }
class StableVideoDecoder_Reset_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void StableVideoDecoder_Reset_ProxyToResponder::Run(
    ) { … }

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

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

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

bool StableVideoDecoderResponseValidator::Accept(mojo::Message* message) { … }
const char StableVideoDecoderTracker::Name_[] = …;
constexpr base::Token StableVideoDecoderTracker::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

// static
bool StableVideoDecoderTrackerStubDispatch::AcceptWithResponder(
    StableVideoDecoderTracker* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t StableVideoDecoderFactory::CreateStableVideoDecoder_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void StableVideoDecoderFactoryProxy::CreateStableVideoDecoder(
    ::mojo::PendingReceiver<StableVideoDecoder> in_receiver, ::mojo::PendingRemote<StableVideoDecoderTracker> in_tracker) { … }

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

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

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

const char StableVideoDecoderFactoryProcess::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t StableVideoDecoderFactoryProcess::InitializeStableVideoDecoderFactory_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void StableVideoDecoderFactoryProcessProxy::InitializeStableVideoDecoderFactory(
    const ::gpu::GpuFeatureInfo& in_gpu_feature_info, ::mojo::PendingReceiver<StableVideoDecoderFactory> in_receiver) { … }

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

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

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



}  // media::stable::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::stable::mojom {


void MediaLogInterceptorForTesting::AddLogRecord(const ::media::MediaLogRecord& event) { … }
MediaLogAsyncWaiter::MediaLogAsyncWaiter(
    MediaLog* proxy) : … { … }

MediaLogAsyncWaiter::~MediaLogAsyncWaiter() = default;




void VideoFrameHandleReleaserInterceptorForTesting::ReleaseVideoFrame(const ::base::UnguessableToken& release_token) { … }
VideoFrameHandleReleaserAsyncWaiter::VideoFrameHandleReleaserAsyncWaiter(
    VideoFrameHandleReleaser* proxy) : … { … }

VideoFrameHandleReleaserAsyncWaiter::~VideoFrameHandleReleaserAsyncWaiter() = default;




void VideoDecoderClientInterceptorForTesting::OnVideoFrameDecoded(::media::stable::mojom::VideoFramePtr frame, bool can_read_without_stalling, const ::base::UnguessableToken& release_token) { … }
void VideoDecoderClientInterceptorForTesting::OnWaiting(::media::WaitingReason reason) { … }
VideoDecoderClientAsyncWaiter::VideoDecoderClientAsyncWaiter(
    VideoDecoderClient* proxy) : … { … }

VideoDecoderClientAsyncWaiter::~VideoDecoderClientAsyncWaiter() = default;




void CdmContextEventCallbackInterceptorForTesting::EventCallback(::media::CdmContext::Event event) { … }
CdmContextEventCallbackAsyncWaiter::CdmContextEventCallbackAsyncWaiter(
    CdmContextEventCallback* proxy) : … { … }

CdmContextEventCallbackAsyncWaiter::~CdmContextEventCallbackAsyncWaiter() = default;




void StableCdmContextInterceptorForTesting::GetHwKeyData(::std::unique_ptr<::media::DecryptConfig> decrypt_config, const std::vector<uint8_t>& hw_identifier, GetHwKeyDataCallback callback) { … }
void StableCdmContextInterceptorForTesting::RegisterEventCallback(::mojo::PendingRemote<CdmContextEventCallback> callback) { … }
void StableCdmContextInterceptorForTesting::GetHwConfigData(GetHwConfigDataCallback callback) { … }
void StableCdmContextInterceptorForTesting::GetScreenResolutions(GetScreenResolutionsCallback callback) { … }
void StableCdmContextInterceptorForTesting::AllocateSecureBuffer(uint32_t size, AllocateSecureBufferCallback callback) { … }
void StableCdmContextInterceptorForTesting::ParseEncryptedSliceHeader(uint64_t secure_handle, uint32_t offset, const std::vector<uint8_t>& stream_data, ParseEncryptedSliceHeaderCallback callback) { … }
void StableCdmContextInterceptorForTesting::DecryptVideoBuffer(const ::scoped_refptr<::media::DecoderBuffer>& buffer, const std::vector<uint8_t>& bytes, DecryptVideoBufferCallback callback) { … }
StableCdmContextAsyncWaiter::StableCdmContextAsyncWaiter(
    StableCdmContext* proxy) : … { … }

StableCdmContextAsyncWaiter::~StableCdmContextAsyncWaiter() = default;

void StableCdmContextAsyncWaiter::GetHwKeyData(
    ::std::unique_ptr<::media::DecryptConfig> decrypt_config, const std::vector<uint8_t>& hw_identifier, ::media::Decryptor::Status* out_status, std::vector<uint8_t>* out_key_data) { … }



void StableCdmContextAsyncWaiter::GetHwConfigData(
    bool* out_success, std::vector<uint8_t>* out_config_data) { … }



void StableCdmContextAsyncWaiter::GetScreenResolutions(
    std::vector<::gfx::Size>* out_resolutions) { … }

std::vector<::gfx::Size> StableCdmContextAsyncWaiter::GetScreenResolutions(
    ) { … }

void StableCdmContextAsyncWaiter::AllocateSecureBuffer(
    uint32_t size, ::mojo::PlatformHandle* out_secure_buffer) { … }

::mojo::PlatformHandle StableCdmContextAsyncWaiter::AllocateSecureBuffer(
    uint32_t size) { … }

void StableCdmContextAsyncWaiter::ParseEncryptedSliceHeader(
    uint64_t secure_handle, uint32_t offset, const std::vector<uint8_t>& stream_data, bool* out_success, std::vector<uint8_t>* out_slice_header) { … }



void StableCdmContextAsyncWaiter::DecryptVideoBuffer(
    const ::scoped_refptr<::media::DecoderBuffer>& buffer, const std::vector<uint8_t>& bytes, ::media::Decryptor::Status* out_status, ::scoped_refptr<::media::DecoderBuffer>* out_decoder_buffer, std::vector<uint8_t>* out_bytes) { … }






void StableVideoDecoderInterceptorForTesting::GetSupportedConfigs(GetSupportedConfigsCallback callback) { … }
void StableVideoDecoderInterceptorForTesting::Construct(::mojo::PendingAssociatedRemote<VideoDecoderClient> client, ::mojo::PendingRemote<MediaLog> media_log, ::mojo::PendingReceiver<VideoFrameHandleReleaser> video_frame_handle_releaser, ::mojo::ScopedDataPipeConsumerHandle decoder_buffer_pipe, const ::gfx::ColorSpace& target_color_space) { … }
void StableVideoDecoderInterceptorForTesting::Initialize(const ::media::VideoDecoderConfig& config, bool low_delay, ::mojo::PendingRemote<StableCdmContext> cdm_context, InitializeCallback callback) { … }
void StableVideoDecoderInterceptorForTesting::Decode(const ::scoped_refptr<::media::DecoderBuffer>& buffer, DecodeCallback callback) { … }
void StableVideoDecoderInterceptorForTesting::Reset(ResetCallback callback) { … }
StableVideoDecoderAsyncWaiter::StableVideoDecoderAsyncWaiter(
    StableVideoDecoder* proxy) : … { … }

StableVideoDecoderAsyncWaiter::~StableVideoDecoderAsyncWaiter() = default;

void StableVideoDecoderAsyncWaiter::GetSupportedConfigs(
    std::vector<::media::SupportedVideoDecoderConfig>* out_supported_configs, ::media::VideoDecoderType* out_decoder_type) { … }



void StableVideoDecoderAsyncWaiter::Initialize(
    const ::media::VideoDecoderConfig& config, bool low_delay, ::mojo::PendingRemote<StableCdmContext> cdm_context, ::media::DecoderStatus* out_status, bool* out_needs_bitstream_conversion, int32_t* out_max_decode_requests, ::media::VideoDecoderType* out_decoder_type, bool* out_needs_transcryption) { … }



void StableVideoDecoderAsyncWaiter::Decode(
    const ::scoped_refptr<::media::DecoderBuffer>& buffer, ::media::DecoderStatus* out_status) { … }

::media::DecoderStatus StableVideoDecoderAsyncWaiter::Decode(
    const ::scoped_refptr<::media::DecoderBuffer>& buffer) { … }

void StableVideoDecoderAsyncWaiter::Reset(
    ) { … }






StableVideoDecoderTrackerAsyncWaiter::StableVideoDecoderTrackerAsyncWaiter(
    StableVideoDecoderTracker* proxy) : … { … }

StableVideoDecoderTrackerAsyncWaiter::~StableVideoDecoderTrackerAsyncWaiter() = default;




void StableVideoDecoderFactoryInterceptorForTesting::CreateStableVideoDecoder(::mojo::PendingReceiver<StableVideoDecoder> receiver, ::mojo::PendingRemote<StableVideoDecoderTracker> tracker) { … }
StableVideoDecoderFactoryAsyncWaiter::StableVideoDecoderFactoryAsyncWaiter(
    StableVideoDecoderFactory* proxy) : … { … }

StableVideoDecoderFactoryAsyncWaiter::~StableVideoDecoderFactoryAsyncWaiter() = default;




void StableVideoDecoderFactoryProcessInterceptorForTesting::InitializeStableVideoDecoderFactory(const ::gpu::GpuFeatureInfo& gpu_feature_info, ::mojo::PendingReceiver<StableVideoDecoderFactory> receiver) { … }
StableVideoDecoderFactoryProcessAsyncWaiter::StableVideoDecoderFactoryProcessAsyncWaiter(
    StableVideoDecoderFactoryProcess* proxy) : … { … }

StableVideoDecoderFactoryProcessAsyncWaiter::~StableVideoDecoderFactoryProcessAsyncWaiter() = default;






}  // media::stable::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/media/mojo/mojom/stable/stable_video_decoder.mojom.cc
