REGRESSION: ( r246394 ) webgpu/whlsl-buffer-fragment.html and webgpu/whlsl-buffer...
authormmaxfield@apple.com <mmaxfield@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 26 Jun 2019 19:35:26 +0000 (19:35 +0000)
committermmaxfield@apple.com <mmaxfield@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 26 Jun 2019 19:35:26 +0000 (19:35 +0000)
https://bugs.webkit.org/show_bug.cgi?id=199012

Reviewed by Saam Barati.

Source/WebCore:

* platform/graphics/gpu/cocoa/GPUDeviceMetal.mm:
(WebCore::isAcceptableDevice):
(WebCore::GPUDevice::tryCreate):

Source/WTF:

* wtf/Platform.h:

LayoutTests:

Make the tests still pass if the machine doesn't support WebGPU.

* webgpu/adapter-options-expected.txt: Removed.
* webgpu/adapter-options.html: Removed.
* webgpu/bind-groups.html:
* webgpu/blend-color-triangle-strip-expected.html:
* webgpu/blend-color-triangle-strip.html:
* webgpu/blend-triangle-strip-expected.html:
* webgpu/blend-triangle-strip.html:
* webgpu/blit-commands-expected.html:
* webgpu/blit-commands.html:
* webgpu/buffer-command-buffer-races-expected.html:
* webgpu/buffer-command-buffer-races.html:
* webgpu/color-write-mask-triangle-strip-expected.html:
* webgpu/color-write-mask-triangle-strip.html:
* webgpu/command-buffers.html:
* webgpu/depth-enabled-triangle-strip-expected.html:
* webgpu/depth-enabled-triangle-strip.html:
* webgpu/draw-indexed-triangles-expected.html:
* webgpu/draw-indexed-triangles.html:
* webgpu/js/create-worker-device.js: Removed.
* webgpu/js/webgpu-functions.js:
(drawWhiteSquareOnBlueBackgroundInSoftware):
(drawGreenSquareInSoftware):
(drawGreenAndBlueCheckerboardInSoftware):
(async.mapWriteDataToBuffer):
* webgpu/map-read-buffers.html:
* webgpu/map-write-buffers.html:
* webgpu/pipeline-layouts.html:
* webgpu/propertyresolver/ander-abstract-lvalue-expected.html:
* webgpu/propertyresolver/ander-abstract-lvalue.html:
* webgpu/propertyresolver/ander-expected.html:
* webgpu/propertyresolver/ander-lvalue-3-levels-expected.html:
* webgpu/propertyresolver/ander-lvalue-3-levels.html:
* webgpu/propertyresolver/ander-lvalue-expected.html:
* webgpu/propertyresolver/ander-lvalue.html:
* webgpu/propertyresolver/ander.html:
* webgpu/propertyresolver/getter-expected.html:
* webgpu/propertyresolver/getter.html:
* webgpu/propertyresolver/indexer-ander-abstract-lvalue-expected.html:
* webgpu/propertyresolver/indexer-ander-abstract-lvalue.html:
* webgpu/propertyresolver/indexer-ander-expected.html:
* webgpu/propertyresolver/indexer-ander-lvalue-3-levels-expected.html:
* webgpu/propertyresolver/indexer-ander-lvalue-3-levels.html:
* webgpu/propertyresolver/indexer-ander-lvalue-expected.html:
* webgpu/propertyresolver/indexer-ander-lvalue.html:
* webgpu/propertyresolver/indexer-ander.html:
* webgpu/propertyresolver/indexer-getter-expected.html:
* webgpu/propertyresolver/indexer-getter.html:
* webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels-expected.html:
* webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels.html:
* webgpu/propertyresolver/indexer-setter-abstract-lvalue-expected.html:
* webgpu/propertyresolver/indexer-setter-abstract-lvalue.html:
* webgpu/propertyresolver/indexer-setter-expected.html:
* webgpu/propertyresolver/indexer-setter-lvalue-expected.html:
* webgpu/propertyresolver/indexer-setter-lvalue.html:
* webgpu/propertyresolver/indexer-setter.html:
* webgpu/propertyresolver/setter-abstract-lvalue-3-levels-expected.html:
* webgpu/propertyresolver/setter-abstract-lvalue-3-levels.html:
* webgpu/propertyresolver/setter-abstract-lvalue-expected.html:
* webgpu/propertyresolver/setter-abstract-lvalue.html:
* webgpu/propertyresolver/setter-lvalue-expected.html:
* webgpu/propertyresolver/setter-lvalue.html:
* webgpu/queue-creation.html:
* webgpu/render-command-encoding.html:
* webgpu/render-pipelines.html:
* webgpu/shader-modules.html:
* webgpu/simple-triangle-strip-expected.html:
* webgpu/simple-triangle-strip.html:
* webgpu/texture-triangle-strip-expected.html:
* webgpu/texture-triangle-strip.html:
* webgpu/textures-textureviews.html:
* webgpu/vertex-buffer-triangle-strip-expected.html:
* webgpu/vertex-buffer-triangle-strip.html:
* webgpu/viewport-scissor-rect-triangle-strip-expected.html:
* webgpu/viewport-scissor-rect-triangle-strip.html:
* webgpu/webgpu-enabled-expected.txt: Removed.
* webgpu/webgpu-enabled-in-worker-expected.txt: Removed.
* webgpu/webgpu-enabled-in-worker.html: Removed.
* webgpu/webgpu-enabled.html: Removed.
* webgpu/whlsl-arbitrary-vertex-attribute-locations-expected.html:
* webgpu/whlsl-arbitrary-vertex-attribute-locations.html:
* webgpu/whlsl-buffer-fragment-expected.html:
* webgpu/whlsl-buffer-fragment.html:
* webgpu/whlsl-buffer-length-expected.txt:
* webgpu/whlsl-buffer-length.html:
* webgpu/whlsl-buffer-vertex-expected.html:
* webgpu/whlsl-buffer-vertex.html:
* webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables-expected.txt:
* webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables.html:
* webgpu/whlsl-compute-expected.txt:
* webgpu/whlsl-compute.html:
* webgpu/whlsl-dereference-pointer-should-type-check-expected.html:
* webgpu/whlsl-dereference-pointer-should-type-check.html:
* webgpu/whlsl-do-while-loop-break-expected.html:
* webgpu/whlsl-do-while-loop-break.html:
* webgpu/whlsl-do-while-loop-continue-expected.html:
* webgpu/whlsl-do-while-loop-continue.html:
* webgpu/whlsl-do-while-loop-expected.html:
* webgpu/whlsl-do-while-loop.html:
* webgpu/whlsl-dont-crash-parsing-enum-expected.html:
* webgpu/whlsl-dont-crash-parsing-enum.html:
* webgpu/whlsl-dot-expressions-expected.html:
* webgpu/whlsl-dot-expressions.html:
* webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors-expected.txt:
* webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors.html:
* webgpu/whlsl-ensure-proper-variable-lifetime-2-expected.html:
* webgpu/whlsl-ensure-proper-variable-lifetime-2.html:
* webgpu/whlsl-ensure-proper-variable-lifetime-3-expected.html:
* webgpu/whlsl-ensure-proper-variable-lifetime-3.html:
* webgpu/whlsl-ensure-proper-variable-lifetime-expected.html:
* webgpu/whlsl-ensure-proper-variable-lifetime.html:
* webgpu/whlsl-expected.html:
* webgpu/whlsl-loops-break-expected.html:
* webgpu/whlsl-loops-break.html:
* webgpu/whlsl-loops-continue-expected.html:
* webgpu/whlsl-loops-continue.html:
* webgpu/whlsl-loops-expected.html:
* webgpu/whlsl-loops.html:
* webgpu/whlsl-matrix-2-expected.txt:
* webgpu/whlsl-matrix-2.html:
* webgpu/whlsl-matrix-expected.txt:
* webgpu/whlsl-matrix.html:
* webgpu/whlsl-nested-dot-expression-rvalue-expected.html:
* webgpu/whlsl-nested-dot-expression-rvalue.html:
* webgpu/whlsl-nested-loop-expected.html:
* webgpu/whlsl-nested-loop.html:
* webgpu/whlsl-null-dereference-expected.txt:
* webgpu/whlsl-null-dereference.html:
* webgpu/whlsl-oob-access-expected.txt:
* webgpu/whlsl-oob-access.html:
* webgpu/whlsl-read-modify-write-high-zombies-expected.txt:
* webgpu/whlsl-read-modify-write-high-zombies.html:
* webgpu/whlsl-return-local-variable-expected.html:
* webgpu/whlsl-return-local-variable.html:
* webgpu/whlsl-store-to-property-updates-properly-expected.html:
* webgpu/whlsl-store-to-property-updates-properly.html:
* webgpu/whlsl-textures-getdimensions-expected.txt:
* webgpu/whlsl-textures-getdimensions.html:
* webgpu/whlsl-textures-load-expected.html:
* webgpu/whlsl-textures-load.html:
* webgpu/whlsl-textures-sample-expected.html:
* webgpu/whlsl-textures-sample.html:
* webgpu/whlsl-while-loop-break-expected.html:
* webgpu/whlsl-while-loop-break.html:
* webgpu/whlsl-while-loop-continue-expected.html:
* webgpu/whlsl-while-loop-continue.html:
* webgpu/whlsl-zero-initialize-values-2-expected.html:
* webgpu/whlsl-zero-initialize-values-2.html:
* webgpu/whlsl-zero-initialize-values-expected.html:
* webgpu/whlsl-zero-initialize-values.html:
* webgpu/whlsl.html:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@246846 268f45cc-cd09-0410-ab3c-d52691b4dbfc

