PWebGPU.ipdl - mozsearch

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * vim: sw=2 ts=8 et :

*/

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

using mozilla::layers::RGBDescriptor from "mozilla/layers/LayersSurfaces.h";

using mozilla::layers::RemoteTextureId from "mozilla/layers/LayersTypes.h";

using mozilla::layers::RemoteTextureOwnerId from "mozilla/layers/LayersTypes.h";

using mozilla::layers::RemoteTextureTxnType from "mozilla/layers/LayersTypes.h";

using mozilla::layers::RemoteTextureTxnId from "mozilla/layers/LayersTypes.h";

using mozilla::webgpu::RawId from "mozilla/webgpu/WebGPUTypes.h";

using mozilla::dom::GPUErrorFilter from "mozilla/dom/WebGPUBinding.h";

using mozilla::dom::GPURequestAdapterOptions from "mozilla/dom/WebGPUBinding.h";

using mozilla::dom::GPUCommandBufferDescriptor from "mozilla/dom/WebGPUBinding.h";

using mozilla::dom::GPUBufferDescriptor from "mozilla/dom/WebGPUBinding.h";

using mozilla::webgpu::PopErrorScopeResult from "mozilla/webgpu/WebGPUTypes.h";

using mozilla::webgpu::WebGPUCompilationMessage from "mozilla/webgpu/WebGPUTypes.h";

[MoveOnly] using class mozilla::ipc::UnsafeSharedMemoryHandle from "mozilla/ipc/RawShmem.h";

using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";

include "mozilla/ipc/ByteBufUtils.h";

include "mozilla/layers/LayersMessageUtils.h";

include "mozilla/webgpu/WebGPUSerialize.h";

include "mozilla/layers/WebRenderMessageUtils.h";

include protocol PCanvasManager;

include PWebGPUTypes;

namespace mozilla {

namespace webgpu {

/**

 * Represents the connection between a WebGPUChild actor that issues WebGPU

 * command from the content process, and a WebGPUParent in the compositor

 * process that runs the commands.

*/

async protocol PWebGPU

  manager PCanvasManager;

parent:

  async DeviceAction(RawId selfId, ByteBuf buf);

  async DeviceActionWithAck(RawId selfId, ByteBuf buf) returns (bool dummy);

  async TextureAction(RawId selfId, RawId aDeviceId, ByteBuf buf);

  async CommandEncoderAction(RawId selfId, RawId aDeviceId, ByteBuf buf);

  async RenderPass(RawId selfId, RawId aDeviceId, ByteBuf buf);

  async ComputePass(RawId selfId, RawId aDeviceId, ByteBuf buf);

  async BumpImplicitBindGroupLayout(RawId pipelineId, bool isCompute, uint32_t index, RawId assignId);

  async DeviceCreateBuffer(RawId deviceId, RawId bufferId, GPUBufferDescriptor desc, UnsafeSharedMemoryHandle shm);

  async InstanceRequestAdapter(GPURequestAdapterOptions options, RawId aAdapterId) returns (ByteBuf byteBuf);

  async AdapterRequestDevice(

      RawId adapterId,

      ByteBuf descriptorBuf,

      RawId newDeviceId,

      RawId newQueueId

  ) returns (bool success);

  async AdapterDrop(RawId selfId);

  // TODO: We want to return an array of compilation messages.

  async DeviceCreateShaderModule(RawId selfId, RawId bufferId, nsString label, nsCString code) returns (WebGPUCompilationMessage[] messages);

  async BufferMap(RawId deviceId, RawId bufferId, uint32_t aMode, uint64_t offset, uint64_t size) returns (BufferMapResult result);

  async BufferUnmap(RawId deviceId, RawId bufferId, bool flush);

  async BufferDestroy(RawId selfId);

  async BufferDrop(RawId selfId);

  async TextureDestroy(RawId selfId, RawId deviceId);

  async TextureDrop(RawId selfId);

  async TextureViewDrop(RawId selfId);

  async SamplerDrop(RawId selfId);

  async QuerySetDrop(RawId selfId);

  async DeviceDestroy(RawId selfId);

  async DeviceDrop(RawId selfId);

  async CommandEncoderFinish(RawId selfId, RawId deviceId, GPUCommandBufferDescriptor desc);

  async CommandEncoderDrop(RawId selfId);

  async RenderBundleDrop(RawId selfId);

  async QueueSubmit(RawId selfId, RawId aDeviceId, RawId[] commandBuffers, RawId[] textureIds);

  async QueueOnSubmittedWorkDone(RawId selfId) returns (void_t ok);

  async QueueWriteAction(RawId selfId, RawId aDeviceId, ByteBuf buf, UnsafeSharedMemoryHandle shmem);

  async BindGroupLayoutDrop(RawId selfId);

  async PipelineLayoutDrop(RawId selfId);

  async BindGroupDrop(RawId selfId);

  async ShaderModuleDrop(RawId selfId);

  async ComputePipelineDrop(RawId selfId);

  async RenderPipelineDrop(RawId selfId);

  async ImplicitLayoutDrop(RawId implicitPlId, RawId[] implicitBglIds);

  async DeviceCreateSwapChain(RawId selfId, RawId queueId, RGBDescriptor desc, RawId[] bufferIds, RemoteTextureOwnerId ownerId, bool useExternalTextureInSwapChain);

  async SwapChainPresent(RawId textureId, RawId commandEncoderId, RemoteTextureId remoteTextureId, RemoteTextureOwnerId remoteTextureOwnerId);

  async SwapChainDrop(RemoteTextureOwnerId ownerId, RemoteTextureTxnType txnType, RemoteTextureTxnId txnId);

  async DevicePushErrorScope(RawId selfId, GPUErrorFilter aFilter);

  async DevicePopErrorScope(RawId selfId) returns (PopErrorScopeResult result);

  // Generate an error on the Device timeline for `deviceId`.

  // The `message` parameter is interpreted as UTF-8.

  async GenerateError(RawId? deviceId, GPUErrorFilter type, nsCString message);

child:

  async UncapturedError(RawId? aDeviceId, nsCString message);

  async DropAction(ByteBuf buf);

  async DeviceLost(RawId aDeviceId, uint8_t? reason, nsCString message);

  async __delete__();

};

} // webgpu

} // mozilla

Source code

Revision control

Copy as Markdown

Other Tools