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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
content / test / data / gpu / webgpu-iframe-removed.html [blame]
<!--
Iframes can be tricky because even after they're removed from the page,
script can continue to run.
So, WebGPU cannot assume that WebGPU resources can be immediately
destroyed with the page.
This test tests a cases one after another by inserting an iframe into the page
with the test case script and waiting for the test to call
|removeIframe| which should remove itself from the DOM. After removal, we wait a bit
and then continue on to the next case.
-->
<html>
<head>
<script>
// |runTestCase| creates an iframe containing the stringified script source of |testFn|.
// It returns a Promise and saves the |resolve| function as |iframeRemovedCallback|.
// This callback is called in removeIframe, so when the Promise resolves, we know
// the iframe containing the test case page has been removed.
let iframeRemovedCallback;
function runTestCase(testFn) {
return new Promise(resolve => {
iframeRemovedCallback = resolve;
let iframe = document.createElement("iframe");
iframe.setAttribute("id", "iframe");
document.body.appendChild(iframe);
const head = iframe.contentWindow.document.getElementsByTagName('head')[0];
const script = iframe.contentWindow.document.createElement('script');
script.innerText = `(${testFn.toString()})().catch(parent.fail);`;
script.type = 'text/javascript';
head.appendChild(script);
});
}
// Called by the inner iframe to remove itself.
function removeIframe() {
const iframe = document.getElementById('iframe');
iframe.parentNode.removeChild(iframe);
// Wait a bit before signaling that the test case is finished.
setTimeout(iframeRemovedCallback, 100);
}
function fail(err) {
if (window.domAutomationController) {
console.log(err);
} else {
alert(err);
}
window.domAutomationController.send('FAILED');
}
async function runTests() {
// Test running basic WebGPU commands after the iframe is removed.
await runTestCase(async () => {
let device;
try {
const adapter = await navigator.gpu.requestAdapter();
device = await adapter.requestDevice();
} catch {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
parent.removeIframe();
device.queue.submit([device.createCommandEncoder().finish()]);
});
// Test getting a swapchain texture after the iframe is removed.
// This may interact with the shared image interfaces.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const canvas = document.createElement('canvas');
const context = canvas.getContext('webgpu');
context.configure({
device,
format: 'bgra8unorm'
});
parent.removeIframe();
const texture = context.getCurrentTexture();
});
// Test reconfiguring the swapchain after the iframe is removed.
// This may interact with the shared image interfaces.
// The expecation is that reconfiguring after removal does not crash, but
// does throw an exception. It is invalid to call |configure| after
// the canvas is destroyed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const canvas = document.createElement('canvas');
const context = canvas.getContext('webgpu');
context.configure({
device,
format: 'bgra8unorm'
});
const texture = context.getCurrentTexture();
parent.removeIframe();
try {
/* Throws an exception since the canvas is destroyed */
context.configure({
device,
format: 'bgra8unorm'
});
} catch (err) {
}
});
// Test creating a device asynchronously, but removing the iframe before
// the response is received.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
adapter.requestDevice();
/* Wait till the next task so we're sure the command flushed */
setTimeout(() => {
parent.removeIframe();
}, 0);
});
// Test sending an async command and then removing the iframe
// before the response is received.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
device.queue.onSubmittedWorkDone();
/* Wait till the next microtask so we're sure the command flushed */
setTimeout(() => {
parent.removeIframe();
}, 0);
});
// Test creating a mappable buffer and then removing the iframe.
// Mappable buffers are tracked because mappings need to be detached
// when the context is destroyed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const buffer = device.createBuffer({
size: 4,
usage: GPUBufferUsage.MAP_READ,
});
parent.removeIframe();
});
// Test creating a mappable buffer and then in the next task, removing the
// iframe while the mapping is in flight.
// Mappable buffers are tracked because mappings need to be detached
// when the context is destroyed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const buffer = device.createBuffer({
size: 4,
usage: GPUBufferUsage.MAP_READ,
});
buffer.mapAsync(GPUMapMode.READ);
/* Wait till the next microtask so we're sure the command flushed */
setTimeout(() => {
parent.removeIframe();
}, 0);
});
// Test creating a mappable buffer and then in the same task, removing the
// iframe while the mapping is in flight.
// Mappable buffers are tracked because mappings need to be detached
// when the context is destroyed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const buffer = device.createBuffer({
size: 4,
usage: GPUBufferUsage.MAP_READ,
});
buffer.mapAsync(GPUMapMode.READ);
/* Empty submit to force a flush */
device.queue.submit([]);
parent.removeIframe();
});
// Test removing the iframe while the buffer is mapped.
// Mappable buffers are tracked because mappings need to be detached
// when the context is destroyed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
const buffer = device.createBuffer({
size: 4,
usage: GPUBufferUsage.MAP_WRITE,
});
const mapping = await buffer.mapAsync(GPUMapMode.WRITE);
parent.removeIframe();
if (mapping !== undefined && mapping.byteLength != 0) {
fail('GPUBuffer mapping should be detached')
}
});
// Test creating and mapping a buffer after the iframe is removed.
await runTestCase(async () => {
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
if (!adapter) {
console.warn('WebGPU not supported');
parent.removeIframe();
return;
}
const device = await adapter.requestDevice();
/* Get these constants now. The receiver interface may become
undefined after the iframe is removed */
const USAGE_MAP_WRITE = GPUBufferUsage.MAP_WRITE;
const MODE_WRITE = GPUMapMode.WRITE;
parent.removeIframe();
const buffer = device.createBuffer({
size: 4,
usage: USAGE_MAP_WRITE,
});
const mapping = await buffer.mapAsync(MODE_WRITE);
if (mapping !== undefined && mapping.byteLength != 0) {
fail('GPUBuffer mapping should be detached')
}
});
window.domAutomationController.send('SUCCESS');
}
</script>
</head>
<body onload="runTests()"></body>
</html>