159 files changed:
LayoutTests/ChangeLog
LayoutTests/webgpu/adapter-options-expected.txt [deleted file]
LayoutTests/webgpu/adapter-options.html [deleted file]
LayoutTests/webgpu/bind-groups.html
LayoutTests/webgpu/blend-color-triangle-strip-expected.html
LayoutTests/webgpu/blend-color-triangle-strip.html
LayoutTests/webgpu/blend-triangle-strip-expected.html
LayoutTests/webgpu/blend-triangle-strip.html
LayoutTests/webgpu/blit-commands-expected.html
LayoutTests/webgpu/blit-commands.html
LayoutTests/webgpu/buffer-command-buffer-races-expected.html
LayoutTests/webgpu/buffer-command-buffer-races.html
LayoutTests/webgpu/color-write-mask-triangle-strip-expected.html
LayoutTests/webgpu/color-write-mask-triangle-strip.html
LayoutTests/webgpu/command-buffers.html
LayoutTests/webgpu/depth-enabled-triangle-strip-expected.html
LayoutTests/webgpu/depth-enabled-triangle-strip.html
LayoutTests/webgpu/draw-indexed-triangles-expected.html
LayoutTests/webgpu/draw-indexed-triangles.html
LayoutTests/webgpu/js/create-worker-device.js [deleted file]
LayoutTests/webgpu/js/webgpu-functions.js
LayoutTests/webgpu/map-read-buffers.html
LayoutTests/webgpu/map-write-buffers.html
LayoutTests/webgpu/pipeline-layouts.html
LayoutTests/webgpu/propertyresolver/ander-abstract-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/ander-abstract-lvalue.html
LayoutTests/webgpu/propertyresolver/ander-expected.html
LayoutTests/webgpu/propertyresolver/ander-lvalue-3-levels-expected.html
LayoutTests/webgpu/propertyresolver/ander-lvalue-3-levels.html
LayoutTests/webgpu/propertyresolver/ander-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/ander-lvalue.html
LayoutTests/webgpu/propertyresolver/ander.html
LayoutTests/webgpu/propertyresolver/getter-expected.html
LayoutTests/webgpu/propertyresolver/getter.html
LayoutTests/webgpu/propertyresolver/indexer-ander-abstract-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/indexer-ander-abstract-lvalue.html
LayoutTests/webgpu/propertyresolver/indexer-ander-expected.html
LayoutTests/webgpu/propertyresolver/indexer-ander-lvalue-3-levels-expected.html
LayoutTests/webgpu/propertyresolver/indexer-ander-lvalue-3-levels.html
LayoutTests/webgpu/propertyresolver/indexer-ander-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/indexer-ander-lvalue.html
LayoutTests/webgpu/propertyresolver/indexer-ander.html
LayoutTests/webgpu/propertyresolver/indexer-getter-expected.html
LayoutTests/webgpu/propertyresolver/indexer-getter.html
LayoutTests/webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels-expected.html
LayoutTests/webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels.html
LayoutTests/webgpu/propertyresolver/indexer-setter-abstract-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/indexer-setter-abstract-lvalue.html
LayoutTests/webgpu/propertyresolver/indexer-setter-expected.html
LayoutTests/webgpu/propertyresolver/indexer-setter-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/indexer-setter-lvalue.html
LayoutTests/webgpu/propertyresolver/indexer-setter.html
LayoutTests/webgpu/propertyresolver/setter-abstract-lvalue-3-levels-expected.html
LayoutTests/webgpu/propertyresolver/setter-abstract-lvalue-3-levels.html
LayoutTests/webgpu/propertyresolver/setter-abstract-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/setter-abstract-lvalue.html
LayoutTests/webgpu/propertyresolver/setter-lvalue-expected.html
LayoutTests/webgpu/propertyresolver/setter-lvalue.html
LayoutTests/webgpu/queue-creation.html
LayoutTests/webgpu/render-command-encoding.html
LayoutTests/webgpu/render-pipelines.html
LayoutTests/webgpu/shader-modules.html
LayoutTests/webgpu/simple-triangle-strip-expected.html
LayoutTests/webgpu/simple-triangle-strip.html
LayoutTests/webgpu/texture-triangle-strip-expected.html
LayoutTests/webgpu/texture-triangle-strip.html
LayoutTests/webgpu/textures-textureviews.html
LayoutTests/webgpu/vertex-buffer-triangle-strip-expected.html
LayoutTests/webgpu/vertex-buffer-triangle-strip.html
LayoutTests/webgpu/viewport-scissor-rect-triangle-strip-expected.html
LayoutTests/webgpu/viewport-scissor-rect-triangle-strip.html
LayoutTests/webgpu/webgpu-enabled-expected.txt [deleted file]
LayoutTests/webgpu/webgpu-enabled-in-worker-expected.txt [deleted file]
LayoutTests/webgpu/webgpu-enabled-in-worker.html [deleted file]
LayoutTests/webgpu/webgpu-enabled.html [deleted file]
LayoutTests/webgpu/whlsl-arbitrary-vertex-attribute-locations-expected.html
LayoutTests/webgpu/whlsl-arbitrary-vertex-attribute-locations.html
LayoutTests/webgpu/whlsl-buffer-fragment-expected.html
LayoutTests/webgpu/whlsl-buffer-fragment.html
LayoutTests/webgpu/whlsl-buffer-length-expected.txt
LayoutTests/webgpu/whlsl-buffer-length.html
LayoutTests/webgpu/whlsl-buffer-vertex-expected.html
LayoutTests/webgpu/whlsl-buffer-vertex.html
LayoutTests/webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables-expected.txt
LayoutTests/webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables.html
LayoutTests/webgpu/whlsl-compute-expected.txt
LayoutTests/webgpu/whlsl-compute.html
LayoutTests/webgpu/whlsl-dereference-pointer-should-type-check-expected.html
LayoutTests/webgpu/whlsl-dereference-pointer-should-type-check.html
LayoutTests/webgpu/whlsl-do-while-loop-break-expected.html
LayoutTests/webgpu/whlsl-do-while-loop-break.html
LayoutTests/webgpu/whlsl-do-while-loop-continue-expected.html
LayoutTests/webgpu/whlsl-do-while-loop-continue.html
LayoutTests/webgpu/whlsl-do-while-loop-expected.html
LayoutTests/webgpu/whlsl-do-while-loop.html
LayoutTests/webgpu/whlsl-dont-crash-parsing-enum-expected.html
LayoutTests/webgpu/whlsl-dont-crash-parsing-enum.html
LayoutTests/webgpu/whlsl-dot-expressions-expected.html
LayoutTests/webgpu/whlsl-dot-expressions.html
LayoutTests/webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors-expected.txt
LayoutTests/webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime-2-expected.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime-2.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime-3-expected.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime-3.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime-expected.html
LayoutTests/webgpu/whlsl-ensure-proper-variable-lifetime.html
LayoutTests/webgpu/whlsl-expected.html
LayoutTests/webgpu/whlsl-loops-break-expected.html
LayoutTests/webgpu/whlsl-loops-break.html
LayoutTests/webgpu/whlsl-loops-continue-expected.html
LayoutTests/webgpu/whlsl-loops-continue.html
LayoutTests/webgpu/whlsl-loops-expected.html
LayoutTests/webgpu/whlsl-loops.html
LayoutTests/webgpu/whlsl-matrix-2-expected.txt
LayoutTests/webgpu/whlsl-matrix-2.html
LayoutTests/webgpu/whlsl-matrix-expected.txt
LayoutTests/webgpu/whlsl-matrix.html
LayoutTests/webgpu/whlsl-nested-dot-expression-rvalue-expected.html
LayoutTests/webgpu/whlsl-nested-dot-expression-rvalue.html
LayoutTests/webgpu/whlsl-nested-loop-expected.html
LayoutTests/webgpu/whlsl-nested-loop.html
LayoutTests/webgpu/whlsl-null-dereference-expected.txt
LayoutTests/webgpu/whlsl-null-dereference.html
LayoutTests/webgpu/whlsl-oob-access-expected.txt
LayoutTests/webgpu/whlsl-oob-access.html
LayoutTests/webgpu/whlsl-read-modify-write-expected.txt
LayoutTests/webgpu/whlsl-read-modify-write-high-zombies-expected.txt
LayoutTests/webgpu/whlsl-read-modify-write-high-zombies.html
LayoutTests/webgpu/whlsl-read-modify-write.html
LayoutTests/webgpu/whlsl-return-local-variable-expected.html
LayoutTests/webgpu/whlsl-return-local-variable.html
LayoutTests/webgpu/whlsl-store-to-property-updates-properly-expected.html
LayoutTests/webgpu/whlsl-store-to-property-updates-properly.html
LayoutTests/webgpu/whlsl-textures-getdimensions-expected.txt
LayoutTests/webgpu/whlsl-textures-getdimensions.html
LayoutTests/webgpu/whlsl-textures-load-expected.html
LayoutTests/webgpu/whlsl-textures-load.html
LayoutTests/webgpu/whlsl-textures-sample-expected.html
LayoutTests/webgpu/whlsl-textures-sample.html
LayoutTests/webgpu/whlsl-use-undefined-variable-2-expected.txt
LayoutTests/webgpu/whlsl-use-undefined-variable-2.html
LayoutTests/webgpu/whlsl-use-undefined-variable-expected.txt
LayoutTests/webgpu/whlsl-use-undefined-variable.html
LayoutTests/webgpu/whlsl-while-loop-break-expected.html
LayoutTests/webgpu/whlsl-while-loop-break.html
LayoutTests/webgpu/whlsl-while-loop-continue-expected.html
LayoutTests/webgpu/whlsl-while-loop-continue.html
LayoutTests/webgpu/whlsl-zero-initialize-values-2-expected.html
LayoutTests/webgpu/whlsl-zero-initialize-values-2.html
LayoutTests/webgpu/whlsl-zero-initialize-values-expected.html
LayoutTests/webgpu/whlsl-zero-initialize-values.html
LayoutTests/webgpu/whlsl.html
Source/WTF/ChangeLog
Source/WTF/wtf/Platform.h
Source/WebCore/ChangeLog
Source/WebCore/PAL/PAL.xcodeproj/project.pbxproj
Source/WebCore/PAL/pal/spi/cocoa/MetalSPI.h [new file with mode: 0644]
Source/WebCore/platform/graphics/gpu/cocoa/GPUDeviceMetal.mm

