Teodor Tanasoaia
81ee9d2ca8
Upstream has split the id/registry ("remoting") machinery out of
wgpu-core into two new crates, `wgpu-core-remote` and
`wgpu-core-remote-types`. wgpu-core is now a direct `Arc`-based API, and
only browser-style consumers that have to mediate between an untrusted
content process and the GPU process layer the remoting crates on top.
Most of this patch is adapting Gecko to that split.
The split buys several things:
- wgpu-core gets simpler for everyone else. wgpu itself and Deno hold
`Arc`s directly and no longer pay for id indirection they never
needed.
- The remoting layer doesn't need to be multi-threaded, so the hub
sheds the locking wgpu-core's registry needed and is now a plain
`RefCell<Hub>`.
- Security hardening. The IPC types Gecko deserialized in the GPU
process used to be wgpu-core's own public types, so the untrusted
content process could name native, non-standard wgpu features
(raytracing, native-only feature bits, arbitrary descriptor fields)
that WebGPU never exposes. `wgpu-core-remote-types` defines the wire
types entirely separately, restricted to what standard WebGPU can
express, so serde deserialization rejects those values outright
instead of relying on Gecko to never construct them.
- Firefox and Servo share one implementation of the per-command
handling instead of each maintaining its own on top of wgpu-core.
- Owning the hub outside wgpu-core opens the door to a real
`device_destroy`: remove every child of the device from the hub and
leave a "lost" sentinel behind, so memory is reclaimed as soon as any
`Arc`s still held elsewhere are dropped when outstanding submissions
finish.
gfx/wgpu_bindings:
- Depend on the two new crates and run cbindgen over those instead of
`wgpu-core`/`wgpu-hal`, since the FFI-visible types are now the
purpose-built remoting types rather than wgpu-core internals.
- The command enums, serializable descriptors and `IdentityHub` were a
Gecko-local version of what `wgpu_core_remote_types` now provides,
and the per-command server dispatch is now
`Global::handle_*_command`. Both are deleted here, along with
`src/client/render_pass.rs`. Only the `ExternalTextureSource` id
space, which has no upstream equivalent, stays local.
- `device_id` is dropped from the encoder, pass and queue-write entry
points: the remote `Global` resolves an encoder's owning device
itself, so content no longer needs to be trusted to supply it.
- Resource teardown moves from `*_drop` to `*_remove` and backend
handles come from `resolve_*_id().as_hal::<B>()`, matching the new
hub ownership model.
- wgpu-core now implements spec-conformant error scopes on `Device`, so
the parallel Gecko implementation and the `ErrorBuffer` out-parameter
protocol built around it are replaced by a serializable `GPUError`
and `Global::device_{push,pop}_error_scope`. Parent-internal
operations that still need a success/failure answer wrap themselves
in a single validation error scope and return `bool`; hence the new
`wgpu_server_submit_copy_texture_to_buffer`, which fuses
create-encoder/copy/finish/submit/drop into one call and one error
scope.
- Uncaptured errors and device loss are raised by wgpu-core callbacks
now rather than synthesised in C++, so they are reported from Rust
over the existing `ServerMessage` stream. `WebGPUParentWeakPtr` wraps
a C++ `WeakPtr<WebGPUParent>` so those async tasks cannot use a
destroyed parent.
dom/webgpu:
- The dedicated `PWebGPU::UncapturedError` and `PWebGPU::DeviceLost`
messages are gone now that both travel in the `ServerMessage` stream;
the child re-enters via
`wgpu_child_handle_uncaptured_error`/`_device_lost`. With their last
consumers gone, `WebGPUSerialize.h` and `PWebGPUTypes.ipdlh` are
deleted, and `WebGPUParent` sheds the error-scope and device-lost
machinery that duplicated state that's aleardy in wgpu-core.
- Zero-sized buffer mappings are allowed, which makes mapped state
awkward to infer from the mapped range, so `BufferMapData` tracks it
directly in `mIsMapped`.
- `SwapChainPresent` now returns the staging buffer id to the available
pool via a scope guard on every error path, matching what the other
readback path already did.
- External texture import no longer raises `GPUInternalError` for
failures such as a missing VideoBridge, an unsupported surface format
or a failed fence wait. Per spec `GPUInternalError` is only ever
generated by pipeline creation, so these were incorrect; they now log
via `gfxCriticalError`/`NoteOnce`. The usability check in
`ImportExternalTexture` still raises a validation error, as the spec
requires.
- Mechanical fallout from the type move: descriptors picked up an `Ffi`
prefix, `device_id` is gone from the client-side encoder calls, and
cbindgen no longer emits `_Sentinel` enum variants so the matching
switch cases and assertions are dropped.
Differential Revision: https://phabricator.services.mozilla.com/D322889
92 lines
3.0 KiB
C++
92 lines
3.0 KiB
C++
/* 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/. */
|
|
|
|
#ifndef GPU_UTIL_H_
|
|
#define GPU_UTIL_H_
|
|
|
|
#include "mozilla/dom/TypedArray.h"
|
|
#include "mozilla/dom/WebGPUBinding.h"
|
|
#include "mozilla/webgpu/WebGPUTypes.h"
|
|
#include "mozilla/webgpu/ffi/wgpu.h"
|
|
#include "nsTArray.h"
|
|
|
|
namespace mozilla {
|
|
class ErrorResult;
|
|
|
|
namespace dom {
|
|
struct GPUComputePassDescriptor;
|
|
enum class PredefinedColorSpace : uint8_t;
|
|
template <typename T>
|
|
class Sequence;
|
|
using GPUExtent3D = RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
|
|
using OwningGPUExtent3D =
|
|
OwningRangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
|
|
} // namespace dom
|
|
namespace webgpu {
|
|
|
|
void ConvertExtent3DToFFI(const dom::GPUExtent3D& aExtent,
|
|
ffi::WGPUExtent3d* aExtentFFI);
|
|
|
|
void ConvertExtent3DToFFI(const dom::OwningGPUExtent3D& aExtent,
|
|
ffi::WGPUExtent3d* aExtentFFI);
|
|
|
|
ffi::WGPUExtent3d ConvertExtent(const dom::GPUExtent3D& aExtent);
|
|
|
|
ffi::WGPUExtent3d ConvertExtent(const dom::OwningGPUExtent3D& aExtent);
|
|
|
|
ffi::WGPUCompareFunction ConvertCompareFunction(
|
|
const dom::GPUCompareFunction& aCompare);
|
|
|
|
ffi::WGPUTextureFormat ConvertTextureFormat(
|
|
const dom::GPUTextureFormat& aFormat);
|
|
|
|
ffi::WGPUTextureAspect ConvertTextureAspect(
|
|
const dom::GPUTextureAspect& aAspect);
|
|
|
|
// Converts a `dom::GPUTextureDescriptor` into a
|
|
// `ffi::WGPUFfiTextureDescriptor`, owning the necessary temporary storage. The
|
|
// converted descriptor returned by `Get` is only valid for the lifetime of this
|
|
// object.
|
|
class MOZ_STACK_CLASS ConvertTextureDescriptor final {
|
|
public:
|
|
explicit ConvertTextureDescriptor(const dom::GPUTextureDescriptor& aDesc);
|
|
|
|
ConvertTextureDescriptor(const ConvertTextureDescriptor&) = delete;
|
|
ConvertTextureDescriptor& operator=(const ConvertTextureDescriptor&) = delete;
|
|
|
|
const ffi::WGPUFfiTextureDescriptor* Get() const { return &mDesc; }
|
|
|
|
private:
|
|
StringHelper mLabel;
|
|
AutoTArray<ffi::WGPUTextureFormat, 8> mViewFormats;
|
|
ffi::WGPUFfiTextureDescriptor mDesc = {};
|
|
};
|
|
|
|
ffi::WGPUVertexFormat ConvertVertexFormat(const dom::GPUVertexFormat& aFormat);
|
|
|
|
ffi::WGPUMultisampleState ConvertMultisampleState(
|
|
const dom::GPUMultisampleState& aDesc);
|
|
|
|
ffi::WGPUBlendComponent ConvertBlendComponent(
|
|
const dom::GPUBlendComponent& aDesc);
|
|
|
|
ffi::WGPUStencilFaceState ConvertStencilFaceState(
|
|
const dom::GPUStencilFaceState& aDesc);
|
|
|
|
ffi::WGPUDepthStencilState ConvertDepthStencilState(
|
|
const dom::GPUDepthStencilState& aDesc);
|
|
|
|
ffi::WGPUPredefinedColorSpace ConvertPredefinedColorSpace(
|
|
const dom::PredefinedColorSpace& aColorSpace);
|
|
|
|
mozilla::Maybe<mozilla::Buffer<uint32_t>> GetDynamicOffsetsFromArray(
|
|
const dom::Uint32Array& aDynamicOffsetsData,
|
|
uint64_t aDynamicOffsetsDataStart, uint64_t aDynamicOffsetsDataLength,
|
|
ErrorResult& aRv);
|
|
|
|
} // namespace webgpu
|
|
} // namespace mozilla
|
|
|
|
#endif // GPU_UTIL_H_
|