@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.4

package/platforms/ios/src/cpp/webgl/WebGLShaderPrecisionFormatImpl.h

@@ -10,9 +10,9 @@
 #include "Common.h"
 #include "ObjectWrapperImpl.h"
 
-class WebGLShaderPrecisionFormatImpl: ObjectWrapperImpl {
+class WebGLShaderPrecisionFormatImpl : ObjectWrapperImpl {
 public:
-    WebGLShaderPrecisionFormatImpl(WebGLShaderPrecisionFormat* shader);
+    explicit WebGLShaderPrecisionFormatImpl(WebGLShaderPrecisionFormat *shader);
 
     ~WebGLShaderPrecisionFormatImpl() {
         canvas_native_webgl_shader_precision_format_destroy(this->GetShaderPrecisionFormat());
@@ -51,7 +51,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLShaderPrecisionFormatImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLShaderPrecisionFormat);
+        SetNativeType(shaderPrecisionFormat, NativeType::WebGLShaderPrecisionFormat);
         object->SetAlignedPointerInInternalField(0, shaderPrecisionFormat);
         shaderPrecisionFormat->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -75,9 +75,9 @@ public:
     static void GetPrecision(v8::Local<v8::Name> property,
                              const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    WebGLShaderPrecisionFormat* GetShaderPrecisionFormat();
+    WebGLShaderPrecisionFormat *GetShaderPrecisionFormat();
 
 private:
-    WebGLShaderPrecisionFormat* shader_;
+    WebGLShaderPrecisionFormat *shader_;
 };
 

package/platforms/ios/src/cpp/webgl/WebGLTexture.h

@@ -6,7 +6,8 @@
 
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
-class WebGLTexture: ObjectWrapperImpl {
+
+class WebGLTexture : ObjectWrapperImpl {
 public:
     WebGLTexture(uint32_t texture) : texture_(texture) {}
 
@@ -34,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLTexture::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLTexture);
+        SetNativeType(texture, NativeType::WebGLTexture);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/WebGLUniformLocation.h

@@ -9,7 +9,7 @@
 #include "Caches.h"
 #include "ObjectWrapperImpl.h"
 
-class WebGLUniformLocation: ObjectWrapperImpl {
+class WebGLUniformLocation : ObjectWrapperImpl {
 public:
     WebGLUniformLocation(int32_t
                          uniformLocation) :
@@ -41,7 +41,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLUniformLocation::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLUniformLocation);
+        SetNativeType(uniformLocation, NativeType::WebGLUniformLocation);
         object->SetAlignedPointerInInternalField(0, uniformLocation);
         uniformLocation->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/ANGLE_instanced_arraysImpl.h

@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = ANGLE_instanced_arraysImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::ANGLE_instanced_arrays);
+        SetNativeType(arrays, NativeType::ANGLE_instanced_arrays);
         object->SetAlignedPointerInInternalField(0, arrays);
         arrays->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/EXT_blend_minmaxImpl.h

@@ -18,7 +18,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_blend_minmaxImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_blend_minmax);
+        SetNativeType( minmax, NativeType::EXT_blend_minmax);
         object->SetAlignedPointerInInternalField(0, minmax);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
                     ConvertToV8String(isolate, "EXT_blend_minmax"));

package/platforms/ios/src/cpp/webgl/extensions/EXT_color_buffer_half_floatImpl.h

@@ -18,7 +18,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_color_buffer_half_floatImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_color_buffer_half_float);
+        SetNativeType( buffer, NativeType::EXT_color_buffer_half_float);
         object->SetAlignedPointerInInternalField(0, buffer);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
                     ConvertToV8String(isolate, "EXT_color_buffer_half_float"));

package/platforms/ios/src/cpp/webgl/extensions/EXT_disjoint_timer_queryImpl.h

@@ -28,7 +28,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_disjoint_timer_queryImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_disjoint_timer_query);
+        SetNativeType( query, NativeType::EXT_disjoint_timer_query);
         object->SetAlignedPointerInInternalField(0, query);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
                     ConvertToV8String(isolate, "EXT_disjoint_timer_query"));

package/platforms/ios/src/cpp/webgl/extensions/EXT_sRGBImpl.h

@@ -45,7 +45,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_sRGBImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_sRGB);
+        SetNativeType( extSrgb, NativeType::EXT_sRGB);
         object->SetAlignedPointerInInternalField(0, extSrgb);
         extSrgb->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/EXT_shader_texture_lodImpl.h

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_shader_texture_lodImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_shader_texture_lod);
+        SetNativeType( texture, NativeType::EXT_shader_texture_lod);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/EXT_texture_filter_anisotropicImpl.h