index c0941a9..a7a3f95 100644 (file)
@@ -1,3 +1,163 @@
+2019-06-26  Myles C. Maxfield  <mmaxfield@apple.com>
+
+        REGRESSION: ( r246394 ) webgpu/whlsl-buffer-fragment.html and webgpu/whlsl-buffer-vertex.html are failing
+        https://bugs.webkit.org/show_bug.cgi?id=199012
+
+        Reviewed by Saam Barati.
+
+        Make the tests still pass if the machine doesn't support WebGPU.
+
+        * webgpu/adapter-options-expected.txt: Removed.
+        * webgpu/adapter-options.html: Removed.
+        * webgpu/bind-groups.html:
+        * webgpu/blend-color-triangle-strip-expected.html:
+        * webgpu/blend-color-triangle-strip.html:
+        * webgpu/blend-triangle-strip-expected.html:
+        * webgpu/blend-triangle-strip.html:
+        * webgpu/blit-commands-expected.html:
+        * webgpu/blit-commands.html:
+        * webgpu/buffer-command-buffer-races-expected.html:
+        * webgpu/buffer-command-buffer-races.html:
+        * webgpu/color-write-mask-triangle-strip-expected.html:
+        * webgpu/color-write-mask-triangle-strip.html:
+        * webgpu/command-buffers.html:
+        * webgpu/depth-enabled-triangle-strip-expected.html:
+        * webgpu/depth-enabled-triangle-strip.html:
+        * webgpu/draw-indexed-triangles-expected.html:
+        * webgpu/draw-indexed-triangles.html:
+        * webgpu/js/create-worker-device.js: Removed.
+        * webgpu/js/webgpu-functions.js:
+        (drawWhiteSquareOnBlueBackgroundInSoftware):
+        (drawGreenSquareInSoftware):
+        (drawGreenAndBlueCheckerboardInSoftware):
+        (async.mapWriteDataToBuffer):
+        * webgpu/map-read-buffers.html:
+        * webgpu/map-write-buffers.html:
+        * webgpu/pipeline-layouts.html:
+        * webgpu/propertyresolver/ander-abstract-lvalue-expected.html:
+        * webgpu/propertyresolver/ander-abstract-lvalue.html:
+        * webgpu/propertyresolver/ander-expected.html:
+        * webgpu/propertyresolver/ander-lvalue-3-levels-expected.html:
+        * webgpu/propertyresolver/ander-lvalue-3-levels.html:
+        * webgpu/propertyresolver/ander-lvalue-expected.html:
+        * webgpu/propertyresolver/ander-lvalue.html:
+        * webgpu/propertyresolver/ander.html:
+        * webgpu/propertyresolver/getter-expected.html:
+        * webgpu/propertyresolver/getter.html:
+        * webgpu/propertyresolver/indexer-ander-abstract-lvalue-expected.html:
+        * webgpu/propertyresolver/indexer-ander-abstract-lvalue.html:
+        * webgpu/propertyresolver/indexer-ander-expected.html:
+        * webgpu/propertyresolver/indexer-ander-lvalue-3-levels-expected.html:
+        * webgpu/propertyresolver/indexer-ander-lvalue-3-levels.html:
+        * webgpu/propertyresolver/indexer-ander-lvalue-expected.html:
+        * webgpu/propertyresolver/indexer-ander-lvalue.html:
+        * webgpu/propertyresolver/indexer-ander.html:
+        * webgpu/propertyresolver/indexer-getter-expected.html:
+        * webgpu/propertyresolver/indexer-getter.html:
+        * webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels-expected.html:
+        * webgpu/propertyresolver/indexer-setter-abstract-lvalue-3-levels.html:
+        * webgpu/propertyresolver/indexer-setter-abstract-lvalue-expected.html:
+        * webgpu/propertyresolver/indexer-setter-abstract-lvalue.html:
+        * webgpu/propertyresolver/indexer-setter-expected.html:
+        * webgpu/propertyresolver/indexer-setter-lvalue-expected.html:
+        * webgpu/propertyresolver/indexer-setter-lvalue.html:
+        * webgpu/propertyresolver/indexer-setter.html:
+        * webgpu/propertyresolver/setter-abstract-lvalue-3-levels-expected.html:
+        * webgpu/propertyresolver/setter-abstract-lvalue-3-levels.html:
+        * webgpu/propertyresolver/setter-abstract-lvalue-expected.html:
+        * webgpu/propertyresolver/setter-abstract-lvalue.html:
+        * webgpu/propertyresolver/setter-lvalue-expected.html:
+        * webgpu/propertyresolver/setter-lvalue.html:
+        * webgpu/queue-creation.html:
+        * webgpu/render-command-encoding.html:
+        * webgpu/render-pipelines.html:
+        * webgpu/shader-modules.html:
+        * webgpu/simple-triangle-strip-expected.html:
+        * webgpu/simple-triangle-strip.html:
+        * webgpu/texture-triangle-strip-expected.html:
+        * webgpu/texture-triangle-strip.html:
+        * webgpu/textures-textureviews.html:
+        * webgpu/vertex-buffer-triangle-strip-expected.html:
+        * webgpu/vertex-buffer-triangle-strip.html:
+        * webgpu/viewport-scissor-rect-triangle-strip-expected.html:
+        * webgpu/viewport-scissor-rect-triangle-strip.html:
+        * webgpu/webgpu-enabled-expected.txt: Removed.
+        * webgpu/webgpu-enabled-in-worker-expected.txt: Removed.
+        * webgpu/webgpu-enabled-in-worker.html: Removed.
+        * webgpu/webgpu-enabled.html: Removed.
+        * webgpu/whlsl-arbitrary-vertex-attribute-locations-expected.html:
+        * webgpu/whlsl-arbitrary-vertex-attribute-locations.html:
+        * webgpu/whlsl-buffer-fragment-expected.html:
+        * webgpu/whlsl-buffer-fragment.html:
+        * webgpu/whlsl-buffer-length-expected.txt:
+        * webgpu/whlsl-buffer-length.html:
+        * webgpu/whlsl-buffer-vertex-expected.html:
+        * webgpu/whlsl-buffer-vertex.html:
+        * webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables-expected.txt:
+        * webgpu/whlsl-checker-should-set-type-of-read-modify-write-variables.html:
+        * webgpu/whlsl-compute-expected.txt:
+        * webgpu/whlsl-compute.html:
+        * webgpu/whlsl-dereference-pointer-should-type-check-expected.html:
+        * webgpu/whlsl-dereference-pointer-should-type-check.html:
+        * webgpu/whlsl-do-while-loop-break-expected.html:
+        * webgpu/whlsl-do-while-loop-break.html:
+        * webgpu/whlsl-do-while-loop-continue-expected.html:
+        * webgpu/whlsl-do-while-loop-continue.html:
+        * webgpu/whlsl-do-while-loop-expected.html:
+        * webgpu/whlsl-do-while-loop.html:
+        * webgpu/whlsl-dont-crash-parsing-enum-expected.html:
+        * webgpu/whlsl-dont-crash-parsing-enum.html:
+        * webgpu/whlsl-dot-expressions-expected.html:
+        * webgpu/whlsl-dot-expressions.html:
+        * webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors-expected.txt:
+        * webgpu/whlsl-duplicate-types-should-not-produce-duplicate-ctors.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime-2-expected.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime-2.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime-3-expected.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime-3.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime-expected.html:
+        * webgpu/whlsl-ensure-proper-variable-lifetime.html:
+        * webgpu/whlsl-expected.html:
+        * webgpu/whlsl-loops-break-expected.html:
+        * webgpu/whlsl-loops-break.html:
+        * webgpu/whlsl-loops-continue-expected.html:
+        * webgpu/whlsl-loops-continue.html:
+        * webgpu/whlsl-loops-expected.html:
+        * webgpu/whlsl-loops.html:
+        * webgpu/whlsl-matrix-2-expected.txt:
+        * webgpu/whlsl-matrix-2.html:
+        * webgpu/whlsl-matrix-expected.txt:
+        * webgpu/whlsl-matrix.html:
+        * webgpu/whlsl-nested-dot-expression-rvalue-expected.html:
+        * webgpu/whlsl-nested-dot-expression-rvalue.html:
+        * webgpu/whlsl-nested-loop-expected.html:
+        * webgpu/whlsl-nested-loop.html:
+        * webgpu/whlsl-null-dereference-expected.txt:
+        * webgpu/whlsl-null-dereference.html:
+        * webgpu/whlsl-oob-access-expected.txt:
+        * webgpu/whlsl-oob-access.html:
+        * webgpu/whlsl-read-modify-write-high-zombies-expected.txt:
+        * webgpu/whlsl-read-modify-write-high-zombies.html:
+        * webgpu/whlsl-return-local-variable-expected.html:
+        * webgpu/whlsl-return-local-variable.html:
+        * webgpu/whlsl-store-to-property-updates-properly-expected.html:
+        * webgpu/whlsl-store-to-property-updates-properly.html:
+        * webgpu/whlsl-textures-getdimensions-expected.txt:
+        * webgpu/whlsl-textures-getdimensions.html:
+        * webgpu/whlsl-textures-load-expected.html:
+        * webgpu/whlsl-textures-load.html:
+        * webgpu/whlsl-textures-sample-expected.html:
+        * webgpu/whlsl-textures-sample.html:
+        * webgpu/whlsl-while-loop-break-expected.html:
+        * webgpu/whlsl-while-loop-break.html:
+        * webgpu/whlsl-while-loop-continue-expected.html:
+        * webgpu/whlsl-while-loop-continue.html:
+        * webgpu/whlsl-zero-initialize-values-2-expected.html:
+        * webgpu/whlsl-zero-initialize-values-2.html:
+        * webgpu/whlsl-zero-initialize-values-expected.html:
+        * webgpu/whlsl-zero-initialize-values.html:
+        * webgpu/whlsl.html:
+
 2019-06-26  Simon Fraser  <simon.fraser@apple.com>
 
         Incorrect clippping with overflow:scroll inside oveflow:hidden with border-radius
diff --git a/LayoutTests/webgpu/adapter-options-expected.txt b/LayoutTests/webgpu/adapter-options-expected.txt
deleted file mode 100644 (file)
index 2df1a50..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-
-PASS Create the default device. 
-PASS Create a device with a low-power option. 
-PASS Create a device with a high-performance option. 
-
diff --git a/LayoutTests/webgpu/adapter-options.html b/LayoutTests/webgpu/adapter-options.html
deleted file mode 100644 (file)
index cc464b5..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-<!DOCTYPE html><!-- webkit-test-runner [ experimental:WebGPUEnabled=true ] -->
-<meta charset=utf-8>
-<title>Create GPUDevices from various options.</title>
-<body>
-<script src="../resources/testharness.js"></script>
-<script src="../resources/testharnessreport.js"></script>
-<script>
-promise_test(async () => {
-    const defaultAdapter = await navigator.gpu.requestAdapter();
-    const device = await defaultAdapter.requestDevice();
-
-    assert_true(device instanceof GPUDevice, "Default device successfully created.");
-}, "Create the default device.");
-
-promise_test(async () => {
-    const lowPowerAdapter = await navigator.gpu.requestAdapter({ powerPreference: "low-power" });
-    const device = await lowPowerAdapter.requestDevice();
-
-    assert_true(device instanceof GPUDevice, "Device successfully created using low-power option.");
-}, "Create a device with a low-power option.");
-
-promise_test(async () => {
-    const highPerfAdapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
-    const device = await highPerfAdapter.requestDevice();
-
-    assert_true(device instanceof GPUDevice, "Device successfully created using high-performance option.");
-}, "Create a device with a high-performance option.");
-</script>
-</body>
\ No newline at end of file
index ebd153c..e8563ea 100644 (file)
@@ -6,25 +6,26 @@
 <script src="../resources/testharness.js"></script>
 <script src="../resources/testharnessreport.js"></script>
 <script>
-promise_test(async () => {
-    const device = await getBasicDevice();
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        // GPUBindGroupLayoutBindings
+        // FIXME: Also test sampled texture bindings.
+        const bufferLayoutBinding = {
+            binding: 1,
+            visibility: GPUShaderStageBit.VERTEX,
+            type: "storage-buffer"
+        };
 
-    // GPUBindGroupLayoutBindings
-    // FIXME: Also test sampled texture bindings. 
-    const bufferLayoutBinding = {
-        binding: 1,
-        visibility: GPUShaderStageBit.VERTEX,
-        type: "storage-buffer"
-    };
+        const bindGroupLayout = device.createBindGroupLayout({ bindings: [bufferLayoutBinding] });
 
-    const bindGroupLayout = device.createBindGroupLayout({ bindings: [bufferLayoutBinding] });
+        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.STORAGE });
+        const bufferBinding = { buffer: buffer, size: 16 };
+        const bindGroupBinding = { binding: 1, resource: bufferBinding };
 
-    const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.STORAGE });
-    const bufferBinding = { buffer: buffer, size: 16 };
-    const bindGroupBinding = { binding: 1, resource: bufferBinding };
-
-    const bindGroup = device.createBindGroup({ layout: bindGroupLayout, bindings: [bindGroupBinding]});
-    assert_true(bindGroup instanceof GPUBindGroup, "GPUBindGroup successfully created.")
+        const bindGroup = device.createBindGroup({ layout: bindGroupLayout, bindings: [bindGroupBinding]});
+        assert_true(bindGroup instanceof GPUBindGroup, "GPUBindGroup successfully created.");
+    }, function() {
+    });
 }, "Create a basic GPUBindGroup via GPUDevice.")
 </script>
