// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
module gpu.mojom;
import "gpu/ipc/common/capabilities.mojom";
import "gpu/ipc/common/context_result.mojom";
import "gpu/ipc/common/mailbox.mojom";
import "gpu/ipc/common/shared_image_metadata.mojom";
import "gpu/ipc/common/surface_handle.mojom";
import "gpu/ipc/common/sync_token.mojom";
import "gpu/ipc/common/vulkan_ycbcr_info.mojom";
import "mojo/public/mojom/base/shared_memory.mojom";
import "mojo/public/mojom/base/unguessable_token.mojom";
import "services/viz/public/mojom/compositing/shared_image_format.mojom";
import "skia/public/mojom/image_info.mojom";
import "skia/public/mojom/surface_origin.mojom";
import "ui/gfx/geometry/mojom/geometry.mojom";
import "ui/gfx/mojom/buffer_types.mojom";
import "ui/gfx/mojom/color_space.mojom";
import "ui/gfx/mojom/gpu_fence_handle.mojom";
import "ui/gfx/mojom/native_handle_types.mojom";
import "ui/gfx/mojom/presentation_feedback.mojom";
import "ui/gl/mojom/gpu_preference.mojom";
import "url/mojom/url.mojom";
// Maps to its namesake in gpu/command_buffer/common/context_creation_attribs.h.
enum ContextType {
kWebGL1,
kWebGL2,
kOpenGLES2,
kOpenGLES3,
kOpenGLES31ForTesting,
kWebGPU,
};
// Maps to its namesake in gpu/command_buffer/common/context_creation_attribs.h.
enum ContextColorSpace {
kUnspecified,
kSRGB,
kDisplayP3,
};
// Maps to its namesake in gpu/command_buffer/common/scheduling_priority.h.
enum SchedulingPriority {
kHigh,
kNormal,
kLow,
};
// Maps to its namesake in gpu/command_buffer/common/context_creation_attribs.h.
struct ContextCreationAttribs {
gl.mojom.GpuPreference gpu_preference = kLowPower;
bool bind_generates_resource = true;
bool fail_if_major_perf_caveat = false;
bool lose_context_when_out_of_memory = false;
bool enable_gles2_interface = true;
bool enable_grcontext = false;
bool enable_raster_interface = false;
bool enable_oop_rasterization = false;
ContextType context_type = kOpenGLES2;
};
struct CreateCommandBufferParams {
[EnableIf=is_android] SurfaceHandle surface_handle;
int32 share_group_id;
int32 stream_id;
SchedulingPriority stream_priority;
ContextCreationAttribs attribs;
url.mojom.Url active_url;
};
// Corresponds to the definition in gpu/command_buffer/common/constants.h.
[Native]
enum Error;
// Corresponds to the definition in gpu/command_buffer/common/constants.h.
[Native]
enum ContextLostReason;
// Information used by the GPU service to convey the current state of a specific
// CommandBuffer instance. Corresponds to gpu::CommandBuffer::State. See
// gpu/command_buffer/common/command_buffer.h.
struct CommandBufferState {
int32 get_offset;
int32 token;
uint64 release_count;
Error error;
ContextLostReason context_lost_reason;
uint32 generation;
uint32 set_get_buffer_count;
};
struct ScheduleImageDecodeParams {
array<uint8> encoded_data;
gfx.mojom.Size output_size;
int32 raster_decoder_route_id;
uint32 transfer_cache_entry_id;
int32 discardable_handle_shm_id;
uint32 discardable_handle_shm_offset;
uint64 discardable_handle_release_count;
gfx.mojom.ColorSpace target_color_space;
bool needs_mips;
};
// Main control interface for a GPU process connection. For now an instance of
// this interface is associated with each C++ GpuChannel/Host's underlying
// IPC::Channel interface. Eventually it will replace the IPC::Channel.
interface GpuChannel {
// Crashes the GPU process in a similar way to how chrome://gpucrash does.
// This is only supported in testing environments with the GPU benchmarking
// extension enabled and is otherwise ignored.
//
// NOTE: It's important to handle this message early, on the IO thread, in
// case the main thread is hung. This is the purpose of this message:
// generating minidumps on the bots, which are symbolized later by the test
// harness.
CrashForTesting();
// Terminates the GPU process with an exit code of 0. This message is handled
// only in tests when the GPU benchmarking extension is enabled. Its purpose
// is to enable test coverage of scenarios where the GPU process is
// intentionally terminated with an exit code of 0.
TerminateForTesting();
// Returns a globally unique token which can be used by other interfaces to
// securely identify this GpuChannel endpoint within the GPU process.
[Sync] GetChannelToken() => (mojo_base.mojom.UnguessableToken token);
// A simple no-op message used as a fence to ensure all previously sent
// messages have been received.
//
// NoInterrupt is safe on this message because it's handled immediately on the
// GPU IO thread, which is never allowed to block.
[Sync, NoInterrupt] Flush() => ();
// `version_buffer` is a handle to a shared memory region that only
// contains a single 64 bit atomic integer used as a flushed message id.
// The number is read from renderers and updated from the
// gpu process on FlushDeferredRequests.
[Sync, NoInterrupt] GetSharedMemoryForFlushId() =>
(mojo_base.mojom.ReadOnlySharedMemoryRegion? version_buffer);
// Tells the GPU process to create a new command buffer. A corresponding
// CommandBufferStub is created. If `params` provides a non-null
// SurfaceHandle, |size| is ignored and it will render directly to the native
// surface (only the browser process is allowed to create those). Otherwise it
// will create an offscreen backbuffer of dimensions `size`.
[Sync, NoInterrupt] CreateCommandBuffer(
CreateCommandBufferParams params, int32 routing_id,
mojo_base.mojom.UnsafeSharedMemoryRegion shared_state,
pending_associated_receiver<CommandBuffer> receiver,
pending_associated_remote<CommandBufferClient> client)
=> (ContextResult result, Capabilities capabilties,
GLCapabilities gl_capabilities);
// The CommandBufferProxy sends this to the CommandBufferStub in its
// destructor, so that the stub deletes the actual CommandBufferService
// object that it's hosting.
[Sync, NoInterrupt] DestroyCommandBuffer(int32 routing_id) => ();
// Schedules a hardware-accelerated image decode in the GPU process. Renderers
// should use gpu::ImageDecodeAcceleratorProxy to schedule decode requests
// which are processed by gpu::ImageDecodeAcceleratorStub on the service side.
ScheduleImageDecode(ScheduleImageDecodeParams params,
uint64 decode_release_count);
// Sends a batch of DeferredRequests to be executed by the service.
// `flushed_deferred_message_id` is used to update the per-channel id of
// messages confirmed to be flushed that's read on the client side through
// shared memory obtained by GetSharedMemoryForFlushId().
FlushDeferredRequests(array<DeferredRequest> requests,
uint32 flushed_deferred_message_id);
// Create a GpuMemoryBuffer on IO thread. Note that this needs to be a
// blocking call on calling client's thread in order to return the
// GpuMemoryBufferHandle before it's used to create a mailbox from it.
[Sync] CreateGpuMemoryBuffer(gfx.mojom.Size size,
viz.mojom.SharedImageFormat format, gfx.mojom.BufferUsage buffer_usage)
=> (gfx.mojom.GpuMemoryBufferHandle buffer_handle);
// Gets the GpuMemoryBufferHandle for the corresponding `mailbox` from
// service side. Note that this needs to be a blocking call on calling
// client's thread in order to return the GpuMemoryBufferHandle and other
// metadata required by client to map the mailbox to CPU memory before it can
// read/write from/to it.
[Sync] GetGpuMemoryBufferHandleInfo(gpu.mojom.Mailbox mailbox)
=> (gfx.mojom.GpuMemoryBufferHandle buffer_handle,
viz.mojom.SharedImageFormat format, gfx.mojom.Size size,
gfx.mojom.BufferUsage buffer_usage);
// Creates a StreamTexture associated with the given `stream_id`.
[Sync, EnableIf=is_android] CreateStreamTexture(
int32 stream_id,
pending_associated_receiver<StreamTexture> receiver) => (bool success);
// Creates a DCOMPTexture and attaches to the provided `route_id`.
// Note: this `route_id` must not conflict with the routing ids for command
// buffers or shared image stub. Otherwise, unexpected behaviour can happen
// if `Add/RemoveRoute()` is called with a pre-existing routing id.
[Sync, EnableIf=is_win] CreateDCOMPTexture(
int32 route_id,
pending_associated_receiver<DCOMPTexture> receiver) => (bool success);
// This interface is used by MediaFoundationRendererClient to subscribe
// to overlay state information from the Viz layer (as provided by the
// DCOverlayProcessor). The MediaFoundationRendererClient uses the overlay
// state associated with a Video Frame texture (correlated via 'mailbox') as
// a heuristic to determine the best video presentation mode to use.
[Sync, EnableIf=is_win] RegisterOverlayStateObserver(
pending_remote<OverlayStateObserver> promotion_hint_observer,
gpu.mojom.Mailbox mailbox) => (bool success);
// Instructs the command buffer to wait asynchronously until its State is
// changed by the reader to have a current token value within the (inclusive)
// range [start, end]. Once in range, the command buffer will reply and
// unblock the caller.
//
// TODO(rockot): This should move to the CommandBuffer interface, but it has
// unique dispatching constraints which require it to be processed
// out-of-order from other scheduled messages targeting the command buffer.
// For now we use a GpuChannel message with a `routing_id` to target a
// specific CommandBuffer.
[Sync, NoInterrupt] WaitForTokenInRange(
int32 routing_id, int32 start, int32 end) => (CommandBufferState state);
// Instructs the command buffer to wait asynchronously until its State is
// changed by the reader to have a current get offset within the (inclusive)
// range [start, end], on the get buffer identified by `set_get_buffer_count`.
// Once in range, the command buffer will reply and unblock the caller.
//
// TODO(rockot): This should move to the CommandBuffer interface, but it has
// unique dispatching constraints which require it to be processed
// out-of-order from other scheduled messages targeting the command buffer.
// For now we use a GpuChannel message with a `routing_id` to target a
// specific CommandBuffer.
[Sync, NoInterrupt] WaitForGetOffsetInRange(
int32 routing_id, uint32 set_get_buffer_count, int32 start, int32 end)
=> (CommandBufferState state);
[EnableIf=is_fuchsia]
RegisterSysmemBufferCollection(
handle<platform> service_handle, handle<platform> sysmem_token,
viz.mojom.SharedImageFormat format, gfx.mojom.BufferUsage usage,
bool register_with_image_pipe);
// Updates the contents of the GpuMemoryBuffer associated with the shared
// image. Necessary on platforms like Windows where we use shared memory GMBs
// for readback from D3D texture shared images. The copy, if successful, is
// complete when the callback runs.
[EnableIf=is_win]
CopyToGpuMemoryBufferAsync(
Mailbox mailbox, array<SyncToken> sync_token_dependencies,
uint64 release_count) => (bool success);
};
// Interface used to issue commands to a specific CommandBuffer instance in the
// GPU process.
interface CommandBuffer {
// Sets the shared memory buffer to use for commands. The ID given here must
// correspond to one registered by a prior RegisterTransferBuffer IPC to the
// same CommandBuffer.
SetGetBuffer(int32 shm_id);
// Registers an existing shared memory transfer buffer with an `id` that can
// be used to identify it within a command buffer.
RegisterTransferBuffer(int32 id,
mojo_base.mojom.UnsafeSharedMemoryRegion buffer);
// Sends a GPU fence handle and store it for the specified gpu fence ID.
CreateGpuFenceFromHandle(uint32 gpu_fence_id,
gfx.mojom.GpuFenceHandle fence_handle);
// Requests retrieval of a GpuFenceHandle by ID.
GetGpuFenceHandle(uint32 id) => (gfx.mojom.GpuFenceHandle? fence_handle);
// Asynchronously waits until the SyncToken is signaled, then sends a
// corresponding SignalAck on the CommandBufferClient interface, using
// `signal_id` to identify this request.
SignalSyncToken(SyncToken sync_token, uint32 signal_id);
// Asynchronously waits until a given query is reached in the command buffer,
// then sends a corresponding SignalAck on the CommandBufferClient interface,
// using `signal_id` to identify this request.
SignalQuery(uint32 query, uint32 signal_id);
};
// Corresponds to gpu::SwapBuffersCompleteParams.
[Native]
struct SwapBuffersCompleteParams;
// Interface used by the GPU process to send the client messages from a specific
// CommandBuffer instance.
interface CommandBufferClient {
// Notifies the client about a console message emitted on behalf of the
// command buffer. These messages are intended to be exposed by
// developer-facing UI such as the DevTools console.
OnConsoleMessage(string message);
// Notifies the client of a GPU switch.
OnGpuSwitched(gl.mojom.GpuPreference active_gpu_heuristic);
// Tells the proxy that there was an error and the command buffer had to be
// destroyed for some reason.
OnDestroyed(ContextLostReason reason, Error error);
// Returns a block of data from the GPU process to the client.
// This contains server->client messages produced by dawn_wire and is used to
// remote WebGPU.
OnReturnData(array<uint8> data);
// Signals the completion of an asynchronous wait initiated by SignalSyncToken
// or SignalQuery on the corresponding CommandBuffer interface. `signal_id`
// identifies the specific request being acknowledged.
OnSignalAck(uint32 signal_id, CommandBufferState state);
};
// Interface to control a single StreamTexture instance. Implemented in the GPU
// process and called by renderer clients.
//
// NOTE: Due to limitations of Channel-associated interfaces, message replies on
// this interface must not be used to pass other associated interface remotes or
// receivers.
[EnableIf=is_android]
interface StreamTexture {
// Tells the StreamTexture to send its SurfaceTexture to the browser process,
// via the ScopedSurfaceRequestConduit. `token` is used to uniquely identify
// the surface request to the browser, and therefore must be a token already
// minted by the browser and somehow procured by the caller.
ForwardForSurfaceRequest(mojo_base.mojom.UnguessableToken token);
// Tells the service-side instance to start sending frame available
// notifications.
StartListening(pending_associated_remote<StreamTextureClient> client);
// Updates the visible size from MediaPlayer. The size includes rotation of
// video.
UpdateRotatedVisibleSize(gfx.mojom.Size rotated_visible_size);
};
// Interface used by GPU to notify the client of a StreamTexture instance about
// new frame availability. Implemented by renderer clients and called by
// StreamTexture instances in the GPU process.
//
// NOTE: Due to limitations of Channel-associated interfaces, messages on this
// interface must not be used to pass other associated interface remotes or
// receivers.
[EnableIf=is_android]
interface StreamTextureClient {
// Informs the client that a new frame is available.
OnFrameAvailable();
// Informs the client that a new frame with VulkanYcbcrInfo is available.
OnFrameWithInfoAvailable(Mailbox mailbox, gfx.mojom.Size coded_size,
gfx.mojom.Rect visible_rect,
VulkanYCbCrInfo? info);
};
// Interface to control a single DCOMPTexture instance. Implemented in the GPU
// process and called by renderer clients.
[EnableIf=is_win]
interface DCOMPTexture {
// Starts sending DCOMP surface notifications via the `client`. Follows the
// pattern in `StreamTexture::StartListening()` to delay notifications until
// the client side is ready.
//
// TODO(crbug.com/40642952): Investigate if we can remove this by having the
// `client` as a parameter to `CreateDCOMPTexture()`.
StartListening(pending_associated_remote<DCOMPTextureClient> client);
// Sets the size of DCOMPTexture.
SetTextureSize(gfx.mojom.Size size);
// Binds the DCOMPTexture to a DCOMP surface handle and returns whether the
// operation succeeded or not. The surface handle is provided as `token`
// registered with the DCOMP surface handle registry in the GPU process.
SetDCOMPSurfaceHandle(mojo_base.mojom.UnguessableToken token)
=> (bool success);
};
// Interface used by GPU to notify the client of a DCOMPTexture instance about
// SharedImage mailbox and DCOMP Surface Handle have been bound to the
// DCOMPTexture instance. It also notifies client about the change in compositon
// on-screen output video rectangle. Implemented by renderer clients and called
// by DCOMPTexture instances in the GPU process.
[EnableIf=is_win]
interface DCOMPTextureClient {
// Informs the client that a SharedImage mailbox has been bound to the
// DCOMPTexture instance.
OnSharedImageMailboxBound(Mailbox mailbox);
// Informs the client of a change in video composition parameter.
OnOutputRectChange(gfx.mojom.Rect output_rect);
};
// Interface used by GPU to notify clients when the overlay promotion hint state
// has changed.
[EnableIf=is_win]
interface OverlayStateObserver {
// Called when the texture associated with the specified mailbox has had a
// change in promotion state. If promoted is true then the texture is
// currently using a DC Layer Overlay. If promoted is false then the texture
// is not using a DC Layer Overlay.
OnStateChanged(bool promoted);
};
// DeferredRequests are batched locally by clients and sent to the service only
// when flushing the channel via GpuChannelHost's EnsureFlush or VerifyFlush.
struct DeferredRequest {
// Parameters for the specific type of request.
DeferredRequestParams params;
// A list of SyncTokens which must be released before the request can be
// processed.
array<SyncToken> sync_token_fences;
// The sync point release count that is expected to be reached after execution
// of this request.
// 0 means this request doesn't release.
uint64 release_count;
};
// Details of a batched request.
union DeferredRequestParams {
// This request targets a specific command buffer instance.
DeferredCommandBufferRequest command_buffer_request;
// This request pertains to shared image management.
DeferredSharedImageRequest shared_image_request;
// Sent to indicate the client wants to destroy the StreamTexture identified
// by this ID.
[EnableIf=is_android]
int32 destroy_stream_texture;
// Sent to indicate the client wants to destroy the DCOMPTexture identified
// by this ID.
[EnableIf=is_win]
int32 destroy_dcomp_texture;
};
// Details of a batched request targeting a specific command buffer.
struct DeferredCommandBufferRequest {
// Identifies the command buffer targeted by this request.
int32 routing_id;
// The specific request parameters.
DeferredCommandBufferRequestParams params;
};
// Details of a batched request targeting a specific command buffer.
union DeferredCommandBufferRequestParams {
// See AsyncFlushParams.
AsyncFlushParams async_flush;
// Destroys a transfer buffer identified by this ID.
int32 destroy_transfer_buffer;
// Allows to attach SharedImage to default framebuffer of this context.
// NOTE: Used only for PNaCL.
SetDefaultFramebufferSharedImageParams set_default_framebuffer_shared_image;
};
// Details of a batched request pertaining to shared image management.
union DeferredSharedImageRequest {
// Sent by clients to record a point in the sequence of pending deferred
// messages. Actual value is ignored.
uint8 nop;
// See CreateSharedImageParams.
CreateSharedImageParams create_shared_image;
// See CreateSharedImageWithDataParams.
CreateSharedImageWithDataParams create_shared_image_with_data;
// See CreateSharedImageWithBufferParams.
CreateSharedImageWithBufferParams create_shared_image_with_buffer;
// Registers a new shared memory region to share with the GPU process for
// uploading shared image data.
mojo_base.mojom.ReadOnlySharedMemoryRegion register_upload_buffer;
// See UpdateSharedImageParams.
UpdateSharedImageParams update_shared_image;
// See CopyToGpuMemoryBufferParams.
CopyToGpuMemoryBufferParams copy_to_gpu_memory_buffer;
// Destroys the shared image identified by this Mailbox.
Mailbox destroy_shared_image;
AddReferenceToSharedImageParams add_reference_to_shared_image;
// See CreateSwapChainParams.
[EnableIf=is_win]
CreateSwapChainParams create_swap_chain;
// See PresentSwapChainParams.
[EnableIf=is_win]
PresentSwapChainParams present_swap_chain;
// See RegisterDxgiFenceParams.
[EnableIf=is_win]
RegisterDxgiFenceParams register_dxgi_fence;
// See UpdateDxgiFenceParams.
[EnableIf=is_win]
UpdateDxgiFenceParams update_dxgi_fence;
// See UnregisterDxgiFenceParams.
[EnableIf=is_win]
UnregisterDxgiFenceParams unregister_dxgi_fence;
};
// Asynchronously synchronize the put and get offsets of both processes.
// Caller passes its current put offset. Current state (including get offset)
// is returned in shared memory.
// TODO(sunnyps): This is an internal implementation detail of the gpu service
// and is not sent by the client. Remove this once the non-scheduler code path
// is removed.
struct AsyncFlushParams {
int32 put_offset;
uint32 flush_id;
array<SyncToken> sync_token_fences;
};
// Sets SharedImage mailbox and other framebuffer params to the default
// framebuffer. NOTE: This exists only to support PNaCl.
struct SetDefaultFramebufferSharedImageParams {
// The mailbox of the shared image. Can be empty if client wants to detach
// SharedImage from the color buffer.
Mailbox mailbox;
// Number of samples for the multisampling.
uint32 samples_count;
// If default framebuffer needs to presevre contents across the frames.
bool preserve;
// If this framebuffer needs depth buffer.
bool needs_depth;
// If this framebuffer needs stencil buffer.
bool needs_stencil;
};
// Common params used when creating a new shared image.
struct SharedImageInfo {
// Metadata about the shared image being created.
SharedImageMetadata meta;
// Retained for heap dumps and passed to graphics APIs for tracing tools.
// Pick a name that is unique to the allocation site.
string debug_label;
};
// Creates a new shared image.
struct CreateSharedImageParams {
// The mailbox used to identify the shared image.
Mailbox mailbox;
// Information about the shared image.
SharedImageInfo si_info;
};
// Creates a new shared image and populates it with pixel data from a shared
// memory region previously configured by the client.
struct CreateSharedImageWithDataParams {
// The mailbox used to identify the shared image.
Mailbox mailbox;
// Information about the shared image.
SharedImageInfo si_info;
// Offset from which to copy data out of the current image upload shared
// memory region.
uint32 pixel_data_offset;
// Size of data to copy out of the current image upload shared memory region.
uint32 pixel_data_size;
// If `true`, this is the last usage of the current image upload shared memory
// region, so the region can be discarded after servicing this request.
bool done_with_shm;
};
// Creates a new shared image with an existing GPU memory buffer.
// If format is multi-planar then `buffer_handle` contains all the planes.
struct CreateSharedImageWithBufferParams {
// The mailbox used to identify the shared image.
Mailbox mailbox;
// Information about the shared image.
SharedImageInfo si_info;
// A handle to the existing GPU memory buffer.
gfx.mojom.GpuMemoryBufferHandle buffer_handle;
};
// Updates the contents of a shared image from whatever is backing it, if
// applicable.
struct UpdateSharedImageParams {
// The mailbox identifying the shared image to update.
Mailbox mailbox;
// An optional GpuFenceHandle for the server to wait on before updating the
// image from whatever backs it.
gfx.mojom.GpuFenceHandle? in_fence_handle;
};
// Adds reference to the shared image that was created on a different
// GpuChannel. This allows SharedImage that is shared across processes to
// outlive original client.
struct AddReferenceToSharedImageParams {
// The mailbox identifying the shared image to add ref.
Mailbox mailbox;
};
// Updates the contents of the GpuMemoryBuffer associated with the shared image.
// Necessary on platforms like Windows and Linux where renderer cannot create
// native GMBs. The command performs synchronization with the GPU so the copy is
// complete after the command runs.
struct CopyToGpuMemoryBufferParams {
// The mailbox identifying the shared image which should update its GMB.
Mailbox mailbox;
};
[EnableIf=is_win]
struct CreateSwapChainParams {
// Mailbox identifying the front buffer of the swap chain.
Mailbox front_buffer_mailbox;
// Mailbox identifying the back buffer of the swap chain.
Mailbox back_buffer_mailbox;
// Pixel format of the front and back buffers.
viz.mojom.SharedImageFormat format;
// Size of the buffers.
gfx.mojom.Size size;
// Color space of the buffers.
gfx.mojom.ColorSpace color_space;
// Usage flags corresponding to values defined in
// gpu/command_buffer/common/shared_image_usage.h.
uint32 usage;
// Which corner is considered the origin of the swap chain's buffers.
skia.mojom.SurfaceOrigin surface_origin;
// Indicates how the alpha component of each pixel is interpreted.
skia.mojom.AlphaType alpha_type;
};
[EnableIf=is_win]
struct PresentSwapChainParams {
// Mailbox identifying the swap chain to present.
Mailbox mailbox;
};
[EnableIf=is_win]
struct RegisterDxgiFenceParams {
// Mailbox identifying the shared image backing to register fence.
Mailbox mailbox;
// The DXGIHandleToken to identifying the registered gpu fence handle.
// Use this token to update fence after registration.
gfx.mojom.DXGIHandleToken dxgi_token;
// The fence handle to register.
gfx.mojom.GpuFenceHandle fence_handle;
};
[EnableIf=is_win]
struct UpdateDxgiFenceParams {
// Mailbox identifying the shared image backing to update the fence.
Mailbox mailbox;
// The DXGIHandleToken to identifying the fence to update.
gfx.mojom.DXGIHandleToken dxgi_token;
// The fence value to signal.
uint64 fence_value;
};
[EnableIf=is_win]
struct UnregisterDxgiFenceParams {
// Mailbox identifying the shared image backing to clear the fence.
Mailbox mailbox;
// The DXGIHandleToken to identifying the fence needs to be cleared.
gfx.mojom.DXGIHandleToken dxgi_token;
};
Codebase Browser
chromium