@@ -43,7 +43,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = EXT_texture_filter_anisotropicImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::EXT_texture_filter_anisotropic);
+        SetNativeType( filterAnisotropic, NativeType::EXT_texture_filter_anisotropic);
         object->SetAlignedPointerInInternalField(0, filterAnisotropic);
         filterAnisotropic->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_element_index_uintImpl.h

@@ -43,10 +43,10 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_element_index_uintImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_element_index_uint);
+        SetNativeType( element, NativeType::OES_element_index_uint);
         object->SetAlignedPointerInInternalField(0, element);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
-                    ConvertToV8String(isolate, "OES_element_index_uint"));
+                    ConvertToV8String(isolate, "OES_element_index_uint")).FromJust();
         element->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }

package/platforms/ios/src/cpp/webgl/extensions/OES_fbo_render_mipmap.h

@@ -32,16 +32,16 @@ public:
     }
 
     static v8::Local<v8::Object>
-    NewInstance(v8::Isolate *isolate, OES_fbo_render_mipmapImpl *texture) {
+    NewInstance(v8::Isolate *isolate, OES_fbo_render_mipmapImpl *mipmap) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_fbo_render_mipmapImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_fbo_render_mipmap);
-        object->SetAlignedPointerInInternalField(0, texture);
+        SetNativeType( mipmap, NativeType::OES_fbo_render_mipmap);
+        object->SetAlignedPointerInInternalField(0, mipmap);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
-                    ConvertToV8String(isolate, "OES_fbo_render_mipmap"));
-        texture->BindFinalizer(isolate, object);
+                    ConvertToV8String(isolate, "OES_fbo_render_mipmap")).FromJust();
+        mipmap->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 

package/platforms/ios/src/cpp/webgl/extensions/OES_standard_derivativesImpl.h

@@ -40,7 +40,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_standard_derivativesImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_standard_derivatives);
+        SetNativeType( derivatives, NativeType::OES_standard_derivatives);
         object->SetAlignedPointerInInternalField(0, derivatives);
         derivatives->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_texture_floatImpl.h

@@ -36,7 +36,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLShader::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_texture_float);
+        SetNativeType( texture, NativeType::OES_texture_float);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_texture_float_linearImpl.h

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_texture_float_linearImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_texture_float_linear);
+        SetNativeType( texture, NativeType::OES_texture_float_linear);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_texture_half_floatImpl.h

@@ -38,7 +38,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_texture_half_floatImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_texture_half_float);
+        SetNativeType( texture, NativeType::OES_texture_half_float);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_texture_half_float_linearImpl.h

@@ -38,7 +38,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_texture_half_float_linearImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::OES_texture_half_float_linear);
+        SetNativeType( texture, NativeType::OES_texture_half_float_linear);
         object->SetAlignedPointerInInternalField(0, texture);
         texture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/OES_vertex_array_objectImpl.h

@@ -71,7 +71,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = OES_vertex_array_objectImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::OES_vertex_array_object);
+        SetNativeType(vertexArrayObject, NativeType::OES_vertex_array_object);
         object->SetAlignedPointerInInternalField(0, vertexArrayObject);
         vertexArrayObject->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_color_buffer_floatImpl.h

@@ -47,7 +47,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_color_buffer_floatImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_color_buffer_float);
+        SetNativeType( buffer, NativeType::WEBGL_color_buffer_float);
         object->SetAlignedPointerInInternalField(0, buffer);
         buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_atcImpl.h

@@ -45,7 +45,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_atcImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_atc);
+        SetNativeType( compressedTextureAtc, NativeType::WEBGL_compressed_texture_atc);
         object->SetAlignedPointerInInternalField(0, compressedTextureAtc);
         compressedTextureAtc->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_etc1Impl.h

@@ -43,7 +43,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_etc1Impl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_etc1);
+        SetNativeType( compressedTextureEtc1, NativeType::WEBGL_compressed_texture_etc1);
         object->SetAlignedPointerInInternalField(0, compressedTextureEtc1);
         compressedTextureEtc1->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_etcImpl.h

@@ -70,10 +70,10 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_etcImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_etc);
+        SetNativeType( compressedTextureEtc, NativeType::WEBGL_compressed_texture_etc);
         object->SetAlignedPointerInInternalField(0, compressedTextureEtc);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
-                    ConvertToV8String(isolate, "WEBGL_compressed_texture_etc"));
+                    ConvertToV8String(isolate, "WEBGL_compressed_texture_etc")).FromJust();
         compressedTextureEtc->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_pvrtcImpl.h

@@ -53,7 +53,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_pvrtcImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_pvrtc);
+        SetNativeType( compressedTexturePvrtc, NativeType::WEBGL_compressed_texture_pvrtc);
         object->SetAlignedPointerInInternalField(0, compressedTexturePvrtc);
         compressedTexturePvrtc->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_s3tcImpl.h

