@shopify/react-native-skia 2.11.0 → 2.11.2-next.1

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -63,16 +63,6 @@ public:
 #endif
   }
 
-  std::shared_ptr<WindowContext>
-  makeContextFromNativeSurface(void *surface, int width, int height) override {
-#if defined(SK_GRAPHITE)
-    return DawnContext::getInstance().MakeWindow(surface, width, height);
-#else
-    auto aWindow = reinterpret_cast<ANativeWindow *>(surface);
-    return OpenGLContext::getInstance().MakeWindow(aWindow);
-#endif
-  }
-
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
 #if defined(SK_GRAPHITE)
     return DawnContext::getInstance().MakeImageFromBuffer(buffer);

package/android/src/main/java/com/shopify/reactnative/skia/ViewScreenshotService.java

@@ -19,10 +19,11 @@ import android.widget.ScrollView;
 import androidx.annotation.NonNull;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.UIManager;
+import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.ViewProps;
 import com.facebook.react.views.view.ReactViewGroup;
 
-import java.lang.reflect.Method;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
@@ -118,17 +119,13 @@ public class ViewScreenshotService {
     }
 
     private static void drawChildren(Canvas canvas, ViewGroup group, Paint paint, float parentOpacity) {
-        // Handle clipping for ReactViewGroup
-        if (group instanceof ReactViewGroup) {
-            try {
-                Class[] cArg = new Class[1];
-                cArg[0] = Canvas.class;
-                Method method = ReactViewGroup.class.getDeclaredMethod("dispatchOverflowDraw", cArg);
-                method.setAccessible(true);
-                method.invoke(group, canvas);
-            } catch (Exception e) {
-                Log.e(TAG, "couldn't invoke dispatchOverflowDraw() on ReactViewGroup", e);
-            }
+        // ReactViewGroup applies `overflow: hidden` / `overflow: scroll` clipping from its
+        // dispatchDraw() override. We never call dispatchDraw() here because children are
+        // walked manually (TextureView / SurfaceView need special handling), so the clip has
+        // to be replicated explicitly, exactly as ReactViewGroup.dispatchDraw() does it.
+        if (group instanceof ReactViewGroup
+                && !ViewProps.VISIBLE.equals(((ReactViewGroup) group).getOverflow())) {
+            BackgroundStyleApplicator.clipToPaddingBox(group, canvas);
         }
         for (int i = 0; i < group.getChildCount(); i++) {
             View child = group.getChildAt(i);

package/apple/RNSkApplePlatformContext.h

@@ -63,9 +63,6 @@ public:
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
 
-  std::shared_ptr<WindowContext>
-  makeContextFromNativeSurface(void *surface, int width, int height) override;
-
   virtual void performStreamOperation(
       const std::string &sourceUri,
       const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;

package/apple/RNSkApplePlatformContext.mm

@@ -307,17 +307,6 @@ RNSkApplePlatformContext::createVideo(const std::string &url) {
   return std::make_shared<RNSkAppleVideo>(url, this);
 }
 
-std::shared_ptr<WindowContext>
-RNSkApplePlatformContext::makeContextFromNativeSurface(void *surface, int width,
-                                                       int height) {
-#if defined(SK_GRAPHITE)
-  return DawnContext::getInstance().MakeWindow(surface, width, height);
-#else
-  return MetalContext::getInstance().MakeWindow((__bridge CALayer *)surface,
-                                                width, height);
-#endif
-}
-
 void RNSkApplePlatformContext::raiseError(const std::exception &err) {
   RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
 }

package/cpp/api/JsiSkApi.h

@@ -56,7 +56,6 @@
 #include "JsiSkTypefaceFactory.h"
 #include "JsiSkTypefaceFontProviderFactory.h"
 #include "JsiSkVertices.h"
-#include "JsiSkiaContext.h"
 #include "JsiSkottieFactory.h"
 #include "JsiVideo.h"
 #include "api/recorder/JsiRecorder.h"
@@ -116,10 +115,6 @@ public:
     return JsiVideo::createCtor(getContext())(runtime, thisValue, arguments,
                                               count);
   }
-  JSI_HOST_FUNCTION(Context) {
-    return JsiSkiaContext::createCtor(getContext())(runtime, thisValue,
-                                                    arguments, count);
-  }
   JSI_HOST_FUNCTION(Font) {
     return JsiSkFont::createCtor(getContext())(runtime, thisValue, arguments,
                                                count);
@@ -256,7 +251,6 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installHostMethod(runtime, prototype, "Video", &JsiSkApi::Video);
-    installHostMethod(runtime, prototype, "Context", &JsiSkApi::Context);
     installHostMethod(runtime, prototype, "getNativeDevice",
                       &JsiSkApi::getNativeDevice);
     installHostMethod(runtime, prototype, "Font", &JsiSkApi::Font);

package/cpp/api/JsiSkFont.h

@@ -135,8 +135,9 @@ public:
   bool isEmbolden() { return getObject()->isEmbolden(); }
 
   std::shared_ptr<JsiSkTypeface> getTypeface() {
-    return std::make_shared<JsiSkTypeface>(
-        getContext(), sk_sp<SkTypeface>(getObject()->getTypeface()));
+    // refTypeface(), not getTypeface(): the wrapper owns what it is handed.
+    return std::make_shared<JsiSkTypeface>(getContext(),
+                                           getObject()->refTypeface());
   }
 
   void setEdging(double edging) {
@@ -161,15 +162,9 @@ public:
 
   void setSize(double size) { getObject()->setSize(size); }
 
-  // The JS API declares booleans here, but the previous implementation read
-  // the arguments with asNumber() — keep accepting numbers.
-  void setEmbolden(double embolden) {
-    getObject()->setEmbolden(static_cast<bool>(embolden));
-  }
+  void setEmbolden(bool embolden) { getObject()->setEmbolden(embolden); }
 
-  void setSubpixel(double subpixel) {
-    getObject()->setSubpixel(static_cast<bool>(subpixel));
-  }
+  void setSubpixel(bool subpixel) { getObject()->setSubpixel(subpixel); }
 
   void setTypeface(std::variant<std::nullptr_t, sk_sp<SkTypeface>> typeface) {
     getObject()->setTypeface(

package/cpp/api/JsiSkMatrix.h

@@ -69,12 +69,14 @@ public:
 
   void postTranslate(double x, double y) { getObject()->postTranslate(x, y); }
 
+  // A missing y means a uniform scale, matching the CanvasKit backend and the
+  // SkMatrix type, where y is optional rather than defaulted to 1.
   void scale(double x, JsiOptional<double> y) {
-    getObject()->preScale(x, y.has_value() ? *y : 1);
+    getObject()->preScale(x, y.has_value() ? *y : x);
   }
 
   void postScale(double x, JsiOptional<double> y) {
-    getObject()->postScale(x, y.has_value() ? *y : 1);
+    getObject()->postScale(x, y.has_value() ? *y : x);
   }
 
   void skew(double x, double y) { getObject()->preSkew(x, y); }

package/cpp/api/recorder/Convertor.h

@@ -361,13 +361,16 @@ SkM44 getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
         m4.preScale(1, s);
       } else if (key == "skewX") {
         auto angle = value.getProperty(runtime, key.c_str()).asNumber();
-        SkM44 skewX(1, 0, 0, 0, std::tan(angle), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+        // The SkM44 constructor takes its arguments in row-major reading
+        // order, so the shear factor of a horizontal skew belongs in row 0,
+        // where it scales y into x.
+        SkM44 skewX(1, std::tan(angle), 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
                     1);
         m4.preConcat(skewX);
 
       } else if (key == "skewY") {
         auto angle = value.getProperty(runtime, key.c_str()).asNumber();
-        SkM44 skewY(1, std::tan(angle), 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+        SkM44 skewY(1, 0, 0, 0, std::tan(angle), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
                     1);
         m4.preConcat(skewY);
       } else if (key == "rotate" || key == "rotateZ") {

package/cpp/api/recorder/Drawings.h

@@ -149,6 +149,9 @@ public:
       if (hasStrokeOptions) {
         const auto &stroke = props.stroke.value();
         SkPaint strokePaint;
+        // A default SkPaint is fill-style, and FillPathWithPaint only
+        // outlines a paint that strokes.
+        strokePaint.setStyle(SkPaint::kStroke_Style);
 
         if (stroke.cap.has_value()) {
           strokePaint.setStrokeCap(stroke.cap.value());
@@ -166,11 +169,18 @@ public:
           strokePaint.setStrokeMiter(stroke.miter_limit.value());
         }
 
+        float precision = stroke.precision.value_or(1.0f);
+
         SkPathBuilder resultBuilder;
-        if (!skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder)) {
-          throw std::runtime_error("Failed to apply stroke to path");
+        auto ctm = SkMatrix::Scale(precision, precision);
+        if (skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder,
+                                           nullptr, ctm)) {
+          pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
+        } else {
+          // The JS player keeps the unstroked path when Path.Stroke returns
+          // null (e.g. a hairline width of 0).
+          pathToUse = std::const_pointer_cast<const SkPath>(p);
         }
-        pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
       } else {
         pathToUse = std::const_pointer_cast<const SkPath>(p);
       }

package/cpp/api/recorder/ImageFilters.h

@@ -135,8 +135,22 @@ private:
     auto sourceAlpha = SkImageFilters::ColorFilter(
         SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kSrcIn), nullptr);
 
+    // The shadow is generated outside the shape and then clipped back into it,
+    // so "outside" has to be the complement of the shape's silhouette. Taking
+    // SrcOut against the source graphic itself makes it the complement of the
+    // source's *alpha*: inside a translucent shape 1 - alpha is non-zero, so
+    // the shadow is generated across the whole interior and tints it, no matter
+    // how small the blur and the offset are (issue #2990). Saturating alpha
+    // first keeps the shadow tied to the shape's outline instead of to its
+    // opacity. 255 is the saturation point of an 8-bit alpha channel, so one
+    // unit of coverage is enough to reach 1.
+    static constexpr float kAlphaSaturate[20] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0};
+    auto coverage = SkImageFilters::ColorFilter(
+        SkColorFilters::Matrix(kAlphaSaturate), nullptr);
+
     auto f1 = SkImageFilters::ColorFilter(
-        SkColorFilters::Blend(color, SkBlendMode::kSrcOut), nullptr);
+        SkColorFilters::Blend(color, SkBlendMode::kSrcOut), coverage);
 
     auto f2 = SkImageFilters::Offset(dx, dy, f1);
     auto f3 = SkImageFilters::Blur(sigmaX, sigmaY, SkTileMode::kDecal, f2);

package/cpp/api/recorder/Paint.h

@@ -154,8 +154,15 @@ public:
     }
     ctx->savePaint();
     if (standalone) {
+      // Reset the paint that savePaint() just pushed instead of pushing a
+      // second one: the matching RestorePaintDeclaration pops a single frame,
+      // so an extra push would leave the enclosing group's opacity on the
+      // stack and leak it onto every sibling drawn afterwards. The fresh
+      // paint is anti-aliased to match the TS player, which resets with
+      // Skia.Paint().
       SkPaint freshPaint;
-      ctx->pushPaint(freshPaint);
+      freshPaint.setAntiAlias(true);
+      ctx->getPaint() = freshPaint;
     }
     auto &paint = ctx->getPaint();
     if (props.opacity.has_value()) {

package/cpp/dawn/include/dawn/dawn_proc.h

@@ -0,0 +1,53 @@
+// Copyright 2019 The Dawn & Tint Authors
+//
+// 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.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_DAWN_DAWN_PROC_H_
+#define INCLUDE_DAWN_DAWN_PROC_H_
+
+#include <webgpu/webgpu.h>
+
+#include "dawn/dawn_proc_table.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Sets the static proctable used by libdawn_proc to implement the Dawn entrypoints. Passing NULL
+// for `procs` sets up the null proctable that contains only null function pointers. It is the
+// default value of the proctable. Setting the proctable back to null is good practice when you
+// are done using libdawn_proc since further usage will cause a segfault instead of calling an
+// unexpected function.
+WGPU_EXPORT void dawnProcSetProcs(const DawnProcTable* procs);
+
+// Returns the static array of uint8_t of size 20 representing the Dawn version.
+WGPU_EXPORT const uint8_t* dawnProcGetVersion();
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // INCLUDE_DAWN_DAWN_PROC_H_

package/cpp/dawn/include/dawn/dawn_proc_table.h

@@ -0,0 +1,330 @@
+
+#ifndef DAWN_DAWN_PROC_TABLE_H_
+#define DAWN_DAWN_PROC_TABLE_H_
+
+#include "webgpu/webgpu.h"
+
+// Note: Often allocated as a static global. Do not add a complex constructor.
+typedef struct DawnProcTable {
+    uint8_t version[20];
+
+    WGPUProcCreateInstance createInstance;
+    WGPUProcGetInstanceFeatures getInstanceFeatures;
+    WGPUProcGetInstanceLimits getInstanceLimits;
+    WGPUProcHasInstanceFeature hasInstanceFeature;
+    WGPUProcGetProcAddress getProcAddress;
+
+    WGPUProcAdapterCreateDevice adapterCreateDevice;
+    WGPUProcAdapterGetFeatures adapterGetFeatures;
+    WGPUProcAdapterGetFormatCapabilities adapterGetFormatCapabilities;
+    WGPUProcAdapterGetInfo adapterGetInfo;
+    WGPUProcAdapterGetInstance adapterGetInstance;
+    WGPUProcAdapterGetLimits adapterGetLimits;
+    WGPUProcAdapterHasFeature adapterHasFeature;
+    WGPUProcAdapterRequestDevice adapterRequestDevice;
+    WGPUProcAdapterAddRef adapterAddRef;
+    WGPUProcAdapterRelease adapterRelease;
+
+    WGPUProcAdapterInfoFreeMembers adapterInfoFreeMembers;
+
+    WGPUProcAdapterPropertiesMemoryHeapsFreeMembers adapterPropertiesMemoryHeapsFreeMembers;
+
+    WGPUProcAdapterPropertiesSubgroupMatrixConfigsFreeMembers adapterPropertiesSubgroupMatrixConfigsFreeMembers;
+
+    WGPUProcBindGroupSetLabel bindGroupSetLabel;
+    WGPUProcBindGroupAddRef bindGroupAddRef;
+    WGPUProcBindGroupRelease bindGroupRelease;
+
+    WGPUProcBindGroupLayoutSetLabel bindGroupLayoutSetLabel;
+    WGPUProcBindGroupLayoutAddRef bindGroupLayoutAddRef;
+    WGPUProcBindGroupLayoutRelease bindGroupLayoutRelease;
+
+    WGPUProcBufferCreateTexelView bufferCreateTexelView;
+    WGPUProcBufferDestroy bufferDestroy;
+    WGPUProcBufferGetConstMappedRange bufferGetConstMappedRange;
+    WGPUProcBufferGetMappedRange bufferGetMappedRange;
+    WGPUProcBufferGetMapState bufferGetMapState;
+    WGPUProcBufferGetSize bufferGetSize;
+    WGPUProcBufferGetUsage bufferGetUsage;
+    WGPUProcBufferMapAsync bufferMapAsync;
+    WGPUProcBufferReadMappedRange bufferReadMappedRange;
+    WGPUProcBufferSetLabel bufferSetLabel;
+    WGPUProcBufferUnmap bufferUnmap;
+    WGPUProcBufferWriteMappedRange bufferWriteMappedRange;
+    WGPUProcBufferAddRef bufferAddRef;
+    WGPUProcBufferRelease bufferRelease;
+
+    WGPUProcCommandBufferSetLabel commandBufferSetLabel;
+    WGPUProcCommandBufferAddRef commandBufferAddRef;
+    WGPUProcCommandBufferRelease commandBufferRelease;
+
+    WGPUProcCommandEncoderBeginComputePass commandEncoderBeginComputePass;
+    WGPUProcCommandEncoderBeginRenderPass commandEncoderBeginRenderPass;
+    WGPUProcCommandEncoderClearBuffer commandEncoderClearBuffer;
+    WGPUProcCommandEncoderCopyBufferToBuffer commandEncoderCopyBufferToBuffer;
+    WGPUProcCommandEncoderCopyBufferToTexture commandEncoderCopyBufferToTexture;
+    WGPUProcCommandEncoderCopyTextureToBuffer commandEncoderCopyTextureToBuffer;
+    WGPUProcCommandEncoderCopyTextureToTexture commandEncoderCopyTextureToTexture;
+    WGPUProcCommandEncoderFinish commandEncoderFinish;
+    WGPUProcCommandEncoderInjectValidationError commandEncoderInjectValidationError;
+    WGPUProcCommandEncoderInsertDebugMarker commandEncoderInsertDebugMarker;
+    WGPUProcCommandEncoderPopDebugGroup commandEncoderPopDebugGroup;
+    WGPUProcCommandEncoderPushDebugGroup commandEncoderPushDebugGroup;
+    WGPUProcCommandEncoderResolveQuerySet commandEncoderResolveQuerySet;
+    WGPUProcCommandEncoderSetLabel commandEncoderSetLabel;
+    WGPUProcCommandEncoderWriteBuffer commandEncoderWriteBuffer;
+    WGPUProcCommandEncoderWriteTimestamp commandEncoderWriteTimestamp;
+    WGPUProcCommandEncoderAddRef commandEncoderAddRef;
+    WGPUProcCommandEncoderRelease commandEncoderRelease;
+
+    WGPUProcComputePassEncoderDispatchWorkgroups computePassEncoderDispatchWorkgroups;
+    WGPUProcComputePassEncoderDispatchWorkgroupsIndirect computePassEncoderDispatchWorkgroupsIndirect;
+    WGPUProcComputePassEncoderEnd computePassEncoderEnd;
+    WGPUProcComputePassEncoderInsertDebugMarker computePassEncoderInsertDebugMarker;
+    WGPUProcComputePassEncoderPopDebugGroup computePassEncoderPopDebugGroup;
+    WGPUProcComputePassEncoderPushDebugGroup computePassEncoderPushDebugGroup;
+    WGPUProcComputePassEncoderSetBindGroup computePassEncoderSetBindGroup;
+    WGPUProcComputePassEncoderSetImmediates computePassEncoderSetImmediates;
+    WGPUProcComputePassEncoderSetLabel computePassEncoderSetLabel;
+    WGPUProcComputePassEncoderSetPipeline computePassEncoderSetPipeline;
+    WGPUProcComputePassEncoderSetResourceTable computePassEncoderSetResourceTable;
+    WGPUProcComputePassEncoderWriteTimestamp computePassEncoderWriteTimestamp;
+    WGPUProcComputePassEncoderAddRef computePassEncoderAddRef;
+    WGPUProcComputePassEncoderRelease computePassEncoderRelease;
+
+    WGPUProcComputePipelineGetBindGroupLayout computePipelineGetBindGroupLayout;
+    WGPUProcComputePipelineSetLabel computePipelineSetLabel;
+    WGPUProcComputePipelineAddRef computePipelineAddRef;
+    WGPUProcComputePipelineRelease computePipelineRelease;
+
+    WGPUProcDawnDrmFormatCapabilitiesFreeMembers dawnDrmFormatCapabilitiesFreeMembers;
+
+    WGPUProcDeviceCreateBindGroup deviceCreateBindGroup;
+    WGPUProcDeviceCreateBindGroupLayout deviceCreateBindGroupLayout;
+    WGPUProcDeviceCreateBuffer deviceCreateBuffer;
+    WGPUProcDeviceCreateCommandEncoder deviceCreateCommandEncoder;
+    WGPUProcDeviceCreateComputePipeline deviceCreateComputePipeline;
+    WGPUProcDeviceCreateComputePipelineAsync deviceCreateComputePipelineAsync;
+    WGPUProcDeviceCreateErrorBuffer deviceCreateErrorBuffer;
+    WGPUProcDeviceCreateErrorComputePipeline deviceCreateErrorComputePipeline;
+    WGPUProcDeviceCreateErrorExternalTexture deviceCreateErrorExternalTexture;
+    WGPUProcDeviceCreateErrorRenderPipeline deviceCreateErrorRenderPipeline;
+    WGPUProcDeviceCreateErrorShaderModule deviceCreateErrorShaderModule;
+    WGPUProcDeviceCreateErrorTexture deviceCreateErrorTexture;
+    WGPUProcDeviceCreateExternalTexture deviceCreateExternalTexture;
+    WGPUProcDeviceCreatePipelineLayout deviceCreatePipelineLayout;
+    WGPUProcDeviceCreateQuerySet deviceCreateQuerySet;
+    WGPUProcDeviceCreateRenderBundleEncoder deviceCreateRenderBundleEncoder;
+    WGPUProcDeviceCreateRenderPipeline deviceCreateRenderPipeline;
+    WGPUProcDeviceCreateRenderPipelineAsync deviceCreateRenderPipelineAsync;
+    WGPUProcDeviceCreateResourceTable deviceCreateResourceTable;
+    WGPUProcDeviceCreateSampler deviceCreateSampler;
+    WGPUProcDeviceCreateShaderModule deviceCreateShaderModule;
+    WGPUProcDeviceCreateTexture deviceCreateTexture;
+    WGPUProcDeviceDestroy deviceDestroy;
+    WGPUProcDeviceForceLoss deviceForceLoss;
+    WGPUProcDeviceGetAdapter deviceGetAdapter;
+    WGPUProcDeviceGetAdapterInfo deviceGetAdapterInfo;
+    WGPUProcDeviceGetAHardwareBufferProperties deviceGetAHardwareBufferProperties;
+    WGPUProcDeviceGetFeatures deviceGetFeatures;
+    WGPUProcDeviceGetLimits deviceGetLimits;
+    WGPUProcDeviceGetLostFuture deviceGetLostFuture;
+    WGPUProcDeviceGetQueue deviceGetQueue;
+    WGPUProcDeviceHasFeature deviceHasFeature;
+    WGPUProcDeviceImportSharedBufferMemory deviceImportSharedBufferMemory;
+    WGPUProcDeviceImportSharedFence deviceImportSharedFence;
+    WGPUProcDeviceImportSharedTextureMemory deviceImportSharedTextureMemory;
+    WGPUProcDeviceInjectError deviceInjectError;
+    WGPUProcDevicePopErrorScope devicePopErrorScope;
+    WGPUProcDevicePushErrorScope devicePushErrorScope;
+    WGPUProcDeviceSetLabel deviceSetLabel;
+    WGPUProcDeviceSetLoggingCallback deviceSetLoggingCallback;
+    WGPUProcDeviceTick deviceTick;
+    WGPUProcDeviceValidateTextureDescriptor deviceValidateTextureDescriptor;
+    WGPUProcDeviceAddRef deviceAddRef;
+    WGPUProcDeviceRelease deviceRelease;
+
+    WGPUProcExternalTextureDestroy externalTextureDestroy;
+    WGPUProcExternalTextureExpire externalTextureExpire;
+    WGPUProcExternalTextureRefresh externalTextureRefresh;
+    WGPUProcExternalTextureSetLabel externalTextureSetLabel;
+    WGPUProcExternalTextureAddRef externalTextureAddRef;
+    WGPUProcExternalTextureRelease externalTextureRelease;
+
+    WGPUProcInstanceCreateSurface instanceCreateSurface;
+    WGPUProcInstanceGetWGSLLanguageFeatures instanceGetWGSLLanguageFeatures;
+    WGPUProcInstanceHasWGSLLanguageFeature instanceHasWGSLLanguageFeature;
+    WGPUProcInstanceProcessEvents instanceProcessEvents;
+    WGPUProcInstanceRequestAdapter instanceRequestAdapter;
+    WGPUProcInstanceWaitAny instanceWaitAny;
+    WGPUProcInstanceAddRef instanceAddRef;
+    WGPUProcInstanceRelease instanceRelease;
+
+    WGPUProcPipelineLayoutSetLabel pipelineLayoutSetLabel;
+    WGPUProcPipelineLayoutAddRef pipelineLayoutAddRef;
+    WGPUProcPipelineLayoutRelease pipelineLayoutRelease;
+
+    WGPUProcQuerySetDestroy querySetDestroy;
+    WGPUProcQuerySetGetCount querySetGetCount;
+    WGPUProcQuerySetGetType querySetGetType;
+    WGPUProcQuerySetSetLabel querySetSetLabel;
+    WGPUProcQuerySetAddRef querySetAddRef;
+    WGPUProcQuerySetRelease querySetRelease;
+
+    WGPUProcQueueCopyExternalTextureForBrowser queueCopyExternalTextureForBrowser;
+    WGPUProcQueueCopyTextureForBrowser queueCopyTextureForBrowser;
+    WGPUProcQueueOnSubmittedWorkDone queueOnSubmittedWorkDone;
+    WGPUProcQueueSetLabel queueSetLabel;
+    WGPUProcQueueSubmit queueSubmit;
+    WGPUProcQueueWriteBuffer queueWriteBuffer;
+    WGPUProcQueueWriteTexture queueWriteTexture;
+    WGPUProcQueueAddRef queueAddRef;
+    WGPUProcQueueRelease queueRelease;
+
+    WGPUProcRenderBundleSetLabel renderBundleSetLabel;
+    WGPUProcRenderBundleAddRef renderBundleAddRef;
+    WGPUProcRenderBundleRelease renderBundleRelease;
+
+    WGPUProcRenderBundleEncoderDraw renderBundleEncoderDraw;
+    WGPUProcRenderBundleEncoderDrawIndexed renderBundleEncoderDrawIndexed;
+    WGPUProcRenderBundleEncoderDrawIndexedIndirect renderBundleEncoderDrawIndexedIndirect;
+    WGPUProcRenderBundleEncoderDrawIndirect renderBundleEncoderDrawIndirect;
+    WGPUProcRenderBundleEncoderFinish renderBundleEncoderFinish;
+    WGPUProcRenderBundleEncoderInsertDebugMarker renderBundleEncoderInsertDebugMarker;
+    WGPUProcRenderBundleEncoderPopDebugGroup renderBundleEncoderPopDebugGroup;
+    WGPUProcRenderBundleEncoderPushDebugGroup renderBundleEncoderPushDebugGroup;
+    WGPUProcRenderBundleEncoderSetBindGroup renderBundleEncoderSetBindGroup;
+    WGPUProcRenderBundleEncoderSetImmediates renderBundleEncoderSetImmediates;
+    WGPUProcRenderBundleEncoderSetIndexBuffer renderBundleEncoderSetIndexBuffer;
+    WGPUProcRenderBundleEncoderSetLabel renderBundleEncoderSetLabel;
+    WGPUProcRenderBundleEncoderSetPipeline renderBundleEncoderSetPipeline;
+    WGPUProcRenderBundleEncoderSetResourceTable renderBundleEncoderSetResourceTable;
+    WGPUProcRenderBundleEncoderSetVertexBuffer renderBundleEncoderSetVertexBuffer;
+    WGPUProcRenderBundleEncoderAddRef renderBundleEncoderAddRef;
+    WGPUProcRenderBundleEncoderRelease renderBundleEncoderRelease;
+
+    WGPUProcRenderPassEncoderBeginOcclusionQuery renderPassEncoderBeginOcclusionQuery;
+    WGPUProcRenderPassEncoderDraw renderPassEncoderDraw;
+    WGPUProcRenderPassEncoderDrawIndexed renderPassEncoderDrawIndexed;
+    WGPUProcRenderPassEncoderDrawIndexedIndirect renderPassEncoderDrawIndexedIndirect;
+    WGPUProcRenderPassEncoderDrawIndirect renderPassEncoderDrawIndirect;
+    WGPUProcRenderPassEncoderEnd renderPassEncoderEnd;
+    WGPUProcRenderPassEncoderEndOcclusionQuery renderPassEncoderEndOcclusionQuery;
+    WGPUProcRenderPassEncoderExecuteBundles renderPassEncoderExecuteBundles;
+    WGPUProcRenderPassEncoderInsertDebugMarker renderPassEncoderInsertDebugMarker;
+    WGPUProcRenderPassEncoderMultiDrawIndexedIndirect renderPassEncoderMultiDrawIndexedIndirect;
+    WGPUProcRenderPassEncoderMultiDrawIndirect renderPassEncoderMultiDrawIndirect;
+    WGPUProcRenderPassEncoderPixelLocalStorageBarrier renderPassEncoderPixelLocalStorageBarrier;
+    WGPUProcRenderPassEncoderPopDebugGroup renderPassEncoderPopDebugGroup;
+    WGPUProcRenderPassEncoderPushDebugGroup renderPassEncoderPushDebugGroup;
+    WGPUProcRenderPassEncoderSetBindGroup renderPassEncoderSetBindGroup;
+    WGPUProcRenderPassEncoderSetBlendConstant renderPassEncoderSetBlendConstant;
+    WGPUProcRenderPassEncoderSetImmediates renderPassEncoderSetImmediates;
+    WGPUProcRenderPassEncoderSetIndexBuffer renderPassEncoderSetIndexBuffer;
+    WGPUProcRenderPassEncoderSetLabel renderPassEncoderSetLabel;
+    WGPUProcRenderPassEncoderSetPipeline renderPassEncoderSetPipeline;
+    WGPUProcRenderPassEncoderSetResourceTable renderPassEncoderSetResourceTable;
+    WGPUProcRenderPassEncoderSetScissorRect renderPassEncoderSetScissorRect;
+    WGPUProcRenderPassEncoderSetStencilReference renderPassEncoderSetStencilReference;
+    WGPUProcRenderPassEncoderSetVertexBuffer renderPassEncoderSetVertexBuffer;
+    WGPUProcRenderPassEncoderSetViewport renderPassEncoderSetViewport;
+    WGPUProcRenderPassEncoderWriteTimestamp renderPassEncoderWriteTimestamp;
+    WGPUProcRenderPassEncoderAddRef renderPassEncoderAddRef;
+    WGPUProcRenderPassEncoderRelease renderPassEncoderRelease;
+
+    WGPUProcRenderPipelineGetBindGroupLayout renderPipelineGetBindGroupLayout;
+    WGPUProcRenderPipelineSetLabel renderPipelineSetLabel;
+    WGPUProcRenderPipelineAddRef renderPipelineAddRef;
+    WGPUProcRenderPipelineRelease renderPipelineRelease;
+
+    WGPUProcResourceTableDestroy resourceTableDestroy;
+    WGPUProcResourceTableGetSize resourceTableGetSize;
+    WGPUProcResourceTableInsert resourceTableInsert;
+    WGPUProcResourceTableRemove resourceTableRemove;
+    WGPUProcResourceTableSetLabel resourceTableSetLabel;
+    WGPUProcResourceTableUpdate resourceTableUpdate;
+    WGPUProcResourceTableAddRef resourceTableAddRef;
+    WGPUProcResourceTableRelease resourceTableRelease;
+
+    WGPUProcSamplerSetLabel samplerSetLabel;
+    WGPUProcSamplerAddRef samplerAddRef;
+    WGPUProcSamplerRelease samplerRelease;
+
+    WGPUProcShaderModuleGetCompilationInfo shaderModuleGetCompilationInfo;
+    WGPUProcShaderModuleSetLabel shaderModuleSetLabel;
+    WGPUProcShaderModuleAddRef shaderModuleAddRef;
+    WGPUProcShaderModuleRelease shaderModuleRelease;
+
+    WGPUProcSharedBufferMemoryBeginAccess sharedBufferMemoryBeginAccess;
+    WGPUProcSharedBufferMemoryCreateBuffer sharedBufferMemoryCreateBuffer;
+    WGPUProcSharedBufferMemoryEndAccess sharedBufferMemoryEndAccess;
+    WGPUProcSharedBufferMemoryGetProperties sharedBufferMemoryGetProperties;
+    WGPUProcSharedBufferMemoryIsDeviceLost sharedBufferMemoryIsDeviceLost;
+    WGPUProcSharedBufferMemorySetLabel sharedBufferMemorySetLabel;
+    WGPUProcSharedBufferMemoryAddRef sharedBufferMemoryAddRef;
+    WGPUProcSharedBufferMemoryRelease sharedBufferMemoryRelease;
+
+    WGPUProcSharedBufferMemoryEndAccessStateFreeMembers sharedBufferMemoryEndAccessStateFreeMembers;
+
+    WGPUProcSharedFenceExportInfo sharedFenceExportInfo;
+    WGPUProcSharedFenceSetLabel sharedFenceSetLabel;
+    WGPUProcSharedFenceAddRef sharedFenceAddRef;
+    WGPUProcSharedFenceRelease sharedFenceRelease;
+
+    WGPUProcSharedTextureMemoryBeginAccess sharedTextureMemoryBeginAccess;
+    WGPUProcSharedTextureMemoryCreateTexture sharedTextureMemoryCreateTexture;
+    WGPUProcSharedTextureMemoryEndAccess sharedTextureMemoryEndAccess;
+    WGPUProcSharedTextureMemoryGetProperties sharedTextureMemoryGetProperties;
+    WGPUProcSharedTextureMemoryIsDeviceLost sharedTextureMemoryIsDeviceLost;
+    WGPUProcSharedTextureMemorySetLabel sharedTextureMemorySetLabel;
+    WGPUProcSharedTextureMemoryAddRef sharedTextureMemoryAddRef;
+    WGPUProcSharedTextureMemoryRelease sharedTextureMemoryRelease;
+
+    WGPUProcSharedTextureMemoryEndAccessStateFreeMembers sharedTextureMemoryEndAccessStateFreeMembers;
+
+    WGPUProcSupportedFeaturesFreeMembers supportedFeaturesFreeMembers;
+
+    WGPUProcSupportedInstanceFeaturesFreeMembers supportedInstanceFeaturesFreeMembers;
+
+    WGPUProcSupportedWGSLLanguageFeaturesFreeMembers supportedWGSLLanguageFeaturesFreeMembers;
+
+    WGPUProcSurfaceConfigure surfaceConfigure;
+    WGPUProcSurfaceGetCapabilities surfaceGetCapabilities;
+    WGPUProcSurfaceGetCurrentTexture surfaceGetCurrentTexture;
+    WGPUProcSurfacePresent surfacePresent;
+    WGPUProcSurfaceSetLabel surfaceSetLabel;
+    WGPUProcSurfaceUnconfigure surfaceUnconfigure;
+    WGPUProcSurfaceAddRef surfaceAddRef;
+    WGPUProcSurfaceRelease surfaceRelease;
+
+    WGPUProcSurfaceCapabilitiesFreeMembers surfaceCapabilitiesFreeMembers;
+
+    WGPUProcTexelBufferViewSetLabel texelBufferViewSetLabel;
+    WGPUProcTexelBufferViewAddRef texelBufferViewAddRef;
+    WGPUProcTexelBufferViewRelease texelBufferViewRelease;
+
+    WGPUProcTextureCreateErrorView textureCreateErrorView;
+    WGPUProcTextureCreateView textureCreateView;
+    WGPUProcTextureDestroy textureDestroy;
+    WGPUProcTextureGetDepthOrArrayLayers textureGetDepthOrArrayLayers;
+    WGPUProcTextureGetDimension textureGetDimension;
+    WGPUProcTextureGetFormat textureGetFormat;
+    WGPUProcTextureGetHeight textureGetHeight;
+    WGPUProcTextureGetMipLevelCount textureGetMipLevelCount;
+    WGPUProcTextureGetSampleCount textureGetSampleCount;
+    WGPUProcTextureGetTextureBindingViewDimension textureGetTextureBindingViewDimension;
+    WGPUProcTextureGetUsage textureGetUsage;
+    WGPUProcTextureGetWidth textureGetWidth;
+    WGPUProcTextureSetLabel textureSetLabel;
+    WGPUProcTextureSetOwnershipForMemoryDump textureSetOwnershipForMemoryDump;
+    WGPUProcTextureAddRef textureAddRef;
+    WGPUProcTextureRelease textureRelease;
+
+    WGPUProcTextureViewSetLabel textureViewSetLabel;
+    WGPUProcTextureViewAddRef textureViewAddRef;
+    WGPUProcTextureViewRelease textureViewRelease;
+
+
+} DawnProcTable;
+
+#endif  // DAWN_DAWN_PROC_TABLE_H_