1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 WEBGPU_CHILD_H_
#define WEBGPU_CHILD_H_
#include "mozilla/webgpu/PWebGPUChild.h"
#include "mozilla/MozPromise.h"
#include "mozilla/WeakPtr.h"
#include "mozilla/webgpu/ffi/wgpu.h"
namespace mozilla {
namespace ipc {
class UnsafeSharedMemoryHandle;
} // namespace ipc
namespace dom {
struct GPURequestAdapterOptions;
} // namespace dom
namespace layers {
class CompositorBridgeChild;
} // namespace layers
namespace webgpu {
namespace ffi {
struct WGPUClient;
struct WGPULimits;
struct WGPUTextureViewDescriptor;
} // namespace ffi
using AdapterPromise =
MozPromise<ipc::ByteBuf, Maybe<ipc::ResponseRejectReason>, true>;
using PipelinePromise = MozPromise<RawId, ipc::ResponseRejectReason, true>;
using DevicePromise = MozPromise<bool, ipc::ResponseRejectReason, true>;
struct PipelineCreationContext {
RawId mParentId = 0;
RawId mImplicitPipelineLayoutId = 0;
nsTArray<RawId> mImplicitBindGroupLayoutIds;
};
struct DeviceRequest {
RawId mId = 0;
RefPtr<DevicePromise> mPromise;
// Note: we could put `ffi::WGPULimits` in here as well,
// but we don't want to #include ffi stuff in this header
};
ffi::WGPUByteBuf* ToFFI(ipc::ByteBuf* x);
class WebGPUChild final : public PWebGPUChild, public SupportsWeakPtr {
public:
friend class layers::CompositorBridgeChild;
NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(WebGPUChild)
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING_INHERITED(WebGPUChild)
public:
explicit WebGPUChild();
bool IsOpen() const { return CanSend(); }
RefPtr<AdapterPromise> InstanceRequestAdapter(
const dom::GPURequestAdapterOptions& aOptions);
Maybe<DeviceRequest> AdapterRequestDevice(RawId aSelfId,
const ffi::WGPUDeviceDescriptor&);
RawId RenderBundleEncoderFinish(ffi::WGPURenderBundleEncoder& aEncoder,
RawId aDeviceId,
const dom::GPURenderBundleDescriptor& aDesc);
RawId RenderBundleEncoderFinishError(RawId aDeviceId, const nsString& aLabel);
ffi::WGPUClient* GetClient() const { return mClient.get(); }
void DeviceCreateSwapChain(RawId aSelfId, const RGBDescriptor& aRgbDesc,
size_t maxBufferCount,
const layers::RemoteTextureOwnerId& aOwnerId,
bool aUseExternalTextureInSwapChain);
void QueueOnSubmittedWorkDone(const RawId aSelfId,
const RefPtr<dom::Promise>& aPromise);
void SwapChainPresent(RawId aTextureId,
const RemoteTextureId& aRemoteTextureId,
const RemoteTextureOwnerId& aOwnerId);
void RegisterDevice(Device* const aDevice);
void UnregisterDevice(RawId aId);
void FreeUnregisteredInParentDevice(RawId aId);
void QueueSubmit(RawId aSelfId, RawId aDeviceId,
nsTArray<RawId>& aCommandBuffers);
void NotifyWaitForSubmit(RawId aTextureId);
static void JsWarning(nsIGlobalObject* aGlobal, const nsACString& aMessage);
private:
virtual ~WebGPUChild();
UniquePtr<ffi::WGPUClient> const mClient;
std::unordered_map<RawId, WeakPtr<Device>> mDeviceMap;
nsTArray<RawId> mSwapChainTexturesWaitingForSubmit;
public:
ipc::IPCResult RecvUncapturedError(Maybe<RawId> aDeviceId,
const nsACString& aMessage);
ipc::IPCResult RecvDropAction(const ipc::ByteBuf& aByteBuf);
ipc::IPCResult RecvDeviceLost(RawId aDeviceId, Maybe<uint8_t> aReason,
const nsACString& aMessage);
void ActorDestroy(ActorDestroyReason) override;
};
} // namespace webgpu
} // namespace mozilla
#endif // WEBGPU_CHILD_H_
|