@@ -49,7 +49,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_s3tcImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_s3tc);
+        SetNativeType( textureS3Tc, NativeType::WEBGL_compressed_texture_s3tc);
         object->SetAlignedPointerInInternalField(0, textureS3Tc);
         textureS3Tc->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_compressed_texture_s3tc_srgbImpl.h

@@ -53,7 +53,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_compressed_texture_s3tc_srgbImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_compressed_texture_s3tc_srgb);
+        SetNativeType( compressedTextureS3TcSrgb, NativeType::WEBGL_compressed_texture_s3tc_srgb);
         object->SetAlignedPointerInInternalField(0, compressedTextureS3TcSrgb);
         object->Set(context, ConvertToV8String(isolate, "ext_name"),
                     ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_depth_textureImpl.h

@@ -43,7 +43,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_depth_textureImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_depth_texture);
+        SetNativeType( depthTexture, NativeType::WEBGL_depth_texture);
         object->SetAlignedPointerInInternalField(0, depthTexture);
         depthTexture->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_draw_buffersImpl.h

@@ -126,7 +126,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_draw_buffersImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::WEBGL_draw_buffers);
+        SetNativeType(buffers, NativeType::WEBGL_draw_buffers);
         object->SetAlignedPointerInInternalField(0, buffers);
         buffers->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl/extensions/WEBGL_lose_contextImpl.h

@@ -51,7 +51,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WEBGL_lose_contextImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WEBGL_lose_context);
+        SetNativeType( element, NativeType::WEBGL_lose_context);
         object->SetAlignedPointerInInternalField(0, element);
         element->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGL2RenderingContext.h

@@ -115,7 +115,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGL2RenderingContext::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::WebGLRenderingContextBase);
+        SetNativeType(renderingContext, NativeType::WebGLRenderingContextBase);
         object->SetAlignedPointerInInternalField(0, renderingContext);
         renderingContext->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGLQuery.h

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLQuery::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLQuery);
+        SetNativeType( query, NativeType::WebGLQuery);
         object->SetAlignedPointerInInternalField(0, query);
         query->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGLSampler.h

@@ -36,7 +36,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLSampler::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLSampler);
+        SetNativeType( sampler, NativeType::WebGLSampler);
         object->SetAlignedPointerInInternalField(0, sampler);
         sampler->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGLSyncImpl.h

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLSyncImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLSync);
+        SetNativeType( sync, NativeType::WebGLSync);
         object->SetAlignedPointerInInternalField(0, sync);
         sync->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGLTransformFeedback.h

@@ -37,7 +37,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLTransformFeedback::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLTransformFeedback);
+        SetNativeType( feedback, NativeType::WebGLTransformFeedback);
         object->SetAlignedPointerInInternalField(0, feedback);
         feedback->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgl2/WebGLVertexArrayObject.h

@@ -9,7 +9,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class WebGLVertexArrayObject: ObjectWrapperImpl {
+class WebGLVertexArrayObject : ObjectWrapperImpl {
 public:
     WebGLVertexArrayObject(uint32_t vertexArrayObject) : vertexArrayObject_(vertexArrayObject) {}
 
@@ -38,7 +38,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLVertexArrayObject::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLVertexArrayObject);
+        SetNativeType(vertexArrayObject, NativeType::WebGLVertexArrayObject);
         object->SetAlignedPointerInInternalField(0, vertexArrayObject);
         vertexArrayObject->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp

@@ -158,6 +158,24 @@ void GPUAdapterImpl::RequestAdapterInfo(const v8::FunctionCallbackInfo<v8::Value
 
 }
 
+struct RequestData {
+    char *error_;
+    const CanvasGPUDevice *device_;
+    char **required_features_data_;
+
+    ~RequestData() {
+        if (required_features_data_ != nullptr) {
+            delete[] required_features_data_;
+            required_features_data_ = nullptr;
+        }
+
+        if (error_ != nullptr) {
+            canvas_native_string_destroy(error_);
+            error_ = nullptr;
+        }
+    }
+};
+
 void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUAdapterImpl *ptr = GetPointer(args.This());
     auto isolate = args.GetIsolate();
@@ -170,7 +188,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         return;
     }
 
-    v8::Global<v8::Function> func(isolate, cb.As<v8::Function>());
+    auto func = cb.As<v8::Function>();
 
     std::string label;
 
@@ -210,7 +228,6 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
             }
         }
 
-
         v8::Local<v8::Value> limitsValue;
 
         options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
@@ -235,68 +252,117 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         }
     }
 