-</body>
\ No newline at end of file
+</body>
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 04984ae..e0acfd2 100644 (file)
@@ -45,9 +45,9 @@ fragment float4 fragment_main()
 }
 `;
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function start(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -77,10 +77,16 @@ async function test() {
     queue.submit([commandEncoder.finish()]);
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index f209b03..c665f57 100644 (file)
@@ -42,10 +42,9 @@ fragment float4 fragment_main(VertexOut v [[stage_in]])
 }
 `;
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
 
+async function start(device) {
     const shaderModule = device.createShaderModule({ code: shaderCode });
 
     const colorStates = [{
@@ -95,13 +94,17 @@ async function test() {
     device.getQueue().submit([commandEncoder.finish()]);
 }
 
-window.addEventListener("load", function() {
-    test().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
-}, false);
+}, function() {
+    drawGreenSquareInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
+});
 </script>
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 8339e90..b3ef263 100644 (file)
 if (window.testRunner)
     testRunner.waitUntilDone();
 
+const canvas2d = document.querySelector("canvas");
+
 async function loadImage() {
     const image = new Image();
     image.src = "resources/green-400.png";
     image.onload = function() {
-        test(image).then(function() {
-            if (window.testRunner)
-                testRunner.notifyDone();
+        getBasicDevice().then(function(device) {
+            test(device, image).then(function() {
+                if (window.testRunner)
+                    testRunner.notifyDone();
+            }, function(e) {
+                if (window.testRunner)
+                    testRunner.notifyDone();
+            });
         }, function() {
+            drawGreenSquareInSoftware(canvas2d);
             if (window.testRunner)
                 testRunner.notifyDone();
         });
     }
 }
 
-async function test(image) {
-    const device = await getBasicDevice();
-
-    const canvas2d = document.createElement('canvas');
+async function test(device, image) {
     canvas2d.width = image.width;
     canvas2d.height = image.height;
     const context2d = canvas2d.getContext('2d');
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index abaaa2a..01b1e58 100644 (file)
@@ -77,9 +77,9 @@ function drawAndSubmitCommands(device, pipeline, attachment, vertexBuffer, color
     device.getQueue().submit([commandEncoder.finish()]);
 }
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -141,10 +141,16 @@ async function test() {
     upperRightBuffer.destroy();
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 5dcc3d9..2f3f12c 100644 (file)
@@ -45,9 +45,9 @@ fragment float4 fragment_main()
 }
 `
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     const shaderModule = device.createShaderModule({ code: shaderCode });
     const colorStates = [{
@@ -71,10 +71,16 @@ async function test() {
     queue.submit([commandEncoder.finish()]);
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index 833a383..f8de175 100644 (file)
@@ -4,12 +4,14 @@
 <script src="../resources/testharness.js"></script>
 <script src="../resources/testharnessreport.js"></script>
 <script>
-promise_test(async () => {
-    const device = await getBasicDevice();
-    const commandEncoder = device.createCommandEncoder();
-    assert_true(commandEncoder instanceof GPUCommandEncoder, "Successfully created GPUCommandEncoder.");
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        const commandEncoder = device.createCommandEncoder();
+        assert_true(commandEncoder instanceof GPUCommandEncoder, "Successfully created GPUCommandEncoder.");
+    }, function() {
+    });
 }, "Create a default GPUCommandEncoder.");
 
 // FIXME: createCommandEncoder should take a GPUCommandEncoderDescriptor, which is currently an empty dictionary.
 </script>
-</html>
\ No newline at end of file
+</html>
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 94b99b1..fb559a8 100644 (file)
@@ -71,9 +71,9 @@ function createVertexInputDescriptor() {
     }
 }
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -110,10 +110,16 @@ async function test() {
     device.getQueue().submit([commandEncoder.finish()]);
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 6738712..11a2b46 100644 (file)
@@ -92,9 +92,9 @@ function createVertexInputDescriptor() {
     };
 }
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -114,10 +114,16 @@ async function test() {
     vertexBuffer.destroy();
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
diff --git a/LayoutTests/webgpu/js/create-worker-device.js b/LayoutTests/webgpu/js/create-worker-device.js
deleted file mode 100644 (file)
index ebf75fb..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-async function tryCreateDevice() {
-    if (!navigator.gpu)
-        postMessage(false);
-
-    const adapter = await navigator.gpu.requestAdapter();
-    await adapter.requestDevice();
-
-    postMessage(true);
-}
-
-tryCreateDevice();
index 8a53bd7..646e801 100644 (file)
@@ -4,6 +4,52 @@ async function getBasicDevice() {
     return device;
 }
 
+function drawWhiteSquareOnBlueBackgroundInSoftware(canvas) {
+    const context = canvas.getContext("2d");
+    context.fillStyle = "blue";
+    context.fillRect(0, 0, 400, 400);
+    context.fillStyle = "white";
+    context.fillRect(100, 100, 200, 200);
+}
+
+function drawBlackSquareOnBlueBackgroundInSoftware(canvas) {
+    const context = canvas.getContext("2d");
+    context.fillStyle = "blue";
+    context.fillRect(0, 0, 400, 400);
+    context.fillStyle = "black";
+    context.fillRect(100, 100, 200, 200);
+}
+
+function drawGreenSquareInSoftware(canvas) {
+    const context = canvas.getContext('2d');
+    context.fillStyle = 'rgb(0, 255, 0)';
+    context.fillRect(0, 0, canvas.width, canvas.height);
+}
+
+function drawGreenAndBlueCheckerboardInSoftware(canvas) {
+    const context = canvas.getContext('2d');
+
+    context.fillStyle = 'rgb(0, 255, 0)';
+    context.fillRect(0, 0, canvas.width, canvas.height);
+
+    const numColumns = 4;
+    const numRows = 4;
+    context.beginPath();
+    context.fillStyle = 'rgb(0, 0, 255)';
+    for (let x = 0; x < numColumns; ++x) {
+        for (let y = 0; y < numRows; ++y) {
+            if (x % 2 == 0 && y % 2 == 0 || x % 2 == 1 && y % 2 == 1)
+                context.rect(
+                    x * canvas.width / numColumns,
+                    y * canvas.height / numRows,
+                    canvas.width / numColumns,
+                    canvas.height / numRows
+                    );
+        }
+    }
+    context.fill();
+}
+
 function createBasicSwapChain(canvas, device) {
     const context = canvas.getContext("gpu");
     return context.configureSwapChain({ device: device, format: "bgra8unorm" });
@@ -102,4 +148,4 @@ async function mapWriteDataToBuffer(buffer, data, offset = 0) {
     const writeArray = new Uint8Array(arrayBuffer);
     writeArray.set(new Uint8Array(data), offset);
     buffer.unmap();
-}
\ No newline at end of file
+}
index 442549d..87bfe54 100644 (file)
 <script src="js/webgpu-functions.js"></script>
 <script>
 async function runTests() {
-    const device =  await getBasicDevice();
-
     // Basic mapReadAsync functionality
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
-        assert_true(buffer instanceof GPUBuffer, "createBuffer returned a GPUBuffer");
-
-        let arrayBuffer = await buffer.mapReadAsync();
-        assert_true(arrayBuffer instanceof ArrayBuffer, "first mapReadAsync resolved successfully");
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
+            assert_true(buffer instanceof GPUBuffer, "createBuffer returned a GPUBuffer");
 
-        const readArray = new Float32Array(arrayBuffer);
-        assert_equals(readArray[0], 0, "successfully access a value from a map read");
+            let arrayBuffer = await buffer.mapReadAsync();
+            assert_true(arrayBuffer instanceof ArrayBuffer, "first mapReadAsync resolved successfully");
 
-        buffer.unmap();
+            const readArray = new Float32Array(arrayBuffer);
+            assert_equals(readArray[0], 0, "successfully access a value from a map read");
 
-        const promise = buffer.mapReadAsync(); // This will eventually reject due to buffer.destroy()
+            buffer.unmap();
 
-        buffer.destroy();
+            const promise = buffer.mapReadAsync(); // This will eventually reject due to buffer.destroy()
 
-        await promise.then(() => {
-            assert_unreached("Buffer was destroyed!");
-        }, () => {});
+            buffer.destroy();
 
+            await promise.then(() => {
+                assert_unreached("Buffer was destroyed!");
+            }, () => {});
+        }, function() {
+        });
     }, "mapReadAsync, unmap, and destroy on a GPUBuffer.");
 
     // GPUDevice.createBufferMapped
-    promise_test(async () => {
-        const bufferResult = device.createBufferMapped({ size: 16, usage: GPUBufferUsage.MAP_READ });
-        const buffer = bufferResult[0];
-        const arrayBuffer = bufferResult[1];
-
-        assert_true(buffer instanceof GPUBuffer, "createBufferMapped returned a GPUBuffer");
-        assert_true(arrayBuffer instanceof ArrayBuffer, "createBufferMapped returned an ArrayBuffer");
-
-        let array = new Float32Array(arrayBuffer);
-        array.set([1, 2, 3, 4]);
-
-        // Buffer should already be "mapped".
-        await buffer.mapReadAsync().then(() => {
-            assert_unreached("GPUBuffer created via GPUBufferMapped cannot be mapped until after first unmap!");
-        }, () => {});
-
-        buffer.unmap();
-
-        // Buffer should not be re-mappable for writes.
-        await buffer.mapWriteAsync().then(() => {
-            assert_unreached("Buffer was not created with MAP_WRITE!");
-        }, () => {});
-
-        // Read results of original writes.
-        let resultArrayBuffer = await buffer.mapReadAsync();
-        const resultArray = new Float32Array(resultArrayBuffer);
-        resultArray.forEach((v, i) => {
-            assert_equals(v, array[i], "Successfully map-read value written to GPUBuffer mapped on creation");
-        })
-        
-        buffer.destroy();
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const bufferResult = device.createBufferMapped({ size: 16, usage: GPUBufferUsage.MAP_READ });
+            const buffer = bufferResult[0];
+            const arrayBuffer = bufferResult[1];
+
+            assert_true(buffer instanceof GPUBuffer, "createBufferMapped returned a GPUBuffer");
+            assert_true(arrayBuffer instanceof ArrayBuffer, "createBufferMapped returned an ArrayBuffer");
+
+            let array = new Float32Array(arrayBuffer);
+            array.set([1, 2, 3, 4]);
+
+            // Buffer should already be "mapped".
+            await buffer.mapReadAsync().then(() => {
+                assert_unreached("GPUBuffer created via GPUBufferMapped cannot be mapped until after first unmap!");
+            }, () => {});
+
+            buffer.unmap();
+
+            // Buffer should not be re-mappable for writes.
+            await buffer.mapWriteAsync().then(() => {
+                assert_unreached("Buffer was not created with MAP_WRITE!");
+            }, () => {});
+
+            // Read results of original writes.
+            let resultArrayBuffer = await buffer.mapReadAsync();
+            const resultArray = new Float32Array(resultArrayBuffer);
+            resultArray.forEach((v, i) => {
+                assert_equals(v, array[i], "Successfully map-read value written to GPUBuffer mapped on creation");
+            })
+            
+            buffer.destroy();
+        }, function() {
+        });
     }, "GPUBuffer.mapReadAsync on a buffer created via GPUDevice.createBufferMapped.");
 
     /* Basic validation */
     // FIXME: Test invalid combinations of GPUBufferUsage after implementing error handling.
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
 
-        await buffer.mapReadAsync().then(() => {
-            assert_unreached("Buffer was not created with MAP_READ!");
-        }, () => {});
+            await buffer.mapReadAsync().then(() => {
+                assert_unreached("Buffer was not created with MAP_READ!");
+            }, () => {});
+        }, function() {
+        });
     }, "Reject a map read on a buffer not created with MAP_READ usage.");
 
     /* Extended unmap/destroy and promise settling testing */
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
 
-        buffer.mapReadAsync().then(() => {
-            buffer.unmap();
-        }, () => { 
-            assert_unreached(); 
-        });
+            buffer.mapReadAsync().then(() => {
+                buffer.unmap();
+            }, () => {
+                assert_unreached();
+            });
 
-        await buffer.mapReadAsync().then(() => {
-            assert_unreached("Map operation was invalid!"); // buffer was still in mapped state during promise creation
-        }, () => {});
+            await buffer.mapReadAsync().then(() => {
+                assert_unreached("Map operation was invalid!"); // buffer was still in mapped state during promise creation
+            }, () => {});
+        }, function() {
+        });
     }, "Reject a map read on a mapped GPUBuffer.");
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
 
-        const promise = buffer.mapReadAsync();
-        buffer.unmap();
+            const promise = buffer.mapReadAsync();
+            buffer.unmap();
 
-        await promise.then(() => {
-            assert_unreached("Buffer was unmapped!"); // buffer was unmapped, which rejects pending promises
-        },() => {});
+            await promise.then(() => {
+                assert_unreached("Buffer was unmapped!"); // buffer was unmapped, which rejects pending promises
+            },() => {});
+        }, function() {
+        });
     }, "Reject a pending map read if GPUBuffer is unmapped.");
 }
 
index 887967c..3405196 100644 (file)
@@ -7,69 +7,78 @@
 <script src="js/webgpu-functions.js"></script>
 <script>
 async function runTests() {
-    const device =  await getBasicDevice();
-
     // Basic mapWriteAsync functionality
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
-        assert_true(buffer instanceof GPUBuffer, "createBuffer returned a GPUBuffer");
-
-        let arrayBuffer = await buffer.mapWriteAsync();
-
-        assert_true(arrayBuffer instanceof ArrayBuffer, "first mapWriteAsync resolved successfully");
-        
-        let array = new Float32Array(arrayBuffer);
-        assert_equals(array[0], 0, "mapWriteAsync zeroed out storage");
-        array.set([1, 2, 3, 4]);
-        
-        buffer.unmap();
-
-        const promise = buffer.mapWriteAsync(); // This will eventually reject due to buffer.destroy()
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
+            assert_true(buffer instanceof GPUBuffer, "createBuffer returned a GPUBuffer");
+
+            let arrayBuffer = await buffer.mapWriteAsync();
+
+            assert_true(arrayBuffer instanceof ArrayBuffer, "first mapWriteAsync resolved successfully");
+            
+            let array = new Float32Array(arrayBuffer);
+            assert_equals(array[0], 0, "mapWriteAsync zeroed out storage");
+            array.set([1, 2, 3, 4]);
+            
+            buffer.unmap();
 
-        buffer.destroy();
+            const promise = buffer.mapWriteAsync(); // This will eventually reject due to buffer.destroy()
 
-        await promise.then(() => {
-            assert_unreached("Buffer was destroyed!");
-        }, () => {});
+            buffer.destroy();
 
+            await promise.then(() => {
+                assert_unreached("Buffer was destroyed!");
+            }, () => {});
+        }, function() {
+        });
     }, "Map write, unmap, and destroy a GPUBuffer.");
 
     /* Basic validation */
     // FIXME: Test invalid combinations of GPUBufferUsage after implementing error handling.
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
 
-        await buffer.mapWriteAsync().then(() => {
-            assert_unreached("Buffer was not created with MAP_WRITE!");
-        }, () => {});
+            await buffer.mapWriteAsync().then(() => {
+                assert_unreached("Buffer was not created with MAP_WRITE!");
+            }, () => {});
+        }, function() {
+        });
     }, "Reject a map write on a buffer not created with MAP_WRITE usage.");
 
     /* Extended unmap/destroy and promise settling testing */
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
 
-        buffer.mapWriteAsync().then(() => {
-            buffer.unmap();
-        }, () => { 
-            assert_unreached(); 
-        });
+            buffer.mapWriteAsync().then(() => {
+                buffer.unmap();
+            }, () => {
+                assert_unreached();
+            });
 
-        await buffer.mapWriteAsync().then(() => {
-            assert_unreached("Map operation was invalid!"); // buffer was still in mapped state during promise creation
-        }, () => {});
+            await buffer.mapWriteAsync().then(() => {
+                assert_unreached("Map operation was invalid!"); // buffer was still in mapped state during promise creation
+            }, () => {});
+        }, function() {
+        });
     }, "Reject a map write on a mapped GPUBuffer.");
 
-    promise_test(async () => {
-        const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
+    promise_test(() => {
+        return getBasicDevice().then(async function(device) {
+            const buffer = device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
 
-        const promise = buffer.mapWriteAsync();
-        buffer.unmap();
+            const promise = buffer.mapWriteAsync();
+            buffer.unmap();
 
-        await promise.then(() => {
-            assert_unreached("Buffer was unmapped!"); // buffer was unmapped, which rejects pending promises
-        },() => {});
+            await promise.then(() => {
+                assert_unreached("Buffer was unmapped!"); // buffer was unmapped, which rejects pending promises
+            },() => {});
+        }, function() {
+        });
     }, "Reject a pending map write if GPUBuffer is unmapped.");
 }
 
index 0d24f4b..3da8e31 100644 (file)
@@ -21,13 +21,15 @@ test(() => {
     assert_equals(bindGroupLayoutDescriptor.bindings[0].type, "storage-buffer");
 }, "Create a basic GPUBindGroupLayoutDescriptor."); 
 
-promise_test(async () => {
-    const device = await getBasicDevice();
-    const bindGroupLayout = device.createBindGroupLayout({ bindings: [createBindGroupLayoutBinding()] });
-    assert_true(bindGroupLayout instanceof GPUBindGroupLayout, "createBindGroupLayout returned a GPUBindGroupLayout");
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        const bindGroupLayout = device.createBindGroupLayout({ bindings: [createBindGroupLayoutBinding()] });
+        assert_true(bindGroupLayout instanceof GPUBindGroupLayout, "createBindGroupLayout returned a GPUBindGroupLayout");
 
-    const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] });
-    assert_true(pipelineLayout instanceof GPUPipelineLayout, "createPipelineLayout returned a GPUPipelineLayout");
+        const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] });
+        assert_true(pipelineLayout instanceof GPUPipelineLayout, "createPipelineLayout returned a GPUPipelineLayout");
+    }, function() {
+    });
 }, "Create a basic GPUPipelineLayout wtih a GPUDevice.");
 </script>
-</body>
\ No newline at end of file
+</body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 444c314..a0988ad 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -37,10 +38,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.w.y, b.w.y, b.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -84,7 +85,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -106,14 +106,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 00107b8..d0901c4 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -40,10 +41,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.q.w.y, b.q.w.y, b.q.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -87,7 +88,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -109,14 +109,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index c81dcf2..0956994 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -32,10 +33,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.w.y, b.w.y, b.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -79,7 +80,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -101,14 +101,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index a6c0126..60f3944 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -28,10 +29,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(generateFoo().y, generateFoo().y, generateFoo().y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -75,7 +76,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -97,14 +97,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index a5ed9c6..adbcec4 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -24,10 +25,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(f.y, f.y, f.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -71,7 +72,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -93,14 +93,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 6a56a6a..89fb8f1 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -37,10 +38,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[2][3], b[2][3], b[2][3], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -84,7 +85,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -106,14 +106,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index bec5e40..7baab5b 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -40,10 +41,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[1][2][3], b[1][2][3], b[1][2][3], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -87,7 +88,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -109,14 +109,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f32edf6..45bb1ff 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -32,10 +33,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[1][2], b[1][2], b[1][2], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -79,7 +80,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -101,14 +101,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index a3e7864..cf835d9 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -28,10 +29,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(generateFoo()[0], generateFoo()[1], generateFoo()[2], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -75,7 +76,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -97,14 +97,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f79f5d5..320ef8b 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -23,10 +24,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(f[1], f[1], f[1], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -70,7 +71,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -92,14 +92,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 8596867..37cc3ca 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -55,10 +56,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[2][3][4], b[2][3][4], b[2][3][4], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -102,7 +103,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -124,14 +124,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index faed73e..1e6bd21 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -42,10 +43,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[2][3], b[2][3], b[2][3], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -89,7 +90,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -111,14 +111,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index f72e88b..9be5b8c 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -37,10 +38,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b[2][3], b[2][3], b[2][3], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -84,7 +85,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -106,14 +106,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 522feff..f2d5d50 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -40,10 +41,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(foo.x, foo.x, foo.x, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -87,7 +88,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -109,14 +109,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 22a3c63..593245a 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -55,10 +56,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.q.w.y, b.q.w.y, b.q.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -102,7 +103,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -124,14 +124,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 82705af..1b0fdb2 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -42,10 +43,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.w.y, b.w.y, b.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -89,7 +90,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -111,14 +111,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..f3e7be7 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 1e46ae5..e19cf7c 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="../js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -37,10 +38,10 @@ fragment float4 fragmentShader() : SV_Target 0 {
     return float4(b.w.y, b.w.y, b.w.y, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -84,7 +85,6 @@ async function start() {
     vertexBufferFloat32Array[15] = 1;
     vertexBuffer.unmap();
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -106,14 +106,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index db35b4e..beefb2b 100644 (file)
@@ -4,6 +4,7 @@
 <body>
 <script src="../resources/testharness.js"></script>
 <script src="../resources/testharnessreport.js"></script>
+<script src="js/webgpu-functions.js"></script>
 <script>
 
 'use strict';
@@ -14,17 +15,14 @@ promise_test(async t => {
     const context = document.createElement("canvas").getContext("gpu");
     assert_true(context instanceof GPUCanvasContext, "getContext returned a GPUCanvasContext.");
 
-    const adapter = await navigator.gpu.requestAdapter({});
-    assert_true(adapter instanceof GPUAdapter, "requestAdapter returned a GPUAdapter.");
+    return getBasicDevice().then(async function(device) {
+        const queue = device.getQueue();
+        assert_true(queue instanceof GPUQueue, "getQueue returned a GPUQueue.");
 
-    const device = await adapter.requestDevice();
-    assert_true(device instanceof GPUDevice, "requestDevice returned a GPUDevice.");
-
-    const queue = device.getQueue();
-    assert_true(queue instanceof GPUQueue, "getQueue returned a GPUQueue.");
-
-    queue.label = "Example label";
-    assert_equals(queue.label, "Example label", "queue.label was set.");
+        queue.label = "Example label";
+        assert_equals(queue.label, "Example label", "queue.label was set.");
+    }, function() {
+    });
 }, "getQueue() on GPUDevice.");
 
 </script>
index 7c600df..05c8aac 100644 (file)
@@ -26,22 +26,24 @@ fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
     return vertexIn.position;
 }
 `
-promise_test(async () => {
-    const device = await getBasicDevice();
 
-    const canvas = document.createElement("canvas");
-    const swapChain = createBasicSwapChain(canvas, device);
-    const shaderModule = device.createShaderModule({ code: shaders });
-    const pipeline = createBasicPipeline(shaderModule, device);
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        const canvas = document.createElement("canvas");
+        const swapChain = createBasicSwapChain(canvas, device);
+        const shaderModule = device.createShaderModule({ code: shaders });
+        const pipeline = createBasicPipeline(shaderModule, device);
 
-    const commandEncoder = device.createCommandEncoder();
-    assert_true(commandEncoder instanceof GPUCommandEncoder, "createCommandEncoder returned a GPUCommandEncoder");
+        const commandEncoder = device.createCommandEncoder();
+        assert_true(commandEncoder instanceof GPUCommandEncoder, "createCommandEncoder returned a GPUCommandEncoder");
 
-    const encoder = beginBasicRenderPass(swapChain, commandEncoder);
-    assert_true(encoder instanceof GPURenderPassEncoder, "beginRenderPass() returned a GPURenderPassEncoder");
+        const encoder = beginBasicRenderPass(swapChain, commandEncoder);
+        assert_true(encoder instanceof GPURenderPassEncoder, "beginRenderPass() returned a GPURenderPassEncoder");
 
-    encoder.setPipeline(pipeline);
-    encoder.endPass();
+        encoder.setPipeline(pipeline);
+        encoder.endPass();
+    }, function() {
+    });
 }, "GPURenderPassEncoder created and successfully ended");
 
 </script>
index 7593956..e6665bb 100644 (file)
@@ -39,16 +39,18 @@ fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
 }
 `
 
-promise_test(async () => {
-    const device = await getBasicDevice();
-    const shaderModule = device.createShaderModule({ code: shaderCode });
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        const shaderModule = device.createShaderModule({ code: shaderCode });
 
-    const layoutBinding = { binding: 0, visibility: GPUShaderStageBit.VERTEX, type: "storage-buffer" };
-    const bindGroupLayout = device.createBindGroupLayout({ bindings: [layoutBinding] });
-    const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] });
+        const layoutBinding = { binding: 0, visibility: GPUShaderStageBit.VERTEX, type: "storage-buffer" };
+        const bindGroupLayout = device.createBindGroupLayout({ bindings: [layoutBinding] });
+        const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] });
 
-    const pipeline = createBasicPipeline(shaderModule, device, null, pipelineLayout);
-    assert_true(pipeline instanceof GPURenderPipeline, "Successfully created GPURenderPipeline");
+        const pipeline = createBasicPipeline(shaderModule, device, null, pipelineLayout);
+        assert_true(pipeline instanceof GPURenderPipeline, "Successfully created GPURenderPipeline");
+    }, function() {
+    });
 }, "Create basic GPURenderPipeline");
 </script>
-</html>
\ No newline at end of file
+</html>
index 870f888..b892981 100644 (file)
@@ -27,11 +27,12 @@ fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
 }
 `
 
-promise_test(async () => {
-    const device = await getBasicDevice();
-
-    let shaderModule = device.createShaderModule({ code: shaders });
-    assert_true(shaderModule instanceof GPUShaderModule, "Shader module created successfully.");
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        let shaderModule = device.createShaderModule({ code: shaders });
+        assert_true(shaderModule instanceof GPUShaderModule, "Shader module created successfully.");
+    }, function() {
+    });
 }, "Test shader code validation when creating modules.");
 </script>
