Codebase Browser
chromium
Go to App

chromium/out/Default/gen/gpu/ipc/common/gpu_channel.mojom.cc 

// gpu/ipc/common/gpu_channel.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 "gpu/ipc/common/gpu_channel.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 "gpu/ipc/common/gpu_channel.mojom-params-data.h"
#include "gpu/ipc/common/gpu_channel.mojom-shared-message-ids.h"

#include "gpu/ipc/common/gpu_channel.mojom-import-headers.h"
#include "gpu/ipc/common/gpu_channel.mojom-test-utils.h"


namespace gpu::mojom {
ContextCreationAttribs::ContextCreationAttribs()
    : … { … }

ContextCreationAttribs::ContextCreationAttribs(
    ::gl::GpuPreference gpu_preference_in,
    bool bind_generates_resource_in,
    bool fail_if_major_perf_caveat_in,
    bool lose_context_when_out_of_memory_in,
    bool enable_gles2_interface_in,
    bool enable_grcontext_in,
    bool enable_raster_interface_in,
    bool enable_oop_rasterization_in,
    ::gpu::ContextType context_type_in)
    : … { … }

ContextCreationAttribs::~ContextCreationAttribs() = default;

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

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

CreateCommandBufferParams::CreateCommandBufferParams(
    int32_t share_group_id_in,
    int32_t stream_id_in,
    ::gpu::SchedulingPriority stream_priority_in,
    const ::gpu::ContextCreationAttribs& attribs_in,
    const ::GURL& active_url_in)
    : … { … }

CreateCommandBufferParams::~CreateCommandBufferParams() = default;

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

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

CommandBufferState::CommandBufferState(
    int32_t get_offset_in,
    int32_t token_in,
    uint64_t release_count_in,
    ::gpu::error::Error error_in,
    ::gpu::error::ContextLostReason context_lost_reason_in,
    uint32_t generation_in,
    uint32_t set_get_buffer_count_in)
    : … { … }

CommandBufferState::~CommandBufferState() = default;

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

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

ScheduleImageDecodeParams::ScheduleImageDecodeParams(
    std::vector<uint8_t> encoded_data_in,
    const ::gfx::Size& output_size_in,
    int32_t raster_decoder_route_id_in,
    uint32_t transfer_cache_entry_id_in,
    int32_t discardable_handle_shm_id_in,
    uint32_t discardable_handle_shm_offset_in,
    uint64_t discardable_handle_release_count_in,
    const ::gfx::ColorSpace& target_color_space_in,
    bool needs_mips_in)
    : … { … }

ScheduleImageDecodeParams::~ScheduleImageDecodeParams() = default;

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

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

DeferredRequest::DeferredRequest(
    DeferredRequestParamsPtr params_in,
    std::vector<::gpu::SyncToken> sync_token_fences_in,
    uint64_t release_count_in)
    : … { … }

DeferredRequest::~DeferredRequest() = default;

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

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

DeferredCommandBufferRequest::DeferredCommandBufferRequest(
    int32_t routing_id_in,
    DeferredCommandBufferRequestParamsPtr params_in)
    : … { … }

DeferredCommandBufferRequest::~DeferredCommandBufferRequest() = default;

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

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

AsyncFlushParams::AsyncFlushParams(
    int32_t put_offset_in,
    uint32_t flush_id_in,
    std::vector<::gpu::SyncToken> sync_token_fences_in)
    : … { … }

AsyncFlushParams::~AsyncFlushParams() = default;

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

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

SetDefaultFramebufferSharedImageParams::SetDefaultFramebufferSharedImageParams(
    const ::gpu::Mailbox& mailbox_in,
    uint32_t samples_count_in,
    bool preserve_in,
    bool needs_depth_in,
    bool needs_stencil_in)
    : … { … }

SetDefaultFramebufferSharedImageParams::~SetDefaultFramebufferSharedImageParams() = default;

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

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

SharedImageInfo::SharedImageInfo(
    const ::gpu::SharedImageMetadata& meta_in,
    const std::string& debug_label_in)
    : … { … }

SharedImageInfo::~SharedImageInfo() = default;

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

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

CreateSharedImageParams::CreateSharedImageParams(
    const ::gpu::Mailbox& mailbox_in,
    SharedImageInfoPtr si_info_in)
    : … { … }

CreateSharedImageParams::~CreateSharedImageParams() = default;

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

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

CreateSharedImageWithDataParams::CreateSharedImageWithDataParams(
    const ::gpu::Mailbox& mailbox_in,
    SharedImageInfoPtr si_info_in,
    uint32_t pixel_data_offset_in,
    uint32_t pixel_data_size_in,
    bool done_with_shm_in)
    : … { … }

CreateSharedImageWithDataParams::~CreateSharedImageWithDataParams() = default;

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

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

CreateSharedImageWithBufferParams::CreateSharedImageWithBufferParams(
    const ::gpu::Mailbox& mailbox_in,
    SharedImageInfoPtr si_info_in,
    ::gfx::GpuMemoryBufferHandle buffer_handle_in)
    : … { … }

CreateSharedImageWithBufferParams::~CreateSharedImageWithBufferParams() = default;

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

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

UpdateSharedImageParams::UpdateSharedImageParams(
    const ::gpu::Mailbox& mailbox_in,
    ::gfx::GpuFenceHandle in_fence_handle_in)
    : … { … }

UpdateSharedImageParams::~UpdateSharedImageParams() = default;

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

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

AddReferenceToSharedImageParams::AddReferenceToSharedImageParams(
    const ::gpu::Mailbox& mailbox_in)
    : … { … }

AddReferenceToSharedImageParams::~AddReferenceToSharedImageParams() = default;

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

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

CopyToGpuMemoryBufferParams::CopyToGpuMemoryBufferParams(
    const ::gpu::Mailbox& mailbox_in)
    : … { … }

CopyToGpuMemoryBufferParams::~CopyToGpuMemoryBufferParams() = default;

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

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

DeferredRequestParams::~DeferredRequestParams() { … }


void DeferredRequestParams::set_command_buffer_request(
    DeferredCommandBufferRequestPtr command_buffer_request) { … }
void DeferredRequestParams::set_shared_image_request(
    DeferredSharedImageRequestPtr shared_image_request) { … }

void DeferredRequestParams::DestroyActive() { … }

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

DeferredCommandBufferRequestParams::~DeferredCommandBufferRequestParams() { … }


void DeferredCommandBufferRequestParams::set_async_flush(
    AsyncFlushParamsPtr async_flush) { … }
void DeferredCommandBufferRequestParams::set_destroy_transfer_buffer(
    int32_t destroy_transfer_buffer) { … }
void DeferredCommandBufferRequestParams::set_set_default_framebuffer_shared_image(
    SetDefaultFramebufferSharedImageParamsPtr set_default_framebuffer_shared_image) { … }

void DeferredCommandBufferRequestParams::DestroyActive() { … }

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

DeferredSharedImageRequest::~DeferredSharedImageRequest() { … }


void DeferredSharedImageRequest::set_nop(
    uint8_t nop) { … }
void DeferredSharedImageRequest::set_create_shared_image(
    CreateSharedImageParamsPtr create_shared_image) { … }
void DeferredSharedImageRequest::set_create_shared_image_with_data(
    CreateSharedImageWithDataParamsPtr create_shared_image_with_data) { … }
void DeferredSharedImageRequest::set_create_shared_image_with_buffer(
    CreateSharedImageWithBufferParamsPtr create_shared_image_with_buffer) { … }
void DeferredSharedImageRequest::set_register_upload_buffer(
    ::base::ReadOnlySharedMemoryRegion register_upload_buffer) { … }
void DeferredSharedImageRequest::set_update_shared_image(
    UpdateSharedImageParamsPtr update_shared_image) { … }
void DeferredSharedImageRequest::set_copy_to_gpu_memory_buffer(
    CopyToGpuMemoryBufferParamsPtr copy_to_gpu_memory_buffer) { … }
void DeferredSharedImageRequest::set_destroy_shared_image(
    const ::gpu::Mailbox& destroy_shared_image) { … }
void DeferredSharedImageRequest::set_add_reference_to_shared_image(
    AddReferenceToSharedImageParamsPtr add_reference_to_shared_image) { … }

void DeferredSharedImageRequest::DestroyActive() { … }

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t GpuChannel::CrashForTesting_Sym::IPCStableHash() { … }
uint32_t GpuChannel::TerminateForTesting_Sym::IPCStableHash() { … }
uint32_t GpuChannel::GetChannelToken_Sym::IPCStableHash() { … }
uint32_t GpuChannel::Flush_Sym::IPCStableHash() { … }
uint32_t GpuChannel::GetSharedMemoryForFlushId_Sym::IPCStableHash() { … }
uint32_t GpuChannel::CreateCommandBuffer_Sym::IPCStableHash() { … }
uint32_t GpuChannel::DestroyCommandBuffer_Sym::IPCStableHash() { … }
uint32_t GpuChannel::ScheduleImageDecode_Sym::IPCStableHash() { … }
uint32_t GpuChannel::FlushDeferredRequests_Sym::IPCStableHash() { … }
uint32_t GpuChannel::CreateGpuMemoryBuffer_Sym::IPCStableHash() { … }
uint32_t GpuChannel::GetGpuMemoryBufferHandleInfo_Sym::IPCStableHash() { … }
uint32_t GpuChannel::WaitForTokenInRange_Sym::IPCStableHash() { … }
uint32_t GpuChannel::WaitForGetOffsetInRange_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool GpuChannel::GetChannelToken(::base::UnguessableToken* out_token) { … }
bool GpuChannel::Flush() { … }
bool GpuChannel::GetSharedMemoryForFlushId(::base::ReadOnlySharedMemoryRegion* out_version_buffer) { … }
bool GpuChannel::CreateCommandBuffer(CreateCommandBufferParamsPtr params, int32_t routing_id, ::base::UnsafeSharedMemoryRegion shared_state, ::mojo::PendingAssociatedReceiver<CommandBuffer> receiver, ::mojo::PendingAssociatedRemote<CommandBufferClient> client, ::gpu::ContextResult* out_result, ::gpu::Capabilities* out_capabilties, ::gpu::GLCapabilities* out_gl_capabilities) { … }
bool GpuChannel::DestroyCommandBuffer(int32_t routing_id) { … }
bool GpuChannel::CreateGpuMemoryBuffer(const ::gfx::Size& size, const ::viz::SharedImageFormat& format, ::gfx::BufferUsage buffer_usage, ::gfx::GpuMemoryBufferHandle* out_buffer_handle) { … }
bool GpuChannel::GetGpuMemoryBufferHandleInfo(const ::gpu::Mailbox& mailbox, ::gfx::GpuMemoryBufferHandle* out_buffer_handle, ::viz::SharedImageFormat* out_format, ::gfx::Size* out_size, ::gfx::BufferUsage* out_buffer_usage) { … }
bool GpuChannel::WaitForTokenInRange(int32_t routing_id, int32_t start, int32_t end, ::gpu::CommandBuffer::State* out_state) { … }
bool GpuChannel::WaitForGetOffsetInRange(int32_t routing_id, uint32_t set_get_buffer_count, int32_t start, int32_t end, ::gpu::CommandBuffer::State* out_state) { … }
class GpuChannel_GetChannelToken_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_GetChannelToken_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_Flush_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_Flush_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_GetSharedMemoryForFlushId_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_GetSharedMemoryForFlushId_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_CreateCommandBuffer_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_CreateCommandBuffer_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_DestroyCommandBuffer_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_DestroyCommandBuffer_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_CreateGpuMemoryBuffer_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_CreateGpuMemoryBuffer_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_GetGpuMemoryBufferHandleInfo_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_GetGpuMemoryBufferHandleInfo_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_WaitForTokenInRange_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class GpuChannel_WaitForTokenInRange_ForwardToCallback
    : public mojo::MessageReceiver { … };
class GpuChannel_WaitForGetOffsetInRange_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

void GpuChannelProxy::CrashForTesting(
    ) { … }

void GpuChannelProxy::TerminateForTesting(
    ) { … }
bool GpuChannelProxy::GetChannelToken(
    ::base::UnguessableToken* out_param_token) { … }

void GpuChannelProxy::GetChannelToken(
    GetChannelTokenCallback callback) { … }
bool GpuChannelProxy::Flush(
    ) { … }

void GpuChannelProxy::Flush(
    FlushCallback callback) { … }
bool GpuChannelProxy::GetSharedMemoryForFlushId(
    ::base::ReadOnlySharedMemoryRegion* out_param_version_buffer) { … }

void GpuChannelProxy::GetSharedMemoryForFlushId(
    GetSharedMemoryForFlushIdCallback callback) { … }
bool GpuChannelProxy::CreateCommandBuffer(
    CreateCommandBufferParamsPtr param_params, int32_t param_routing_id, ::base::UnsafeSharedMemoryRegion param_shared_state, ::mojo::PendingAssociatedReceiver<CommandBuffer> param_receiver, ::mojo::PendingAssociatedRemote<CommandBufferClient> param_client, ::gpu::ContextResult* out_param_result, ::gpu::Capabilities* out_param_capabilties, ::gpu::GLCapabilities* out_param_gl_capabilities) { … }

void GpuChannelProxy::CreateCommandBuffer(
    CreateCommandBufferParamsPtr in_params, int32_t in_routing_id, ::base::UnsafeSharedMemoryRegion in_shared_state, ::mojo::PendingAssociatedReceiver<CommandBuffer> in_receiver, ::mojo::PendingAssociatedRemote<CommandBufferClient> in_client, CreateCommandBufferCallback callback) { … }
bool GpuChannelProxy::DestroyCommandBuffer(
    int32_t param_routing_id) { … }

void GpuChannelProxy::DestroyCommandBuffer(
    int32_t in_routing_id, DestroyCommandBufferCallback callback) { … }

void GpuChannelProxy::ScheduleImageDecode(
    ScheduleImageDecodeParamsPtr in_params, uint64_t in_decode_release_count) { … }

void GpuChannelProxy::FlushDeferredRequests(
    std::vector<DeferredRequestPtr> in_requests, uint32_t in_flushed_deferred_message_id) { … }
bool GpuChannelProxy::CreateGpuMemoryBuffer(
    const ::gfx::Size& param_size, const ::viz::SharedImageFormat& param_format, ::gfx::BufferUsage param_buffer_usage, ::gfx::GpuMemoryBufferHandle* out_param_buffer_handle) { … }

void GpuChannelProxy::CreateGpuMemoryBuffer(
    const ::gfx::Size& in_size, const ::viz::SharedImageFormat& in_format, ::gfx::BufferUsage in_buffer_usage, CreateGpuMemoryBufferCallback callback) { … }
bool GpuChannelProxy::GetGpuMemoryBufferHandleInfo(
    const ::gpu::Mailbox& param_mailbox, ::gfx::GpuMemoryBufferHandle* out_param_buffer_handle, ::viz::SharedImageFormat* out_param_format, ::gfx::Size* out_param_size, ::gfx::BufferUsage* out_param_buffer_usage) { … }

void GpuChannelProxy::GetGpuMemoryBufferHandleInfo(
    const ::gpu::Mailbox& in_mailbox, GetGpuMemoryBufferHandleInfoCallback callback) { … }
bool GpuChannelProxy::WaitForTokenInRange(
    int32_t param_routing_id, int32_t param_start, int32_t param_end, ::gpu::CommandBuffer::State* out_param_state) { … }

void GpuChannelProxy::WaitForTokenInRange(
    int32_t in_routing_id, int32_t in_start, int32_t in_end, WaitForTokenInRangeCallback callback) { … }
bool GpuChannelProxy::WaitForGetOffsetInRange(
    int32_t param_routing_id, uint32_t param_set_get_buffer_count, int32_t param_start, int32_t param_end, ::gpu::CommandBuffer::State* out_param_state) { … }

void GpuChannelProxy::WaitForGetOffsetInRange(
    int32_t in_routing_id, uint32_t in_set_get_buffer_count, int32_t in_start, int32_t in_end, WaitForGetOffsetInRangeCallback callback) { … }
class GpuChannel_GetChannelToken_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_GetChannelToken_ProxyToResponder::Run(
    const ::base::UnguessableToken& in_token) { … }
bool GpuChannel_GetChannelToken_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_Flush_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_Flush_ProxyToResponder::Run(
    ) { … }
bool GpuChannel_Flush_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_GetSharedMemoryForFlushId_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_GetSharedMemoryForFlushId_ProxyToResponder::Run(
    ::base::ReadOnlySharedMemoryRegion in_version_buffer) { … }
bool GpuChannel_GetSharedMemoryForFlushId_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_CreateCommandBuffer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_CreateCommandBuffer_ProxyToResponder::Run(
    ::gpu::ContextResult in_result, const ::gpu::Capabilities& in_capabilties, const ::gpu::GLCapabilities& in_gl_capabilities) { … }
bool GpuChannel_CreateCommandBuffer_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_DestroyCommandBuffer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_DestroyCommandBuffer_ProxyToResponder::Run(
    ) { … }
bool GpuChannel_DestroyCommandBuffer_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_CreateGpuMemoryBuffer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_CreateGpuMemoryBuffer_ProxyToResponder::Run(
    ::gfx::GpuMemoryBufferHandle in_buffer_handle) { … }
bool GpuChannel_CreateGpuMemoryBuffer_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_GetGpuMemoryBufferHandleInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_GetGpuMemoryBufferHandleInfo_ProxyToResponder::Run(
    ::gfx::GpuMemoryBufferHandle in_buffer_handle, const ::viz::SharedImageFormat& in_format, const ::gfx::Size& in_size, ::gfx::BufferUsage in_buffer_usage) { … }
bool GpuChannel_GetGpuMemoryBufferHandleInfo_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_WaitForTokenInRange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_WaitForTokenInRange_ProxyToResponder::Run(
    const ::gpu::CommandBuffer::State& in_state) { … }
bool GpuChannel_WaitForTokenInRange_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class GpuChannel_WaitForGetOffsetInRange_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void GpuChannel_WaitForGetOffsetInRange_ProxyToResponder::Run(
    const ::gpu::CommandBuffer::State& in_state) { … }
bool GpuChannel_WaitForGetOffsetInRange_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t CommandBuffer::SetGetBuffer_Sym::IPCStableHash() { … }
uint32_t CommandBuffer::RegisterTransferBuffer_Sym::IPCStableHash() { … }
uint32_t CommandBuffer::CreateGpuFenceFromHandle_Sym::IPCStableHash() { … }
uint32_t CommandBuffer::GetGpuFenceHandle_Sym::IPCStableHash() { … }
uint32_t CommandBuffer::SignalSyncToken_Sym::IPCStableHash() { … }
uint32_t CommandBuffer::SignalQuery_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void CommandBufferProxy::SetGetBuffer(
    int32_t in_shm_id) { … }

void CommandBufferProxy::RegisterTransferBuffer(
    int32_t in_id, ::base::UnsafeSharedMemoryRegion in_buffer) { … }

void CommandBufferProxy::CreateGpuFenceFromHandle(
    uint32_t in_gpu_fence_id, ::gfx::GpuFenceHandle in_fence_handle) { … }

void CommandBufferProxy::GetGpuFenceHandle(
    uint32_t in_id, GetGpuFenceHandleCallback callback) { … }

void CommandBufferProxy::SignalSyncToken(
    const ::gpu::SyncToken& in_sync_token, uint32_t in_signal_id) { … }

void CommandBufferProxy::SignalQuery(
    uint32_t in_query, uint32_t in_signal_id) { … }
class CommandBuffer_GetGpuFenceHandle_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void CommandBuffer_GetGpuFenceHandle_ProxyToResponder::Run(
    ::gfx::GpuFenceHandle in_fence_handle) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t CommandBufferClient::OnConsoleMessage_Sym::IPCStableHash() { … }
uint32_t CommandBufferClient::OnGpuSwitched_Sym::IPCStableHash() { … }
uint32_t CommandBufferClient::OnDestroyed_Sym::IPCStableHash() { … }
uint32_t CommandBufferClient::OnReturnData_Sym::IPCStableHash() { … }
uint32_t CommandBufferClient::OnSignalAck_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void CommandBufferClientProxy::OnConsoleMessage(
    const std::string& in_message) { … }

void CommandBufferClientProxy::OnGpuSwitched(
    ::gl::GpuPreference in_active_gpu_heuristic) { … }

void CommandBufferClientProxy::OnDestroyed(
    ::gpu::error::ContextLostReason in_reason, ::gpu::error::Error in_error) { … }

void CommandBufferClientProxy::OnReturnData(
    const std::vector<uint8_t>& in_data) { … }

void CommandBufferClientProxy::OnSignalAck(
    uint32_t in_signal_id, const ::gpu::CommandBuffer::State& in_state) { … }

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

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

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



}  // gpu::mojom