-
     auto callback = new AsyncCallback{
             isolate,
-            std::move(func),
-            static_cast<void *>(required_features_data)
+            func,
+            [](bool done, void *data) {
+                if (data != nullptr) {
+                    auto async_data = static_cast<AsyncCallback *>(data);
+                    auto func = async_data->inner_.get();
+                    if (func != nullptr && func->isolate_ != nullptr) {
+                        v8::Isolate *isolate = func->isolate_;
+                        v8::Locker locker(isolate);
+                        v8::Isolate::Scope isolate_scope(isolate);
+                        v8::HandleScope handle_scope(isolate);
+                        v8::Local<v8::Function> callback = func->callback_.Get(
+                                isolate);
+                        v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                        v8::Context::Scope context_scope(context);
+
+                        RequestData *requestData = nullptr;
+                        if (func->data != nullptr) {
+                            requestData = static_cast<RequestData *>(func->data);
+                        }
+
+                        if (requestData == nullptr) {
+                            // Should never happen
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Exception::Error(
+                                            ConvertToV8String(isolate, "Internal Error"))};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            delete static_cast<AsyncCallback *>(data);
+
+                            return;
+                        }
+
+                        if (requestData->error_ != nullptr) {
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Exception::Error(
+                                            ConvertToV8String(isolate,
+                                                              requestData->error_))};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            delete static_cast<AsyncCallback *>(data);
+                        } else {
+
+                            auto impl = new GPUDeviceImpl(requestData->device_);
+                            auto ret = GPUDeviceImpl::NewInstance(
+                                    isolate, impl);
+
+                            v8::Local<v8::Value> args[2] = {
+                                    v8::Null(isolate), ret};
+
+
+                            callback->Call(context, context->Global(),
+                                           2,
+                                           args);  // ignore JS return value
+
+                            delete static_cast<AsyncCallback *>(data);
+                        }
+
+                        if (requestData != nullptr) {
+                            delete requestData;
+                            requestData = nullptr;
+                        }
+                    }
+                }
+            }
     };
 
-    canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
-                                        label.empty() ? nullptr : label.c_str(),
-                                        required_features_data, required_features_data_length,
-                                        limits,
-                                        [](char *error, const CanvasGPUDevice *device, void *data) {
-                                            if (data != nullptr) {
-                                                auto func = static_cast<AsyncCallback *>(data);
-                                                if (func->isolate != nullptr) {
-                                                    v8::Isolate *isolate = func->isolate;
-                                                    v8::Locker locker(isolate);
-                                                    v8::Isolate::Scope isolate_scope(isolate);
-                                                    v8::HandleScope handle_scope(isolate);
-                                                    v8::Local<v8::Function> callback = func->callback.Get(
-                                                            isolate);
-                                                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                    v8::Context::Scope context_scope(context);
-
-                                                    if (func->data != nullptr) {
-                                                        delete[] static_cast<char **>(func->data);
-                                                        func->data = nullptr;
-                                                    }
-
-                                                    if (error != nullptr) {
-                                                        v8::Local<v8::Value> args[1] = {
-                                                                v8::Exception::Error(
-                                                                        ConvertToV8String(isolate,
-                                                                                          error))};
-
-                                                        canvas_native_string_destroy(error);
-
-                                                        callback->Call(context, context->Global(),
-                                                                       1,
-                                                                       args);  // ignore JS return value
-                                                        delete static_cast<AsyncCallback *>(data);
-                                                    } else {
-
-                                                        auto impl = new GPUDeviceImpl(device);
-                                                        auto ret = GPUDeviceImpl::NewInstance(
-                                                                isolate, impl);
-
+    auto inner = callback->inner_.get();
 
-                                                        v8::Local<v8::Value> args[2] = {
-                                                                v8::Null(isolate), ret};
-
-
-                                                        callback->Call(context, context->Global(),
-                                                                       2,
-                                                                       args);  // ignore JS return value
+    if (required_features_data != nullptr) {
+        inner->data = new RequestData{
+                nullptr,
+                nullptr,
+                required_features_data
+        };
+    }
 
-                                                        delete static_cast<AsyncCallback *>(data);
+    callback->prepare();
 
+    canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
+                                                label.empty() ? nullptr : label.c_str(),
+                                                required_features_data,
+                                                required_features_data_length,
+                                                limits,
+                                                [](char *error, const CanvasGPUDevice *device,
+                                                   void *data) {
+                                                    if (data != nullptr) {
+                                                        auto async_data = static_cast<AsyncCallback *>(data);
+                                                        auto inner = async_data->inner_.get();
+                                                        if (inner != nullptr) {
+                                                            if (inner->data == nullptr) {
+                                                                inner->data = new RequestData{
+                                                                        error,
+                                                                        device
+                                                                };
+                                                            } else {
+                                                                auto request_data = static_cast<RequestData *>(inner->data);
+                                                                request_data->error_ = error;
+                                                                request_data->device_ = device;
+                                                                delete request_data->required_features_data_;
+                                                                request_data->required_features_data_ = nullptr;
+                                                            }
+
+                                                            async_data->execute(true);
+                                                        }
                                                     }
-                                                }
-                                            }
-                                        }, callback);
-
+                                                }, callback);
 
 }