-</html>
\ No newline at end of file
+</html>
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index ebc5506..c8d1e3b 100644 (file)
@@ -45,9 +45,9 @@ fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
 }
 `
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -60,10 +60,16 @@ async function test() {
     queue.submit([commandEncoder.finish()]);
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index b69a9c0..fc8fe2b 100644 (file)
@@ -1,29 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is a 4 by 4 blue/green checkerboard.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-
-const numColumns = 4;
-const numRows = 4;
-context.beginPath();
-context.fillStyle = 'rgb(0, 0, 255)';
-for (let x = 0; x < numColumns; ++x) {
-    for (let y = 0; y < numRows; ++y) {
-        if (x % 2 == 0 && y % 2 == 0 || x % 2 == 1 && y % 2 == 1)
-            context.rect(
-                x * canvas.width / numColumns, 
-                y * canvas.height / numRows, 
-                canvas.width / numColumns, 
-                canvas.height / numRows
-                );
-    }
-}
-context.fill();
-</script>
\ No newline at end of file
+drawGreenAndBlueCheckerboardInSoftware(canvas);
+</script>
index c729d96..cae04b5 100644 (file)
@@ -75,9 +75,9 @@ function createVertexInputDescriptor() {
     return { vertexBuffers: bufferDescriptors };
 }
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -196,10 +196,16 @@ async function test() {
     texture.destroy();
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenAndBlueCheckerboardInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index 0becd33..04e4c92 100644 (file)
@@ -8,7 +8,7 @@
 <script src="../resources/testharnessreport.js"></script>
 <script>
 const canvas = document.querySelector("canvas");    
-let device, context;
+let context;
 
 let texSize = {
     width: canvas.width,
@@ -22,41 +22,52 @@ let texDescriptor = {
     usage: GPUTextureUsage.OUTPUT_ATTACHMENT
 };
 
-promise_test(async () => {
-    device = await getBasicDevice();
-    swapChain = createBasicSwapChain(canvas, device);
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        swapChain = createBasicSwapChain(canvas, device);
 
-    const texture = swapChain.getCurrentTexture();
-    assert_true(texture instanceof GPUTexture, "Successfully acquired next texture.");
+        const texture = swapChain.getCurrentTexture();
+        assert_true(texture instanceof GPUTexture, "Successfully acquired next texture.");
 
-    const textureView = texture.createDefaultView();
-    assert_true(textureView instanceof GPUTextureView, "Successfully created texture view from next texture.");
+        const textureView = texture.createDefaultView();
+        assert_true(textureView instanceof GPUTextureView, "Successfully created texture view from next texture.");
+    }, function() {
+    });
 }, "Create texture view from swap chain.");
 
-promise_test(async () => {
-    const depthTexture = device.createTexture(texDescriptor);
-    assert_true(depthTexture instanceof GPUTexture, "Successfully created depth texture.");
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        const depthTexture = device.createTexture(texDescriptor);
+        assert_true(depthTexture instanceof GPUTexture, "Successfully created depth texture.");
+    }, function() {
+    });
 }, "Create basic depth texture from device.");
 
-promise_test(async () => {
-    texDescriptor.sampleCount = 4;
-    texDescriptor.format = "rgba8unorm";
-    texDescriptor.usage = GPUTextureUsage.SAMPLED | GPUTextureUsage.TRANSFER_SRC
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        texDescriptor.sampleCount = 4;
+        texDescriptor.format = "rgba8unorm";
+        texDescriptor.usage = GPUTextureUsage.SAMPLED | GPUTextureUsage.TRANSFER_SRC
 
-    const multisampledTexture = device.createTexture(texDescriptor);
-    assert_true(multisampledTexture instanceof GPUTexture, "Successfully created multisampled texture.");
+        const multisampledTexture = device.createTexture(texDescriptor);
+        assert_true(multisampledTexture instanceof GPUTexture, "Successfully created multisampled texture.");
+    }, function() {
+    });
 }, "Create basic 4x multisampled texture.");
 
-promise_test(async () => {
-    texDescriptor.size.depth = 3;
-    texDescriptor.sampleCount = 1;
-    texDescriptor.dimension = "3d";
+promise_test(() => {
+    return getBasicDevice().then(function(device) {
+        texDescriptor.size.depth = 3;
+        texDescriptor.sampleCount = 1;
+        texDescriptor.dimension = "3d";
 
-    const texture3d = device.createTexture(texDescriptor);
-    assert_true(texture3d instanceof GPUTexture, "Successfully created basic 3D texture.");
+        const texture3d = device.createTexture(texDescriptor);
+        assert_true(texture3d instanceof GPUTexture, "Successfully created basic 3D texture.");
+    }, function() {
+    });
 }, "Create basic 3D texture from device.");
 
 // FIXME: Add tests for 1D textures, textureArrays, and GPUTextureViews.
 </script>
 </body>
-</html>
\ No newline at end of file
+</html>
index 886f13e..4f60f5a 100644 (file)
@@ -1,12 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is completely green.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
+drawGreenSquareInSoftware(canvas);
+</script>
index 41104fc..bd335e6 100644 (file)
@@ -76,9 +76,9 @@ function createVertexInputDescriptor() {
     }
 }
 
-async function test() {
-    const device = await getBasicDevice();
-    const canvas = document.querySelector("canvas");
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
     const shaderModule = device.createShaderModule({ code: shaderCode });
@@ -93,10 +93,16 @@ async function test() {
     vertexBuffer.destroy();
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenSquareInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
index b69a9c0..fc8fe2b 100644 (file)
@@ -1,29 +1,10 @@
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>HTML Reference File</title>
+<script src="js/webgpu-functions.js"></script>
 <p>Pass if square canvas below is a 4 by 4 blue/green checkerboard.</p>
 <canvas width="400" height="400"></canvas>
 <script>
 const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-
-const numColumns = 4;
-const numRows = 4;
-context.beginPath();
-context.fillStyle = 'rgb(0, 0, 255)';
-for (let x = 0; x < numColumns; ++x) {
-    for (let y = 0; y < numRows; ++y) {
-        if (x % 2 == 0 && y % 2 == 0 || x % 2 == 1 && y % 2 == 1)
-            context.rect(
-                x * canvas.width / numColumns, 
-                y * canvas.height / numRows, 
-                canvas.width / numColumns, 
-                canvas.height / numRows
-                );
-    }
-}
-context.fill();
-</script>
\ No newline at end of file
+drawGreenAndBlueCheckerboardInSoftware(canvas);
+</script>
index 4a783d5..b9ade87 100644 (file)
@@ -45,8 +45,9 @@ fragment float4 fragment_main(Vertex vertexIn [[stage_in]])
 }
 `;
 
