gpu/command_buffer/client/webgpu_implementation.cc - chromium/src.git - Git at Google

 // Copyright 2018 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "gpu/command_buffer/client/webgpu_implementation.h"

 #include <algorithm>
 #include <vector>

 #include <dawn/dawn_proc.h>

 #include "base/numerics/checked_math.h"
 #include "base/run_loop.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/dawn_client_memory_transfer_service.h"
 #include "gpu/command_buffer/client/dawn_client_serializer.h"
 #include "gpu/command_buffer/client/gpu_control.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"

 #define GPU_CLIENT_SINGLE_THREAD_CHECK()

 namespace gpu {
 namespace webgpu {

 #if BUILDFLAG(USE_DAWN)
 class DawnWireServices : public APIChannel {
  private:
   friend class base::RefCounted<DawnWireServices>;
   ~DawnWireServices() override { GetProcs().instanceRelease(wgpu_instance_); }

  public:
   DawnWireServices(WebGPUImplementation* webgpu_implementation,
                    WebGPUCmdHelper* helper,
                    MappedMemoryManager* mapped_memory,
                    std::unique_ptr<TransferBuffer> transfer_buffer)
       : memory_transfer_service_(mapped_memory),
         serializer_(webgpu_implementation,
                     helper,
                     &memory_transfer_service_,
                     std::move(transfer_buffer)),
         wire_client_(dawn::wire::WireClientDescriptor{
             &serializer_,
             &memory_transfer_service_,
         }),
         wgpu_instance_(wire_client_.ReserveInstance().instance) {
     DCHECK(wgpu_instance_);
   }

   const DawnProcTable& GetProcs() const override {
     return dawn::wire::client::GetProcs();
   }

   WGPUInstance GetWGPUInstance() const override { return wgpu_instance_; }

   dawn::wire::WireClient* wire_client() { return &wire_client_; }
   DawnClientSerializer* serializer() { return &serializer_; }
   DawnClientMemoryTransferService* memory_transfer_service() {
     return &memory_transfer_service_;
   }

   void Disconnect() override {
     disconnected_ = true;
     wire_client_.Disconnect();
     serializer_.Disconnect();
     memory_transfer_service_.Disconnect();
   }

   bool IsDisconnected() const { return disconnected_; }

   void FreeMappedResources(WebGPUCmdHelper* helper) {
     memory_transfer_service_.FreeHandles(helper);
   }

  private:
   bool disconnected_ = false;
   DawnClientMemoryTransferService memory_transfer_service_;
   DawnClientSerializer serializer_;
   dawn::wire::WireClient wire_client_;
   WGPUInstance wgpu_instance_;
 };
 #endif

 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/webgpu_implementation_impl_autogen.h"

 WebGPUImplementation::WebGPUImplementation(
     WebGPUCmdHelper* helper,
     TransferBufferInterface* transfer_buffer,
     GpuControl* gpu_control)
     : ImplementationBase(helper, transfer_buffer, gpu_control),
       helper_(helper) {}

 WebGPUImplementation::~WebGPUImplementation() {
   LoseContext();

   // Before destroying WebGPUImplementation, all mappable buffers
   // must be destroyed first. This means that all shared memory mappings are
   // detached. If they are not destroyed, MappedMemoryManager (member of
   // base class ImplementationBase) will assert on destruction that some
   // memory blocks are in use. Calling |FreeMappedResources| marks all
   // blocks that are no longer in use as free.
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->FreeMappedResources(helper_);
 #endif

   // Wait for commands to finish before we continue destruction.
   // WebGPUImplementation no longer owns the WebGPU transfer buffer, but still
   // owns the GPU command buffer. We should not free shared memory that the
   // GPU process is using.
   helper_->Finish();
 }

 void WebGPUImplementation::LoseContext() {
   lost_ = true;
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->Disconnect();
 #endif
 }

 gpu::ContextResult WebGPUImplementation::Initialize(
     const SharedMemoryLimits& limits) {
   TRACE_EVENT0("gpu", "WebGPUImplementation::Initialize");
   auto result = ImplementationBase::Initialize(limits);
   if (result != gpu::ContextResult::kSuccess) {
     return result;
   }

   std::unique_ptr<TransferBuffer> transfer_buffer =
       std::make_unique<TransferBuffer>(helper_);
   if (!transfer_buffer->Initialize(limits.start_transfer_buffer_size,
                                    /* start offset */ 0,
                                    limits.min_transfer_buffer_size,
                                    limits.max_transfer_buffer_size,
                                    /* alignment */ 8)) {
     return gpu::ContextResult::kFatalFailure;
   }

 #if BUILDFLAG(USE_DAWN)
   dawn_wire_ = base::MakeRefCounted<DawnWireServices>(
       this, helper_, mapped_memory_.get(), std::move(transfer_buffer));

   // TODO(senorblanco): Do this only once per process. Doing it once per
   // WebGPUImplementation is non-optimal but valid, since the returned
   // procs are always the same.
   dawnProcSetProcs(&dawn::wire::client::GetProcs());
 #endif

   return gpu::ContextResult::kSuccess;
 }

 // ContextSupport implementation.
 void WebGPUImplementation::SetAggressivelyFreeResources(
     bool aggressively_free_resources) {
   NOTIMPLEMENTED();
 }
 uint64_t WebGPUImplementation::ShareGroupTracingGUID() const {
   NOTIMPLEMENTED();
   return 0;
 }
 void WebGPUImplementation::SetErrorMessageCallback(
     base::RepeatingCallback<void(const char*, int32_t)> callback) {
   NOTIMPLEMENTED();
 }
 bool WebGPUImplementation::ThreadSafeShallowLockDiscardableTexture(
     uint32_t texture_id) {
   NOTREACHED();
   return false;
 }
 void WebGPUImplementation::CompleteLockDiscardableTexureOnContextThread(
     uint32_t texture_id) {
   NOTREACHED();
 }
 bool WebGPUImplementation::ThreadsafeDiscardableTextureIsDeletedForTracing(
     uint32_t texture_id) {
   NOTREACHED();
   return false;
 }
 void* WebGPUImplementation::MapTransferCacheEntry(uint32_t serialized_size) {
   NOTREACHED();
   return nullptr;
 }
 void WebGPUImplementation::UnmapAndCreateTransferCacheEntry(uint32_t type,
                                                             uint32_t id) {
   NOTREACHED();
 }
 bool WebGPUImplementation::ThreadsafeLockTransferCacheEntry(uint32_t type,
                                                             uint32_t id) {
   NOTREACHED();
   return false;
 }
 void WebGPUImplementation::UnlockTransferCacheEntries(
     const std::vector<std::pair<uint32_t, uint32_t>>& entries) {
   NOTREACHED();
 }
 void WebGPUImplementation::DeleteTransferCacheEntry(uint32_t type,
                                                     uint32_t id) {
   NOTREACHED();
 }
 unsigned int WebGPUImplementation::GetTransferBufferFreeSize() const {
   NOTREACHED();
   return 0;
 }
 bool WebGPUImplementation::IsJpegDecodeAccelerationSupported() const {
   NOTREACHED();
   return false;
 }
 bool WebGPUImplementation::IsWebPDecodeAccelerationSupported() const {
   NOTREACHED();
   return false;
 }
 bool WebGPUImplementation::CanDecodeWithHardwareAcceleration(
     const cc::ImageHeaderMetadata* image_metadata) const {
   NOTREACHED();
   return false;
 }

 // InterfaceBase implementation.
 void WebGPUImplementation::GenSyncTokenCHROMIUM(GLbyte* sync_token) {
   // Need to commit the commands to the GPU command buffer first for SyncToken
   // to work.
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->serializer()->Commit();
 #endif
   ImplementationBase::GenSyncToken(sync_token);
 }
 void WebGPUImplementation::GenUnverifiedSyncTokenCHROMIUM(GLbyte* sync_token) {
   // Need to commit the commands to the GPU command buffer first for SyncToken
   // to work.
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->serializer()->Commit();
 #endif
   ImplementationBase::GenUnverifiedSyncToken(sync_token);
 }
 void WebGPUImplementation::VerifySyncTokensCHROMIUM(GLbyte** sync_tokens,
                                                     GLsizei count) {
   ImplementationBase::VerifySyncTokens(sync_tokens, count);
 }
 void WebGPUImplementation::WaitSyncTokenCHROMIUM(const GLbyte* sync_token) {
   // Need to commit the commands to the GPU command buffer first for SyncToken
   // to work.
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->serializer()->Commit();
 #endif
   ImplementationBase::WaitSyncToken(sync_token);
 }
 void WebGPUImplementation::ShallowFlushCHROMIUM() {
   FlushCommands();
 }

 bool WebGPUImplementation::HasGrContextSupport() const {
   return true;
 }

 // ImplementationBase implementation.
 void WebGPUImplementation::IssueShallowFlush() {
   NOTIMPLEMENTED();
 }

 void WebGPUImplementation::SetGLError(GLenum error,
                                       const char* function_name,
                                       const char* msg) {
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] Client Synthesized Error: "
                      << gles2::GLES2Util::GetStringError(error) << ": "
                      << function_name << ": " << msg);
   NOTIMPLEMENTED();
 }

 // GpuControlClient implementation.
 void WebGPUImplementation::OnGpuControlLostContext() {
   LoseContext();

   // This should never occur more than once.
   DCHECK(!lost_context_callback_run_);
   lost_context_callback_run_ = true;
   if (!lost_context_callback_.is_null()) {
     std::move(lost_context_callback_).Run();
   }
 }
 void WebGPUImplementation::OnGpuControlLostContextMaybeReentrant() {
   // If this function is called, we are guaranteed to also get a call
   // to |OnGpuControlLostContext| when the callstack unwinds. Thus, this
   // function only handles immediately setting state so that other operations
   // which occur while the callstack is unwinding are aware that the context
   // is lost.
   lost_ = true;
 }
 void WebGPUImplementation::OnGpuControlErrorMessage(const char* message,
                                                     int32_t id) {
   NOTIMPLEMENTED();
 }
 void WebGPUImplementation::OnGpuControlReturnData(
     base::span<const uint8_t> data) {
   if (lost_) {
     return;
   }
 #if BUILDFLAG(USE_DAWN)

   static uint32_t return_trace_id = 0;
   TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("gpu.dawn"),
                          "DawnReturnCommands", return_trace_id++,
                          TRACE_EVENT_FLAG_FLOW_IN);

   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("gpu.dawn"),
                "WebGPUImplementation::OnGpuControlReturnData", "bytes",
                data.size());

   CHECK_GT(data.size(), sizeof(cmds::DawnReturnDataHeader));

   const cmds::DawnReturnDataHeader& dawnReturnDataHeader =
       *reinterpret_cast<const cmds::DawnReturnDataHeader*>(data.data());

   switch (dawnReturnDataHeader.return_data_type) {
     case DawnReturnDataType::kDawnCommands: {
       CHECK_GE(data.size(), sizeof(cmds::DawnReturnCommandsInfo));

       const cmds::DawnReturnCommandsInfo* dawn_return_commands_info =
           reinterpret_cast<const cmds::DawnReturnCommandsInfo*>(data.data());
       if (dawn_wire_->IsDisconnected()) {
         break;
       }
       // TODO(enga): Instead of a CHECK, this could generate a device lost
       // event on just that device. It doesn't seem worth doing right now
       // since a failure here is likely not recoverable.
       CHECK(dawn_wire_->wire_client()->HandleCommands(
           reinterpret_cast<const char*>(
               dawn_return_commands_info->deserialized_buffer),
           data.size() -
               offsetof(cmds::DawnReturnCommandsInfo, deserialized_buffer)));
     } break;

     default:
       NOTREACHED();
   }
 #endif
 }

 void WebGPUImplementation::FlushCommands() {
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->serializer()->Commit();
   helper_->Flush();
 #endif
 }

 bool WebGPUImplementation::EnsureAwaitingFlush() {
 #if BUILDFLAG(USE_DAWN)
   // If there is already a flush waiting, we don't need to flush.
   // We only want to ask for a flush on state transition from
   // false -> true.
   if (dawn_wire_->serializer()->AwaitingFlush()) {
     return false;
   }

   // Set the state to waiting for flush.
   dawn_wire_->serializer()->SetAwaitingFlush(true);
   return true;
 #else
   return false;
 #endif
 }

 void WebGPUImplementation::FlushAwaitingCommands() {
 #if BUILDFLAG(USE_DAWN)
   dawn_wire_->serializer()->Commit();
   helper_->FlushLazy();
   dawn_wire_->serializer()->SetAwaitingFlush(false);
 #endif
 }

 scoped_refptr<APIChannel> WebGPUImplementation::GetAPIChannel() const {
 #if BUILDFLAG(USE_DAWN)
   return dawn_wire_.get();
 #else
   return nullptr;
 #endif
 }

 ReservedTexture WebGPUImplementation::ReserveTexture(
     WGPUDevice device,
     const WGPUTextureDescriptor* optionalDesc) {
 #if BUILDFLAG(USE_DAWN)
   // Commit because we need to make sure messages that free a previously used
   // texture are seen first. ReserveTexture may reuse an existing ID.
   dawn_wire_->serializer()->Commit();

   WGPUTextureDescriptor placeholderDesc;
   if (optionalDesc == nullptr) {
     placeholderDesc = {};  // Zero initialize.
     optionalDesc = &placeholderDesc;
   }

   auto reservation =
       dawn_wire_->wire_client()->ReserveTexture(device, optionalDesc);
   ReservedTexture result;
   result.texture = reservation.texture;
   result.id = reservation.id;
   result.generation = reservation.generation;
   result.deviceId = reservation.deviceId;
   result.deviceGeneration = reservation.deviceGeneration;
   return result;
 #else
   NOTREACHED();
   return {};
 #endif
 }

 WGPUDevice WebGPUImplementation::DeprecatedEnsureDefaultDeviceSync() {
   NOTIMPLEMENTED();
   return nullptr;
 }

 void WebGPUImplementation::AssociateMailbox(GLuint device_id,
                                             GLuint device_generation,
                                             GLuint texture_id,
                                             GLuint texture_generation,
                                             GLuint usage,
                                             MailboxFlags flags,
                                             const GLbyte* mailbox) {
 #if BUILDFLAG(USE_DAWN)
   // Commit previous Dawn commands as they may manipulate texture object IDs
   // and need to be resolved prior to the AssociateMailbox command. Otherwise
   // the service side might not know, for example that the previous texture
   // using that ID has been released.
   dawn_wire_->serializer()->Commit();
   helper_->AssociateMailboxImmediate(device_id, device_generation, texture_id,
                                      texture_generation, usage, flags, mailbox);
 #endif
 }

 void WebGPUImplementation::DissociateMailbox(GLuint texture_id,
                                              GLuint texture_generation) {
 #if BUILDFLAG(USE_DAWN)
   // Commit previous Dawn commands that might be rendering to the texture, prior
   // to Dissociating the shared image from that texture.
   dawn_wire_->serializer()->Commit();
   helper_->DissociateMailbox(texture_id, texture_generation);
 #endif
 }

 void WebGPUImplementation::DissociateMailboxForPresent(
     GLuint device_id,
     GLuint device_generation,
     GLuint texture_id,
     GLuint texture_generation) {
 #if BUILDFLAG(USE_DAWN)
   // Commit previous Dawn commands that might be rendering to the texture, prior
   // to Dissociating the shared image from that texture.
   dawn_wire_->serializer()->Commit();
   helper_->DissociateMailboxForPresent(device_id, device_generation, texture_id,
                                        texture_generation);
 #endif
 }

 void WebGPUImplementation::SetExecutionContextToken(uint32_t type,
                                                     uint32_t high_high,
                                                     uint32_t high_low,
                                                     uint32_t low_high,
                                                     uint32_t low_low) {
 #if BUILDFLAG(USE_DAWN)
   helper_->SetExecutionContextToken(type, high_high, high_low, low_high,
                                     low_low);
 #endif
 }

 }  // namespace webgpu
 }  // namespace gpu
	// Copyright 2018 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "gpu/command_buffer/client/webgpu_implementation.h"

	#include <algorithm>
	#include <vector>

	#include <dawn/dawn_proc.h>

	#include "base/numerics/checked_math.h"
	#include "base/run_loop.h"
	#include "base/trace_event/trace_event.h"
	#include "gpu/command_buffer/client/dawn_client_memory_transfer_service.h"
	#include "gpu/command_buffer/client/dawn_client_serializer.h"
	#include "gpu/command_buffer/client/gpu_control.h"
	#include "gpu/command_buffer/client/shared_memory_limits.h"

	#define GPU_CLIENT_SINGLE_THREAD_CHECK()

	namespace gpu {
	namespace webgpu {

	#if BUILDFLAG(USE_DAWN)
	class DawnWireServices : public APIChannel {
	private:
	friend class base::RefCounted<DawnWireServices>;
	~DawnWireServices() override { GetProcs().instanceRelease(wgpu_instance_); }

	public:
	DawnWireServices(WebGPUImplementation* webgpu_implementation,
	WebGPUCmdHelper* helper,
	MappedMemoryManager* mapped_memory,
	std::unique_ptr<TransferBuffer> transfer_buffer)
	: memory_transfer_service_(mapped_memory),
	serializer_(webgpu_implementation,
	helper,
	&memory_transfer_service_,
	std::move(transfer_buffer)),
	wire_client_(dawn::wire::WireClientDescriptor{
	&serializer_,
	&memory_transfer_service_,
	}),
	wgpu_instance_(wire_client_.ReserveInstance().instance) {
	DCHECK(wgpu_instance_);
	}

	const DawnProcTable& GetProcs() const override {
	return dawn::wire::client::GetProcs();
	}

	WGPUInstance GetWGPUInstance() const override { return wgpu_instance_; }

	dawn::wire::WireClient* wire_client() { return &wire_client_; }
	DawnClientSerializer* serializer() { return &serializer_; }
	DawnClientMemoryTransferService* memory_transfer_service() {
	return &memory_transfer_service_;
	}

	void Disconnect() override {
	disconnected_ = true;
	wire_client_.Disconnect();
	serializer_.Disconnect();
	memory_transfer_service_.Disconnect();
	}

	bool IsDisconnected() const { return disconnected_; }

	void FreeMappedResources(WebGPUCmdHelper* helper) {
	memory_transfer_service_.FreeHandles(helper);
	}

	private:
	bool disconnected_ = false;
	DawnClientMemoryTransferService memory_transfer_service_;
	DawnClientSerializer serializer_;
	dawn::wire::WireClient wire_client_;
	WGPUInstance wgpu_instance_;
	};
	#endif

	// Include the auto-generated part of this file. We split this because it means
	// we can easily edit the non-auto generated parts right here in this file
	// instead of having to edit some template or the code generator.
	#include "gpu/command_buffer/client/webgpu_implementation_impl_autogen.h"

	WebGPUImplementation::WebGPUImplementation(
	WebGPUCmdHelper* helper,
	TransferBufferInterface* transfer_buffer,
	GpuControl* gpu_control)
	: ImplementationBase(helper, transfer_buffer, gpu_control),
	helper_(helper) {}

	WebGPUImplementation::~WebGPUImplementation() {
	LoseContext();

	// Before destroying WebGPUImplementation, all mappable buffers
	// must be destroyed first. This means that all shared memory mappings are
	// detached. If they are not destroyed, MappedMemoryManager (member of
	// base class ImplementationBase) will assert on destruction that some
	// memory blocks are in use. Calling \|FreeMappedResources\| marks all
	// blocks that are no longer in use as free.
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->FreeMappedResources(helper_);
	#endif

	// Wait for commands to finish before we continue destruction.
	// WebGPUImplementation no longer owns the WebGPU transfer buffer, but still
	// owns the GPU command buffer. We should not free shared memory that the
	// GPU process is using.
	helper_->Finish();
	}

	void WebGPUImplementation::LoseContext() {
	lost_ = true;
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->Disconnect();
	#endif
	}

	gpu::ContextResult WebGPUImplementation::Initialize(
	const SharedMemoryLimits& limits) {
	TRACE_EVENT0("gpu", "WebGPUImplementation::Initialize");
	auto result = ImplementationBase::Initialize(limits);
	if (result != gpu::ContextResult::kSuccess) {
	return result;
	}

	std::unique_ptr<TransferBuffer> transfer_buffer =
	std::make_unique<TransferBuffer>(helper_);
	if (!transfer_buffer->Initialize(limits.start_transfer_buffer_size,
	/* start offset */ 0,
	limits.min_transfer_buffer_size,
	limits.max_transfer_buffer_size,
	/* alignment */ 8)) {
	return gpu::ContextResult::kFatalFailure;
	}

	#if BUILDFLAG(USE_DAWN)
	dawn_wire_ = base::MakeRefCounted<DawnWireServices>(
	this, helper_, mapped_memory_.get(), std::move(transfer_buffer));

	// TODO(senorblanco): Do this only once per process. Doing it once per
	// WebGPUImplementation is non-optimal but valid, since the returned
	// procs are always the same.
	dawnProcSetProcs(&dawn::wire::client::GetProcs());
	#endif

	return gpu::ContextResult::kSuccess;
	}

	// ContextSupport implementation.
	void WebGPUImplementation::SetAggressivelyFreeResources(
	bool aggressively_free_resources) {
	NOTIMPLEMENTED();
	}
	uint64_t WebGPUImplementation::ShareGroupTracingGUID() const {
	NOTIMPLEMENTED();
	return 0;
	}
	void WebGPUImplementation::SetErrorMessageCallback(
	base::RepeatingCallback<void(const char*, int32_t)> callback) {
	NOTIMPLEMENTED();
	}
	bool WebGPUImplementation::ThreadSafeShallowLockDiscardableTexture(
	uint32_t texture_id) {
	NOTREACHED();
	return false;
	}
	void WebGPUImplementation::CompleteLockDiscardableTexureOnContextThread(
	uint32_t texture_id) {
	NOTREACHED();
	}
	bool WebGPUImplementation::ThreadsafeDiscardableTextureIsDeletedForTracing(
	uint32_t texture_id) {
	NOTREACHED();
	return false;
	}
	void* WebGPUImplementation::MapTransferCacheEntry(uint32_t serialized_size) {
	NOTREACHED();
	return nullptr;
	}
	void WebGPUImplementation::UnmapAndCreateTransferCacheEntry(uint32_t type,
	uint32_t id) {
	NOTREACHED();
	}
	bool WebGPUImplementation::ThreadsafeLockTransferCacheEntry(uint32_t type,
	uint32_t id) {
	NOTREACHED();
	return false;
	}
	void WebGPUImplementation::UnlockTransferCacheEntries(
	const std::vector<std::pair<uint32_t, uint32_t>>& entries) {
	NOTREACHED();
	}
	void WebGPUImplementation::DeleteTransferCacheEntry(uint32_t type,
	uint32_t id) {
	NOTREACHED();
	}
	unsigned int WebGPUImplementation::GetTransferBufferFreeSize() const {
	NOTREACHED();
	return 0;
	}
	bool WebGPUImplementation::IsJpegDecodeAccelerationSupported() const {
	NOTREACHED();
	return false;
	}
	bool WebGPUImplementation::IsWebPDecodeAccelerationSupported() const {
	NOTREACHED();
	return false;
	}
	bool WebGPUImplementation::CanDecodeWithHardwareAcceleration(
	const cc::ImageHeaderMetadata* image_metadata) const {
	NOTREACHED();
	return false;
	}

	// InterfaceBase implementation.
	void WebGPUImplementation::GenSyncTokenCHROMIUM(GLbyte* sync_token) {
	// Need to commit the commands to the GPU command buffer first for SyncToken
	// to work.
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->serializer()->Commit();
	#endif
	ImplementationBase::GenSyncToken(sync_token);
	}
	void WebGPUImplementation::GenUnverifiedSyncTokenCHROMIUM(GLbyte* sync_token) {
	// Need to commit the commands to the GPU command buffer first for SyncToken
	// to work.
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->serializer()->Commit();
	#endif
	ImplementationBase::GenUnverifiedSyncToken(sync_token);
	}
	void WebGPUImplementation::VerifySyncTokensCHROMIUM(GLbyte** sync_tokens,
	GLsizei count) {
	ImplementationBase::VerifySyncTokens(sync_tokens, count);
	}
	void WebGPUImplementation::WaitSyncTokenCHROMIUM(const GLbyte* sync_token) {
	// Need to commit the commands to the GPU command buffer first for SyncToken
	// to work.
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->serializer()->Commit();
	#endif
	ImplementationBase::WaitSyncToken(sync_token);
	}
	void WebGPUImplementation::ShallowFlushCHROMIUM() {
	FlushCommands();
	}

	bool WebGPUImplementation::HasGrContextSupport() const {
	return true;
	}

	// ImplementationBase implementation.
	void WebGPUImplementation::IssueShallowFlush() {
	NOTIMPLEMENTED();
	}

	void WebGPUImplementation::SetGLError(GLenum error,
	const char* function_name,
	const char* msg) {
	GPU_CLIENT_LOG("[" << GetLogPrefix() << "] Client Synthesized Error: "
	<< gles2::GLES2Util::GetStringError(error) << ": "
	<< function_name << ": " << msg);
	NOTIMPLEMENTED();
	}

	// GpuControlClient implementation.
	void WebGPUImplementation::OnGpuControlLostContext() {
	LoseContext();

	// This should never occur more than once.
	DCHECK(!lost_context_callback_run_);
	lost_context_callback_run_ = true;
	if (!lost_context_callback_.is_null()) {
	std::move(lost_context_callback_).Run();
	}
	}
	void WebGPUImplementation::OnGpuControlLostContextMaybeReentrant() {
	// If this function is called, we are guaranteed to also get a call
	// to \|OnGpuControlLostContext\| when the callstack unwinds. Thus, this
	// function only handles immediately setting state so that other operations
	// which occur while the callstack is unwinding are aware that the context
	// is lost.
	lost_ = true;
	}
	void WebGPUImplementation::OnGpuControlErrorMessage(const char* message,
	int32_t id) {
	NOTIMPLEMENTED();
	}
	void WebGPUImplementation::OnGpuControlReturnData(
	base::span<const uint8_t> data) {
	if (lost_) {
	return;
	}
	#if BUILDFLAG(USE_DAWN)

	static uint32_t return_trace_id = 0;
	TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("gpu.dawn"),
	"DawnReturnCommands", return_trace_id++,
	TRACE_EVENT_FLAG_FLOW_IN);

	TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("gpu.dawn"),
	"WebGPUImplementation::OnGpuControlReturnData", "bytes",
	data.size());

	CHECK_GT(data.size(), sizeof(cmds::DawnReturnDataHeader));

	const cmds::DawnReturnDataHeader& dawnReturnDataHeader =
	reinterpret_cast<const cmds::DawnReturnDataHeader>(data.data());

	switch (dawnReturnDataHeader.return_data_type) {
	case DawnReturnDataType::kDawnCommands: {
	CHECK_GE(data.size(), sizeof(cmds::DawnReturnCommandsInfo));

	const cmds::DawnReturnCommandsInfo* dawn_return_commands_info =
	reinterpret_cast<const cmds::DawnReturnCommandsInfo*>(data.data());
	if (dawn_wire_->IsDisconnected()) {
	break;
	}
	// TODO(enga): Instead of a CHECK, this could generate a device lost
	// event on just that device. It doesn't seem worth doing right now
	// since a failure here is likely not recoverable.
	CHECK(dawn_wire_->wire_client()->HandleCommands(
	reinterpret_cast<const char*>(
	dawn_return_commands_info->deserialized_buffer),
	data.size() -
	offsetof(cmds::DawnReturnCommandsInfo, deserialized_buffer)));
	} break;

	default:
	NOTREACHED();
	}
	#endif
	}

	void WebGPUImplementation::FlushCommands() {
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->serializer()->Commit();
	helper_->Flush();
	#endif
	}

	bool WebGPUImplementation::EnsureAwaitingFlush() {
	#if BUILDFLAG(USE_DAWN)
	// If there is already a flush waiting, we don't need to flush.
	// We only want to ask for a flush on state transition from
	// false -> true.
	if (dawn_wire_->serializer()->AwaitingFlush()) {
	return false;
	}

	// Set the state to waiting for flush.
	dawn_wire_->serializer()->SetAwaitingFlush(true);
	return true;
	#else
	return false;
	#endif
	}

	void WebGPUImplementation::FlushAwaitingCommands() {
	#if BUILDFLAG(USE_DAWN)
	dawn_wire_->serializer()->Commit();
	helper_->FlushLazy();
	dawn_wire_->serializer()->SetAwaitingFlush(false);
	#endif
	}

	scoped_refptr<APIChannel> WebGPUImplementation::GetAPIChannel() const {
	#if BUILDFLAG(USE_DAWN)
	return dawn_wire_.get();
	#else
	return nullptr;
	#endif
	}

	ReservedTexture WebGPUImplementation::ReserveTexture(
	WGPUDevice device,
	const WGPUTextureDescriptor* optionalDesc) {
	#if BUILDFLAG(USE_DAWN)
	// Commit because we need to make sure messages that free a previously used
	// texture are seen first. ReserveTexture may reuse an existing ID.
	dawn_wire_->serializer()->Commit();

	WGPUTextureDescriptor placeholderDesc;
	if (optionalDesc == nullptr) {
	placeholderDesc = {}; // Zero initialize.
	optionalDesc = &placeholderDesc;
	}

	auto reservation =
	dawn_wire_->wire_client()->ReserveTexture(device, optionalDesc);
	ReservedTexture result;
	result.texture = reservation.texture;
	result.id = reservation.id;
	result.generation = reservation.generation;
	result.deviceId = reservation.deviceId;
	result.deviceGeneration = reservation.deviceGeneration;
	return result;
	#else
	NOTREACHED();
	return {};
	#endif
	}

	WGPUDevice WebGPUImplementation::DeprecatedEnsureDefaultDeviceSync() {
	NOTIMPLEMENTED();
	return nullptr;
	}

	void WebGPUImplementation::AssociateMailbox(GLuint device_id,
	GLuint device_generation,
	GLuint texture_id,
	GLuint texture_generation,
	GLuint usage,
	MailboxFlags flags,
	const GLbyte* mailbox) {
	#if BUILDFLAG(USE_DAWN)
	// Commit previous Dawn commands as they may manipulate texture object IDs
	// and need to be resolved prior to the AssociateMailbox command. Otherwise
	// the service side might not know, for example that the previous texture
	// using that ID has been released.
	dawn_wire_->serializer()->Commit();
	helper_->AssociateMailboxImmediate(device_id, device_generation, texture_id,
	texture_generation, usage, flags, mailbox);
	#endif
	}

	void WebGPUImplementation::DissociateMailbox(GLuint texture_id,
	GLuint texture_generation) {
	#if BUILDFLAG(USE_DAWN)
	// Commit previous Dawn commands that might be rendering to the texture, prior
	// to Dissociating the shared image from that texture.
	dawn_wire_->serializer()->Commit();
	helper_->DissociateMailbox(texture_id, texture_generation);
	#endif
	}

	void WebGPUImplementation::DissociateMailboxForPresent(
	GLuint device_id,
	GLuint device_generation,
	GLuint texture_id,
	GLuint texture_generation) {
	#if BUILDFLAG(USE_DAWN)
	// Commit previous Dawn commands that might be rendering to the texture, prior
	// to Dissociating the shared image from that texture.
	dawn_wire_->serializer()->Commit();
	helper_->DissociateMailboxForPresent(device_id, device_generation, texture_id,
	texture_generation);
	#endif
	}

	void WebGPUImplementation::SetExecutionContextToken(uint32_t type,
	uint32_t high_high,
	uint32_t high_low,
	uint32_t low_high,
	uint32_t low_low) {
	#if BUILDFLAG(USE_DAWN)
	helper_->SetExecutionContextToken(type, high_high, high_low, low_high,
	low_low);
	#endif
	}

	} // namespace webgpu
	} // namespace gpu