namespace mojo {


// static
bool StructTraits<::gpu::mojom::ContextCreationAttribs::DataView, ::gpu::mojom::ContextCreationAttribsPtr>::Read(
    ::gpu::mojom::ContextCreationAttribs::DataView input,
    ::gpu::mojom::ContextCreationAttribsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CreateCommandBufferParams::DataView, ::gpu::mojom::CreateCommandBufferParamsPtr>::Read(
    ::gpu::mojom::CreateCommandBufferParams::DataView input,
    ::gpu::mojom::CreateCommandBufferParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CommandBufferState::DataView, ::gpu::mojom::CommandBufferStatePtr>::Read(
    ::gpu::mojom::CommandBufferState::DataView input,
    ::gpu::mojom::CommandBufferStatePtr* output) { … }


// static
bool StructTraits<::gpu::mojom::ScheduleImageDecodeParams::DataView, ::gpu::mojom::ScheduleImageDecodeParamsPtr>::Read(
    ::gpu::mojom::ScheduleImageDecodeParams::DataView input,
    ::gpu::mojom::ScheduleImageDecodeParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::DeferredRequest::DataView, ::gpu::mojom::DeferredRequestPtr>::Read(
    ::gpu::mojom::DeferredRequest::DataView input,
    ::gpu::mojom::DeferredRequestPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::DeferredCommandBufferRequest::DataView, ::gpu::mojom::DeferredCommandBufferRequestPtr>::Read(
    ::gpu::mojom::DeferredCommandBufferRequest::DataView input,
    ::gpu::mojom::DeferredCommandBufferRequestPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::AsyncFlushParams::DataView, ::gpu::mojom::AsyncFlushParamsPtr>::Read(
    ::gpu::mojom::AsyncFlushParams::DataView input,
    ::gpu::mojom::AsyncFlushParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::SetDefaultFramebufferSharedImageParams::DataView, ::gpu::mojom::SetDefaultFramebufferSharedImageParamsPtr>::Read(
    ::gpu::mojom::SetDefaultFramebufferSharedImageParams::DataView input,
    ::gpu::mojom::SetDefaultFramebufferSharedImageParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::SharedImageInfo::DataView, ::gpu::mojom::SharedImageInfoPtr>::Read(
    ::gpu::mojom::SharedImageInfo::DataView input,
    ::gpu::mojom::SharedImageInfoPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CreateSharedImageParams::DataView, ::gpu::mojom::CreateSharedImageParamsPtr>::Read(
    ::gpu::mojom::CreateSharedImageParams::DataView input,
    ::gpu::mojom::CreateSharedImageParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CreateSharedImageWithDataParams::DataView, ::gpu::mojom::CreateSharedImageWithDataParamsPtr>::Read(
    ::gpu::mojom::CreateSharedImageWithDataParams::DataView input,
    ::gpu::mojom::CreateSharedImageWithDataParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CreateSharedImageWithBufferParams::DataView, ::gpu::mojom::CreateSharedImageWithBufferParamsPtr>::Read(
    ::gpu::mojom::CreateSharedImageWithBufferParams::DataView input,
    ::gpu::mojom::CreateSharedImageWithBufferParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::UpdateSharedImageParams::DataView, ::gpu::mojom::UpdateSharedImageParamsPtr>::Read(
    ::gpu::mojom::UpdateSharedImageParams::DataView input,
    ::gpu::mojom::UpdateSharedImageParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::AddReferenceToSharedImageParams::DataView, ::gpu::mojom::AddReferenceToSharedImageParamsPtr>::Read(
    ::gpu::mojom::AddReferenceToSharedImageParams::DataView input,
    ::gpu::mojom::AddReferenceToSharedImageParamsPtr* output) { … }


// static
bool StructTraits<::gpu::mojom::CopyToGpuMemoryBufferParams::DataView, ::gpu::mojom::CopyToGpuMemoryBufferParamsPtr>::Read(
    ::gpu::mojom::CopyToGpuMemoryBufferParams::DataView input,
    ::gpu::mojom::CopyToGpuMemoryBufferParamsPtr* output) { … }

// static
bool UnionTraits<::gpu::mojom::DeferredRequestParams::DataView, ::gpu::mojom::DeferredRequestParamsPtr>::Read(
    ::gpu::mojom::DeferredRequestParams::DataView input,
    ::gpu::mojom::DeferredRequestParamsPtr* output) { … }

// static
bool UnionTraits<::gpu::mojom::DeferredCommandBufferRequestParams::DataView, ::gpu::mojom::DeferredCommandBufferRequestParamsPtr>::Read(
    ::gpu::mojom::DeferredCommandBufferRequestParams::DataView input,
    ::gpu::mojom::DeferredCommandBufferRequestParamsPtr* output) { … }

// static
bool UnionTraits<::gpu::mojom::DeferredSharedImageRequest::DataView, ::gpu::mojom::DeferredSharedImageRequestPtr>::Read(
    ::gpu::mojom::DeferredSharedImageRequest::DataView input,
    ::gpu::mojom::DeferredSharedImageRequestPtr* 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 gpu::mojom {


void GpuChannelInterceptorForTesting::CrashForTesting() { … }
void GpuChannelInterceptorForTesting::TerminateForTesting() { … }
void GpuChannelInterceptorForTesting::GetChannelToken(GetChannelTokenCallback callback) { … }
void GpuChannelInterceptorForTesting::Flush(FlushCallback callback) { … }
void GpuChannelInterceptorForTesting::GetSharedMemoryForFlushId(GetSharedMemoryForFlushIdCallback callback) { … }
void GpuChannelInterceptorForTesting::CreateCommandBuffer(CreateCommandBufferParamsPtr params, int32_t routing_id, ::base::UnsafeSharedMemoryRegion shared_state, ::mojo::PendingAssociatedReceiver<CommandBuffer> receiver, ::mojo::PendingAssociatedRemote<CommandBufferClient> client, CreateCommandBufferCallback callback) { … }
void GpuChannelInterceptorForTesting::DestroyCommandBuffer(int32_t routing_id, DestroyCommandBufferCallback callback) { … }
void GpuChannelInterceptorForTesting::ScheduleImageDecode(ScheduleImageDecodeParamsPtr params, uint64_t decode_release_count) { … }
void GpuChannelInterceptorForTesting::FlushDeferredRequests(std::vector<DeferredRequestPtr> requests, uint32_t flushed_deferred_message_id) { … }
void GpuChannelInterceptorForTesting::CreateGpuMemoryBuffer(const ::gfx::Size& size, const ::viz::SharedImageFormat& format, ::gfx::BufferUsage buffer_usage, CreateGpuMemoryBufferCallback callback) { … }
void GpuChannelInterceptorForTesting::GetGpuMemoryBufferHandleInfo(const ::gpu::Mailbox& mailbox, GetGpuMemoryBufferHandleInfoCallback callback) { … }
void GpuChannelInterceptorForTesting::WaitForTokenInRange(int32_t routing_id, int32_t start, int32_t end, WaitForTokenInRangeCallback callback) { … }
void GpuChannelInterceptorForTesting::WaitForGetOffsetInRange(int32_t routing_id, uint32_t set_get_buffer_count, int32_t start, int32_t end, WaitForGetOffsetInRangeCallback callback) { … }
GpuChannelAsyncWaiter::GpuChannelAsyncWaiter(
    GpuChannel* proxy) : … { … }

GpuChannelAsyncWaiter::~GpuChannelAsyncWaiter() = default;

void GpuChannelAsyncWaiter::GetChannelToken(
    ::base::UnguessableToken* out_token) { … }

::base::UnguessableToken GpuChannelAsyncWaiter::GetChannelToken(
    ) { … }

void GpuChannelAsyncWaiter::Flush(
    ) { … }



void GpuChannelAsyncWaiter::GetSharedMemoryForFlushId(
    ::base::ReadOnlySharedMemoryRegion* out_version_buffer) { … }

::base::ReadOnlySharedMemoryRegion GpuChannelAsyncWaiter::GetSharedMemoryForFlushId(
    ) { … }

void GpuChannelAsyncWaiter::CreateCommandBuffer(
    CreateCommandBufferParamsPtr params, int32_t routing_id, ::base::UnsafeSharedMemoryRegion shared_state, ::mojo::PendingAssociatedReceiver<CommandBuffer> receiver, ::mojo::PendingAssociatedRemote<CommandBufferClient> client, ::gpu::ContextResult* out_result, ::gpu::Capabilities* out_capabilties, ::gpu::GLCapabilities* out_gl_capabilities) { … }



void GpuChannelAsyncWaiter::DestroyCommandBuffer(
    int32_t routing_id) { … }



void GpuChannelAsyncWaiter::CreateGpuMemoryBuffer(
    const ::gfx::Size& size, const ::viz::SharedImageFormat& format, ::gfx::BufferUsage buffer_usage, ::gfx::GpuMemoryBufferHandle* out_buffer_handle) { … }

::gfx::GpuMemoryBufferHandle GpuChannelAsyncWaiter::CreateGpuMemoryBuffer(
    const ::gfx::Size& size, const ::viz::SharedImageFormat& format, ::gfx::BufferUsage buffer_usage) { … }

void GpuChannelAsyncWaiter::GetGpuMemoryBufferHandleInfo(
    const ::gpu::Mailbox& mailbox, ::gfx::GpuMemoryBufferHandle* out_buffer_handle, ::viz::SharedImageFormat* out_format, ::gfx::Size* out_size, ::gfx::BufferUsage* out_buffer_usage) { … }



void GpuChannelAsyncWaiter::WaitForTokenInRange(
    int32_t routing_id, int32_t start, int32_t end, ::gpu::CommandBuffer::State* out_state) { … }

::gpu::CommandBuffer::State GpuChannelAsyncWaiter::WaitForTokenInRange(
    int32_t routing_id, int32_t start, int32_t end) { … }

void GpuChannelAsyncWaiter::WaitForGetOffsetInRange(
    int32_t routing_id, uint32_t set_get_buffer_count, int32_t start, int32_t end, ::gpu::CommandBuffer::State* out_state) { … }

::gpu::CommandBuffer::State GpuChannelAsyncWaiter::WaitForGetOffsetInRange(
    int32_t routing_id, uint32_t set_get_buffer_count, int32_t start, int32_t end) { … }




void CommandBufferInterceptorForTesting::SetGetBuffer(int32_t shm_id) { … }
void CommandBufferInterceptorForTesting::RegisterTransferBuffer(int32_t id, ::base::UnsafeSharedMemoryRegion buffer) { … }
void CommandBufferInterceptorForTesting::CreateGpuFenceFromHandle(uint32_t gpu_fence_id, ::gfx::GpuFenceHandle fence_handle) { … }
void CommandBufferInterceptorForTesting::GetGpuFenceHandle(uint32_t id, GetGpuFenceHandleCallback callback) { … }
void CommandBufferInterceptorForTesting::SignalSyncToken(const ::gpu::SyncToken& sync_token, uint32_t signal_id) { … }
void CommandBufferInterceptorForTesting::SignalQuery(uint32_t query, uint32_t signal_id) { … }
CommandBufferAsyncWaiter::CommandBufferAsyncWaiter(
    CommandBuffer* proxy) : … { … }

CommandBufferAsyncWaiter::~CommandBufferAsyncWaiter() = default;

void CommandBufferAsyncWaiter::GetGpuFenceHandle(
    uint32_t id, ::gfx::GpuFenceHandle* out_fence_handle) { … }

::gfx::GpuFenceHandle CommandBufferAsyncWaiter::GetGpuFenceHandle(
    uint32_t id) { … }




void CommandBufferClientInterceptorForTesting::OnConsoleMessage(const std::string& message) { … }
void CommandBufferClientInterceptorForTesting::OnGpuSwitched(::gl::GpuPreference active_gpu_heuristic) { … }
void CommandBufferClientInterceptorForTesting::OnDestroyed(::gpu::error::ContextLostReason reason, ::gpu::error::Error error) { … }
void CommandBufferClientInterceptorForTesting::OnReturnData(const std::vector<uint8_t>& data) { … }
void CommandBufferClientInterceptorForTesting::OnSignalAck(uint32_t signal_id, const ::gpu::CommandBuffer::State& state) { … }
CommandBufferClientAsyncWaiter::CommandBufferClientAsyncWaiter(
    CommandBufferClient* proxy) : … { … }

CommandBufferClientAsyncWaiter::~CommandBufferClientAsyncWaiter() = default;






}  // gpu::mojom


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