-async function test() {
-    const device = await getBasicDevice();
+const canvas = document.querySelector("canvas");
+
+async function test(device) {
     const canvas = document.querySelector("canvas");
     const swapChain = createBasicSwapChain(canvas, device);
     // FIXME: Replace with non-MSL shaders.
@@ -96,10 +97,16 @@ async function test() {
     queue.submit([commandEncoder.finish()]);
 }
 
-test().then(function() {
-    if (window.testRunner)
-        testRunner.notifyDone();
+getBasicDevice().then(function(device) {
+    test(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
 }, function() {
+    drawGreenAndBlueCheckerboardInSoftware(canvas);
     if (window.testRunner)
         testRunner.notifyDone();
 });
diff --git a/LayoutTests/webgpu/webgpu-enabled-expected.txt b/LayoutTests/webgpu/webgpu-enabled-expected.txt
deleted file mode 100644 (file)
index 5694c21..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-
-PASS Web GPU is enabled. 
-
diff --git a/LayoutTests/webgpu/webgpu-enabled-in-worker-expected.txt b/LayoutTests/webgpu/webgpu-enabled-in-worker-expected.txt
deleted file mode 100644 (file)
index f4faecc..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-
-PASS Test if WebGPU is enabled for workers. 
-
diff --git a/LayoutTests/webgpu/webgpu-enabled-in-worker.html b/LayoutTests/webgpu/webgpu-enabled-in-worker.html
deleted file mode 100644 (file)
index 33dc5e6..0000000
+++ /dev/null
@@ -1,20 +0,0 @@
-<!DOCTYPE html><!-- webkit-test-runner [ experimental:WebGPUEnabled=true ] -->
-<html>
-<meta charset=utf-8>
-<title>Test if WebGPU is enabled for workers.</title>
-<script src="../resources/testharness.js"></script>
-<script src="../resources/testharnessreport.js"></script>
-<script>
-if (window.testRunner)
-    testRunner.waitUntilDone();
-
-const worker = new Worker('js/create-worker-device.js');
-
-worker.onmessage = event => {
-    test(() => { assert_true(event.data, "Create GPUDevice with a worker."); });
-
-    if (window.testRunner)
-        testRunner.notifyDone();
-};
-</script>
-</html>
\ No newline at end of file
diff --git a/LayoutTests/webgpu/webgpu-enabled.html b/LayoutTests/webgpu/webgpu-enabled.html
deleted file mode 100644 (file)
index a2434cd..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE html><!-- webkit-test-runner [ experimental:WebGPUEnabled=true ] -->
-<html>
-<meta charset=utf-8>
-<title>Test if WebGPU is enabled.</title>
-<script src="../resources/testharness.js"></script>
-<script src="../resources/testharnessreport.js"></script>
-<script>
-promise_test(async () => {
-    const canvas = document.createElement("canvas");
-    const context = canvas.getContext("gpu");
-    assert_true(context instanceof GPUCanvasContext, "Created GPUCanvasContext.");
-
-    assert_equals(window.gpu, undefined, "window.gpu should not be defined.")
-    assert_not_equals(navigator.gpu, undefined, "navigator.gpu is defined.");
-
-    const adapter = await navigator.gpu.requestAdapter();
-    assert_true(adapter instanceof GPUAdapter, "Created default GPUAdapter.");
-    
-    const device = await adapter.requestDevice();
-    assert_true(device instanceof GPUDevice, "Created GPUDevice.");
-}, "Web GPU is enabled.");
-</script>
-</html>
\ No newline at end of file
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 049e1bc..f1a0414 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -22,10 +23,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -91,7 +92,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -114,14 +114,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 9bb788f..e0baba0 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -14,10 +15,10 @@ fragment float4 fragmentShader(float4 position : SV_Position, constant float[] t
     return float4(theBuffer[0], theBuffer[0], theBuffer[0], 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -87,7 +88,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -110,14 +110,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 597f203..4882f90 100644 (file)
@@ -1,4 +1,4 @@
-PASS resultUint32Array[0] is 1337
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index ba201c4..a322c6d 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -11,11 +12,8 @@ compute void computeShader(device uint[] buffer : register(u0), float3 threadID
     buffer[0] = buffer.length;
 }
 `;
-let resultUint32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -55,17 +53,24 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultUint32Array = new Uint32Array(resultsArrayBuffer);
-    shouldBe("resultUint32Array[0]", "1337");
+    const resultUint32Array = new Uint32Array(resultsArrayBuffer);
+    if (resultUint32Array[0] == 1337)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index b192703..000f280 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -14,10 +15,10 @@ fragment float4 fragmentShader(float4 position : SV_Position) : SV_Target 0 {
     return float4(1.0, 1.0, 1.0, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -67,7 +68,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -89,14 +89,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 464e268..1c799bf 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -13,11 +14,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     buffer[uint(threadID.x)] = vec[0];
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -57,20 +55,24 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "42");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 42)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
-if (window.testRunner)
-    testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+window.jsTestIsAsync = true;
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        finishJSTest();
     }, function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+        testFailed("");
+        finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index a935cf8..4882f90 100644 (file)
@@ -1,11 +1,4 @@
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 8093e85..b3b0e9a 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -11,11 +12,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -62,24 +60,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 7b0c10b..42cec96 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -27,10 +28,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -97,7 +98,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -120,14 +120,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 8a114c4..361ca55 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -31,10 +32,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -101,7 +102,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -124,14 +124,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 243c6f1..97896e8 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -33,10 +34,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -103,7 +104,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -126,14 +126,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 8bdab79..d09c5c8 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -28,10 +29,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -98,7 +99,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -121,14 +121,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 8986f7f..f13f245 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -19,10 +20,10 @@ fragment float4 fragmentShader(float4 position : SV_Position) : SV_Target 0 {
     return position;
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -92,7 +93,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -115,14 +115,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 806b389..af8d50b 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -22,10 +23,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -92,7 +93,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -115,14 +115,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index a935cf8..4882f90 100644 (file)
@@ -1,11 +1,4 @@
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 0ea596c..bc4238d 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -32,11 +33,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     }
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -83,24 +81,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index fd930c8..f98c310 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -51,10 +52,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -121,7 +122,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -144,14 +144,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 12cdc36..ca8a28f 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -52,10 +53,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -122,7 +123,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -145,14 +145,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 5ee0318..ea6a2ee 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -51,10 +52,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -121,7 +122,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -144,14 +144,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index bd7460e..c82382d 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -32,10 +33,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -102,7 +103,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -125,14 +125,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 3e34c93..a3b4e90 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -32,10 +33,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -102,7 +103,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -125,14 +125,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 4f3afa3..82fb767 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -28,10 +29,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -98,7 +99,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -121,14 +121,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 6e1668a..4882f90 100644 (file)
@@ -1,12 +1,5 @@
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
 
index 1701999..f456f95 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -73,11 +74,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -124,27 +122,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
-if (window.testRunner)
-    testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+window.jsTestIsAsync = true;
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        finishJSTest();
     }, function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+        testFailed("");
+        finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index 6e1668a..4882f90 100644 (file)
@@ -1,12 +1,5 @@
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
 
index 130ac66..f47b06c 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -85,11 +86,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -136,27 +134,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
-if (window.testRunner)
-    testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+window.jsTestIsAsync = true;
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        finishJSTest();
     }, function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+        testFailed("");
+        finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 92d2ac3..fd5f18c 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -36,10 +37,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -106,7 +107,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -129,14 +129,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index c0a4b71..74b1181 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -64,10 +65,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -134,7 +135,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -157,14 +157,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index a935cf8..4882f90 100644 (file)
@@ -1,11 +1,4 @@
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index d692457..f30a7ec 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -47,11 +48,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     }
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -98,24 +96,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index a935cf8..4882f90 100644 (file)
@@ -1,11 +1,4 @@
-PASS resultsFloat32Array[0] is 2
-PASS resultsFloat32Array[1] is 4
-PASS resultsFloat32Array[2] is 6
-PASS resultsFloat32Array[3] is 8
-PASS resultsFloat32Array[4] is 5
-PASS resultsFloat32Array[5] is 6
-PASS resultsFloat32Array[6] is 7
-PASS resultsFloat32Array[7] is 8
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 31760d7..bfb2629 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -14,11 +15,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
         buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -65,24 +63,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "2");
-    shouldBe("resultsFloat32Array[1]", "4");
-    shouldBe("resultsFloat32Array[2]", "6");
-    shouldBe("resultsFloat32Array[3]", "8");
-    shouldBe("resultsFloat32Array[4]", "5");
-    shouldBe("resultsFloat32Array[5]", "6");
-    shouldBe("resultsFloat32Array[6]", "7");
-    shouldBe("resultsFloat32Array[7]", "8");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 2
+        && resultsFloat32Array[1] == 4
+        && resultsFloat32Array[2] == 6
+        && resultsFloat32Array[3] == 8
+        && resultsFloat32Array[4] == 5
+        && resultsFloat32Array[5] == 6
+        && resultsFloat32Array[6] == 7
+        && resultsFloat32Array[7] == 8)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index 70d961e..4882f90 100644 (file)
@@ -1,11 +1,4 @@
-PASS results[0] is 2
-PASS results[1] is 1
-PASS results[2] is 2
-PASS results[3] is 2
-PASS results[4] is 6
-PASS results[5] is 7
-PASS results[6] is 34
-PASS results[7] is 59
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index d3b7238..e7a7561 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -32,11 +33,8 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     buffer[uint(threadID.x)] = mat[0][0];
 }
 `;
-let resultsFloat32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -76,20 +74,24 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsFloat32Array = new Float32Array(resultsArrayBuffer);
-    shouldBe("resultsFloat32Array[0]", "66");
+    const resultsFloat32Array = new Float32Array(resultsArrayBuffer);
+    if (resultsFloat32Array[0] == 66)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
-if (window.testRunner)
-    testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+window.jsTestIsAsync = true;
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        finishJSTest();
     }, function() {
-        if (window.testRunner)
-            testRunner.notifyDone();
+        testFailed("");
+        finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index 118eacc..67f1b11 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -33,7 +34,7 @@ compute void computeShader(device int[] buffer : register(u0)) {
     buffer[7] = total;
 }
 `;
-let results;
+
 async function start() {
     const adapter = await navigator.gpu.requestAdapter();
     const device = await adapter.requestDevice();
@@ -69,24 +70,31 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await buffer.mapReadAsync();
-    results = new Int32Array(resultsArrayBuffer);
-    shouldBe("results[0]", "2");
-    shouldBe("results[1]", "1");
-    shouldBe("results[2]", "2");
-    shouldBe("results[3]", "2");
-    shouldBe("results[4]", "6");
-    shouldBe("results[5]", "7");
-    shouldBe("results[6]", "34");
-    shouldBe("results[7]", "59");
+    const results = new Int32Array(resultsArrayBuffer);
+    if (results[0] == 2
+        && results[1] == 1
+        && results[2] == 2
+        && results[3] == 2
+        && results[4] == 6
+        && results[5] == 7
+        && results[6] == 34
+        && results[7] == 59)
+        testPassed("");
+    else
+        testFailed("");
     buffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 9e4375f..8c3e356 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -29,10 +30,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -99,7 +100,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -122,14 +122,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index a6eb251..0e4d55c 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -44,10 +45,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -114,7 +115,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -137,14 +137,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 794166f..4882f90 100644 (file)
@@ -1,6 +1,4 @@
-PASS resultsUint32Array[0] is 2
-PASS resultsUint32Array[1] is 2
-PASS resultsUint32Array[2] is 1
+PASS 
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 1a80f7e..19f12f8 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -17,11 +18,8 @@ compute void computeShader(Texture2D<float4> theTexture : register(t0), device u
     theBuffer[2] = numberOfLevels;
 }
 `;
-let resultsUint32Array;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};
 
@@ -55,19 +53,26 @@ async function start() {
     device.getQueue().submit([commandBuffer]);
 
     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
-    resultsUint32Array = new Uint32Array(resultsArrayBuffer);
-    shouldBe("resultsUint32Array[0]", "2");
-    shouldBe("resultsUint32Array[1]", "2");
-    shouldBe("resultsUint32Array[2]", "1");
+    const resultsUint32Array = new Uint32Array(resultsArrayBuffer);
+    if (resultsUint32Array[0] == 2
+        && resultsUint32Array[1] == 2
+        && resultsUint32Array[2] == 1)
+        testPassed("");
+    else
+        testFailed("");
     resultsBuffer.unmap();
 }
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         finishJSTest();
-    }, function(e) {
+    }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index edcd4e2..914fe0f 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -14,10 +15,10 @@ fragment float4 fragmentShader(Texture2D<float4> theTexture : register(t0)) : SV
     return Load(theTexture, int2(0, 0));
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -93,7 +94,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: bindGroupBindings};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -125,7 +125,19 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", start);
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
+});
 </script>
 </body>
 </html>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 2dffb00..1345e47 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -14,10 +15,10 @@ fragment float4 fragmentShader(Texture2D<float4> theTexture : register(t0), samp
     return Sample(theTexture, theSampler, float2(0.5, 0.5));
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -96,7 +97,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: bindGroupBindings};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -128,7 +128,19 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", start);
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    }, function() {
+        if (window.testRunner)
+            testRunner.notifyDone();
+    });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
+});
 </script>
 </body>
 </html>
index 9f96c90..0be852f 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -11,7 +12,7 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     float4 vec = float4(x,x,x,x);
 }
 `;
-let resultsFloat32Array;
+
 async function start() {
     const adapter = await navigator.gpu.requestAdapter();
     const device = await adapter.requestDevice();
@@ -26,16 +27,20 @@ async function start() {
 
     const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
     const computePipeline = device.createComputePipeline(computePipelineDescriptor);
-
-    testPassed("Should not crash.");
 }
+
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+        testPassed("");
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index 1470dc5..aa7cd62 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
@@ -14,7 +15,7 @@ compute void computeShader(device float[] buffer : register(u0), float3 threadID
     }
 }
 `;
-let resultsFloat32Array;
+
 async function start() {
     const adapter = await navigator.gpu.requestAdapter();
     const device = await adapter.requestDevice();
@@ -29,16 +30,20 @@ async function start() {
 
     const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
     const computePipeline = device.createComputePipeline(computePipelineDescriptor);
-
-    testPassed("Should not crash.");
 }
+
 window.jsTestIsAsync = true;
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
+    testPassed("");
         finishJSTest();
     }, function() {
+        testFailed("");
         finishJSTest();
     });
+}, function() {
+    testPassed("");
+    finishJSTest();
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 49b016f..6906303 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -34,10 +35,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -104,7 +105,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -125,16 +125,21 @@ async function start() {
     const commandBuffer = commandEncoder.finish();
     device.getQueue().submit([commandBuffer]);
 }
+
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f417050..9f53a26 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "white";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index c1fd165..ae7db9a 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -34,10 +35,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -104,7 +105,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -127,14 +127,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 8e73258..10e9d83 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -50,10 +51,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -120,7 +121,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -141,16 +141,21 @@ async function start() {
     const commandBuffer = commandEncoder.finish();
     device.getQueue().submit([commandBuffer]);
 }
+
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index ca6e692..3bf869a 100644 (file)
@@ -1,19 +1,13 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
 <script>
-async function start() {
-    const canvas = document.getElementById("canvas");
-    const context = canvas.getContext("2d");
-    context.fillStyle = "blue";
-    context.fillRect(0, 0, 400, 400);
-    context.fillStyle = "black";
-    context.fillRect(100, 100, 200, 200);
-}
-window.addEventListener("load", start);
+const canvas = document.getElementById("canvas");
+drawBlackSquareOnBlueBackgroundInSoftware(canvas);
 </script>
 </body>
 </html>
index 43ff33d..a12568f 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -33,10 +34,10 @@ fragment float4 fragmentShader(float shade : attribute(0)) : SV_Target 0 {
     return float4(shade, shade, shade, 1.0);
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -103,7 +104,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -124,16 +124,21 @@ async function start() {
     const commandBuffer = commandEncoder.finish();
     device.getQueue().submit([commandBuffer]);
 }
+
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawBlackSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index 676bd06..97ca0dd 100644 (file)
@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
+<script src="js/webgpu-functions.js"></script>
 </head>
 <body>
 <canvas id="canvas" width="400" height="400"></canvas>
@@ -14,10 +15,10 @@ fragment float4 fragmentShader(float4 position : SV_Position) : SV_Target 0 {
     return position;
 }
 `;
-async function start() {
-    const adapter = await navigator.gpu.requestAdapter();
-    const device = await adapter.requestDevice();
 
+const canvas = document.getElementById("canvas");
+
+async function start(device) {
     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
     const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
@@ -87,7 +88,6 @@ async function start() {
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);
 
-    const canvas = document.getElementById("canvas");
     const context = canvas.getContext("gpu");
     const swapChainDescriptor = {device, format: "bgra8unorm"};
     const swapChain = context.configureSwapChain(swapChainDescriptor);
@@ -110,14 +110,18 @@ async function start() {
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
-window.addEventListener("load", function() {
-    start().then(function() {
+getBasicDevice().then(function(device) {
+    start(device).then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
+}, function() {
+    drawWhiteSquareOnBlueBackgroundInSoftware(canvas);
+    if (window.testRunner)
+        testRunner.notifyDone();
 });
 </script>
 </body>
index f6f8108..3697297 100644 (file)
@@ -1,3 +1,12 @@
+2019-06-26  Myles C. Maxfield  <mmaxfield@apple.com>
+
+        REGRESSION: ( r246394 ) webgpu/whlsl-buffer-fragment.html and webgpu/whlsl-buffer-vertex.html are failing
+        https://bugs.webkit.org/show_bug.cgi?id=199012
+
+        Reviewed by Saam Barati.
+
+        * wtf/Platform.h:
+
 2019-06-25  Keith Miller  <keith_miller@apple.com>
 
         CagedPtr doesn't merge PAC bits back into the resulting caged pointer.
index 5a6ef3a..33a4bb8 100644 (file)
 #if PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 130000
 #define USE_UICONTEXTMENU 1
 #endif
+
+#if PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED <= 101300
+#define USE_INTEL_METAL_WORKAROUND 1
+#endif
index 9aa5e2d..73841c0 100644 (file)
@@ -1,3 +1,14 @@
+2019-06-26  Myles C. Maxfield  <mmaxfield@apple.com>
+
+        REGRESSION: ( r246394 ) webgpu/whlsl-buffer-fragment.html and webgpu/whlsl-buffer-vertex.html are failing
+        https://bugs.webkit.org/show_bug.cgi?id=199012
+
+        Reviewed by Saam Barati.
+
+        * platform/graphics/gpu/cocoa/GPUDeviceMetal.mm:
+        (WebCore::isAcceptableDevice):
+        (WebCore::GPUDevice::tryCreate):
+
 2019-06-26  Simon Fraser  <simon.fraser@apple.com>
 
         Incorrect clippping with overflow:scroll inside oveflow:hidden with border-radius
index 9a9aba4..10bc6fb 100644 (file)
                1C09D0581E31C57E00725F18 /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C09D0571E31C57E00725F18 /* config.h */; };
                1C4876D81F8D7F4E00CCEEBD /* Logging.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C4876D61F8D7F4E00CCEEBD /* Logging.cpp */; };
                1C4876D91F8D7F4E00CCEEBD /* Logging.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C4876D71F8D7F4E00CCEEBD /* Logging.h */; };
+               1CC3ACE822BD7EC500F360F0 /* MetalSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CC3ACE722BD7EB800F360F0 /* MetalSPI.h */; };
                1CCEE4F520D871930047B097 /* CoreUISPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CCEE4F420D871930047B097 /* CoreUISPI.h */; };
                1CCEE4F720D8743F0047B097 /* NSAppearanceSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 1CCEE4F620D8743F0047B097 /* NSAppearanceSPI.h */; };
                2D02E93C2056FAA700A13797 /* AudioToolboxSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D02E93B2056FAA700A13797 /* AudioToolboxSPI.h */; };
                1C4876DC1F8D7FC600CCEEBD /* LogMacros.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LogMacros.h; sourceTree = "<group>"; };
                1C67CEA11E32EDA800F80F2E /* FeatureDefines.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FeatureDefines.xcconfig; sourceTree = "<group>"; };
                1C67CEA21E32EE2600F80F2E /* Version.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Version.xcconfig; sourceTree = "<group>"; };
+               1CC3ACE722BD7EB800F360F0 /* MetalSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MetalSPI.h; sourceTree = "<group>"; };
                1CCEE4F420D871930047B097 /* CoreUISPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CoreUISPI.h; sourceTree = "<group>"; };
                1CCEE4F620D8743F0047B097 /* NSAppearanceSPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NSAppearanceSPI.h; sourceTree = "<group>"; };
                2D02E93B2056FAA700A13797 /* AudioToolboxSPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AudioToolboxSPI.h; sourceTree = "<group>"; };
                                0C2DA12A1F3BEB4900DBC317 /* IOTypesSPI.h */,
                                0C5AF9121F43A4C7002EAC02 /* LaunchServicesSPI.h */,
                                0C2DA12C1F3BEB4900DBC317 /* MachVMSPI.h */,
+                               1CC3ACE722BD7EB800F360F0 /* MetalSPI.h */,
                                0C2DA12D1F3BEB4900DBC317 /* NEFilterSourceSPI.h */,
                                0C2DA12E1F3BEB4900DBC317 /* NSAttributedStringSPI.h */,
                                0C2DA12F1F3BEB4900DBC317 /* NSButtonCellSPI.h */,
                                0C5AF91D1F43A4C7002EAC02 /* MediaPlayerSPI.h in Headers */,
                                0C77858C1F45130F00F4EBB6 /* MediaRemoteSPI.h in Headers */,
                                0C00CFD41F68CE4600AAC26D /* MediaTimeAVFoundation.h in Headers */,
+                               1CC3ACE822BD7EC500F360F0 /* MetalSPI.h in Headers */,
                                0C5AF91E1F43A4C7002EAC02 /* MobileGestaltSPI.h in Headers */,
                                0C2DA1491F3BEB4900DBC317 /* NEFilterSourceSPI.h in Headers */,
                                0C77858D1F45130F00F4EBB6 /* NSAccessibilitySPI.h in Headers */,
diff --git a/Source/WebCore/PAL/pal/spi/cocoa/MetalSPI.h b/Source/WebCore/PAL/pal/spi/cocoa/MetalSPI.h
new file mode 100644 (file)
index 0000000..ea0527d
--- /dev/null
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
<