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

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp

@@ -255,7 +255,8 @@ void CanvasRenderingContext2DImpl::Init(v8::Local<v8::Object> canvasModule, v8::
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"), func).FromJust();
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"),
+                      func).FromJust();
 }
 
 CanvasRenderingContext2DImpl *
@@ -1206,10 +1207,6 @@ void CanvasRenderingContext2DImpl::GetFillStyle(v8::Local<v8::String> property,
             info.GetReturnValue().Set(style);
             break;
         }
-        case PaintStyleType::PaintStyleTypeNone: {
-            info.GetReturnValue().SetUndefined();
-            break;
-        }
     }
 
 }
@@ -1289,10 +1286,6 @@ void CanvasRenderingContext2DImpl::GetStrokeStyle(v8::Local<v8::String> property
             info.GetReturnValue().Set(style);
             break;
         }
-        case PaintStyleType::PaintStyleTypeNone: {
-            info.GetReturnValue().SetUndefined();
-            break;
-        }
     }
 
 }
@@ -1540,13 +1533,13 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
     auto count = args.Length();
     if (count == 0) {
         canvas_native_context_clip_rule(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
     } else if (count == 1 && args[0]->IsUint32()) {
         uint32_t val = 0;
 
         if (args[0]->Uint32Value(context).To(&val)) {
             canvas_native_context_clip_rule(
-                    ptr->GetContext(), val);
+                    ptr->GetContext(), val == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
         }
     } else if (count == 1 && args[0]->IsObject()) {
         auto type = GetNativeType(args[0].As<v8::Object>());
@@ -1555,7 +1548,7 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
 
             if (object != nullptr) {
                 canvas_native_context_clip(
-                        ptr->GetContext(), object->GetPath(), 0);
+                        ptr->GetContext(), object->GetPath(), CanvasFillRuleNonZero);
             }
         }
     } else if (count >= 2 && args[0]->IsObject() && args[1]->IsUint32()) {
@@ -1566,7 +1559,8 @@ void CanvasRenderingContext2DImpl::Clip(const v8::FunctionCallbackInfo<v8::Value
 
             if (args[1]->Uint32Value(context).To(&rule)) {
                 canvas_native_context_clip(
-                        ptr->GetContext(), object->GetPath(), rule);
+                        ptr->GetContext(), object->GetPath(),
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
             }
         }
     }
@@ -1661,18 +1655,36 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto image_asset = ImageAssetImpl::GetPointer(value.As<v8::Object>());
                 if (image_asset != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_asset(
-                            ptr->GetContext(),
-                            image_asset->GetImageAsset(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+
+                    PaintStyle *style = nullptr;
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_asset->GetImageAsset(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
+                    }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
                     }
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1680,18 +1692,37 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto image_bitmap = ImageBitmapImpl::GetPointer(value.As<v8::Object>());
                 if (image_bitmap != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_asset(
-                            ptr->GetContext(),
-                            image_bitmap->GetImageAsset(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_asset(
+                                ptr->GetContext(),
+                                image_bitmap->GetImageAsset(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
                     }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
+                    }
+
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1700,18 +1731,36 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                         value.As<v8::Object>());
                 if (canvas_2d != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_canvas2d(
-                            canvas_2d->GetContext(),
-                            ptr->GetContext(), rep.c_str());
-                    auto style_type = canvas_native_context_get_style_type(pattern);
-                    if (style_type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetUndefined();
-                        canvas_native_paint_style_destroy(pattern);
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_canvas2d(
+                                canvas_2d->GetContext(),
+                                ptr->GetContext(), CanvasRepetitionRepeatY);
                     } else {
-                        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
-                        args.GetReturnValue().Set(data);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
+                    }
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
+                        return;
                     }
+
+                    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(style));
+                    args.GetReturnValue().Set(data);
                 }
                 return;
             }
@@ -1719,21 +1768,40 @@ CanvasRenderingContext2DImpl::CreatePattern(const v8::FunctionCallbackInfo<v8::V
                 auto webgl = WebGLRenderingContextBase::GetPointer(value.As<v8::Object>());
                 if (webgl != nullptr) {
                     auto rep = ConvertFromV8String(isolate, args[1]);
-                    auto pattern = canvas_native_context_create_pattern_webgl(
-                            webgl->GetState(),
-                            ptr->GetContext(), rep.c_str());
-                    auto type = canvas_native_context_get_style_type(pattern);
-                    if (type ==
-                        PaintStyleType::PaintStyleTypeNone) {
-                        args.GetReturnValue().SetNull();
-                        canvas_native_paint_style_destroy(pattern);
-                        return;
+
+                    PaintStyle *style = nullptr;
+
+                    if (rep == "no-repeat") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionNoRepeat);
+                    } else if (rep == "repeat") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeat);
+                    } else if (rep == "repeat-x") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeatX);
+                    } else if (rep == "repeat-y") {
+                        style = canvas_native_context_create_pattern_webgl(
+                                webgl->GetState(),
+                                ptr->GetContext(), CanvasRepetitionRepeatY);
                     } else {
-                        auto ret = CanvasPattern::NewInstance(isolate, new CanvasPattern(
-                                pattern));
-                        args.GetReturnValue().Set(ret);
+                        // todo
+                        args.GetReturnValue().SetUndefined();
+                        return;
+                    }
+
+                    if (style == nullptr) {
+                        args.GetReturnValue().SetNull();
                         return;
                     }
+
+                    auto ret = CanvasPattern::NewInstance(isolate, new CanvasPattern(
+                            style));
+                    args.GetReturnValue().Set(ret);
+                    return;
                 }
                 return;
             }
@@ -1831,16 +1899,16 @@ CanvasRenderingContext2DImpl::__CreatePatternWithNative(
     auto pointer = args[0]->ToBigInt(context).ToLocalChecked();
 
     auto pattern = canvas_native_pattern_from_ptr(pointer->Int64Value());
-    auto type = canvas_native_context_get_style_type(pattern);
-    if (type == PaintStyleType::PaintStyleTypeNone) {
-        args.GetReturnValue().SetUndefined();
-        canvas_native_paint_style_destroy(pattern);
-    } else {
-        auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
 
-        args.GetReturnValue().Set(data);
+    if (pattern == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
     }
 
+    auto data = CanvasPattern::NewInstance(isolate, new CanvasPattern(pattern));
+
+    args.GetReturnValue().Set(data);
+
 }
 
 void
@@ -2282,7 +2350,8 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
                 auto rule = args[1]->Uint32Value(context).ToChecked();
                 canvas_native_context_fill_with_path(
                         ptr->GetContext(),
-                        object->GetPath(), rule);
+                        object->GetPath(),
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
                 ptr->UpdateInvalidateState();
             }
         }
@@ -2291,7 +2360,7 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
             auto rule = value->Uint32Value(context).ToChecked();
             canvas_native_context_fill(
                     ptr->GetContext(),
-                    rule);
+                    rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
             ptr->UpdateInvalidateState();
         } else if (value->IsObject()) {
             auto type = GetNativeType(value.As<v8::Object>());
@@ -2300,13 +2369,13 @@ CanvasRenderingContext2DImpl::Fill(const v8::FunctionCallbackInfo<v8::Value> &ar
 
                 canvas_native_context_fill_with_path(
                         ptr->GetContext(),
-                        object->GetPath(), 0);
+                        object->GetPath(), CanvasFillRuleNonZero);
                 ptr->UpdateInvalidateState();
             }
         }
     } else {
         canvas_native_context_fill(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 }
@@ -2457,7 +2526,7 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
         auto x = static_cast<float>(args[0]->NumberValue(context).ToChecked());
         auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
         auto ret = canvas_native_context_is_point_in_path(
-                ptr->GetContext(), x, y, 0);
+                ptr->GetContext(), x, y, CanvasFillRuleNonZero);
         args.GetReturnValue().Set(ret);
         return;
     } else if (count == 3 &&
@@ -2466,7 +2535,7 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
         auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
         auto rule = args[2]->Uint32Value(context).ToChecked();
         bool ret = canvas_native_context_is_point_in_path(
-                ptr->GetContext(), x, y, rule);
+                ptr->GetContext(), x, y, rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
         args.GetReturnValue().Set(ret);
         return;
     } else if (count == 4 &&
@@ -2486,7 +2555,8 @@ CanvasRenderingContext2DImpl::IsPointInPath(const v8::FunctionCallbackInfo<v8::V
 
                 bool ret = canvas_native_context_is_point_in_path_with_path(
                         ptr->GetContext(),
-                        path->GetPath(), x, y, rule);
+                        path->GetPath(), x, y,
+                        rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
 
                 args.GetReturnValue().Set(ret);
                 return;
@@ -3061,7 +3131,7 @@ CanvasRenderingContext2DImpl::~CanvasRenderingContext2DImpl() {
         canvas_native_raf_stop(raf->GetRaf());
     }
 
-    canvas_native_context_destroy(this->GetContext());
+    canvas_native_context_release(this->GetContext());
     this->context_ = nullptr;
 }
 

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h

@@ -503,9 +503,12 @@ public:
 
         switch (rule) {
             case 0:
+                canvas_native_context_clip_rule(
+                        ptr->GetContext(), CanvasFillRuleNonZero);
+                break;
             case 1:
                 canvas_native_context_clip_rule(
-                        ptr->GetContext(), rule);
+                        ptr->GetContext(), CanvasFillRuleEvenOdd);
                 break;
             default:
                 break;
@@ -521,7 +524,7 @@ public:
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
             canvas_native_context_clip(
-                    ptr->GetContext(), path->GetPath(), 0);
+                    ptr->GetContext(), path->GetPath(), CanvasFillRuleNonZero);
         }
 
 
@@ -536,8 +539,17 @@ public:
 
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
-            canvas_native_context_clip(
-                    ptr->GetContext(), path->GetPath(), rule);
+            switch (rule) {
+                case 0:
+                    canvas_native_context_clip(
+                            ptr->GetContext(), path->GetPath(), CanvasFillRuleNonZero);
+                    break;
+                case 1:
+                    canvas_native_context_clip(
+                            ptr->GetContext(), path->GetPath(), CanvasFillRuleEvenOdd);
+                    break;
+                default: break;
+            }
         }
 
     }
@@ -884,10 +896,22 @@ public:
         auto object = Path2D::GetPointer(path);
 
         if (object != nullptr) {
-            canvas_native_context_fill_with_path(
-                    ptr->GetContext(),
-                    object->GetPath(),
-                    rule);
+            switch (rule) {
+                case 0:
+                    canvas_native_context_fill_with_path(
+                            ptr->GetContext(),
+                            object->GetPath(),
+                            CanvasFillRuleNonZero);
+                    break;
+                case 1:
+                    canvas_native_context_fill_with_path(
+                            ptr->GetContext(),
+                            object->GetPath(),
+                            CanvasFillRuleEvenOdd);
+                    break;
+                default: break;
+            }
+
             ptr->UpdateInvalidateState();
         }
     }
@@ -901,9 +925,10 @@ public:
 
         auto object = Path2D::GetPointer(path);
 
+
         canvas_native_context_fill_with_path(
                 ptr->GetContext(),
-                object->GetPath(), 0);
+                object->GetPath(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 
@@ -913,8 +938,20 @@ public:
             return;
         }
 
-        canvas_native_context_fill(
-                ptr->GetContext(), rule);
+
+        switch (rule) {
+            case 0:
+                canvas_native_context_fill(
+                        ptr->GetContext(), CanvasFillRuleNonZero);
+                break;
+            case 1:
+                canvas_native_context_fill(
+                        ptr->GetContext(), CanvasFillRuleEvenOdd);
+                break;
+            default: break;
+        }
+
+
         ptr->UpdateInvalidateState();
     }
 
@@ -925,7 +962,7 @@ public:
         }
 
         canvas_native_context_fill(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 
@@ -986,7 +1023,7 @@ public:
         }
 
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), 0);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), CanvasFillRuleNonZero);
     }
 
     static bool
@@ -997,8 +1034,9 @@ public:
             return false;
         }
 
+
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
     }
 
     static bool
@@ -1018,10 +1056,21 @@ public:
         if (type == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
 
+            switch (rule) {
+                case 0:
 
-            ret = canvas_native_context_is_point_in_path_with_path(
-                    ptr->GetContext(),
-                    path->GetPath(), x, y, rule);
+                    ret = canvas_native_context_is_point_in_path_with_path(
+                            ptr->GetContext(),
+                            path->GetPath(), (float)x,  (float)y, CanvasFillRuleNonZero);
+                    break;
+                case 1:
+
+                    ret = canvas_native_context_is_point_in_path_with_path(
+                            ptr->GetContext(),
+                            path->GetPath(),  (float)x,  (float)y, CanvasFillRuleEvenOdd);
+                    break;
+                default: break;
+            }
 
         }
         return ret;

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.cpp

@@ -23,9 +23,9 @@ public:
     }
 
     ~ImageDataBuffer() {
-        canvas_native_u8_buffer_destroy(slice_);
+        canvas_native_u8_buffer_release(slice_);
         slice_ = nullptr;
-        canvas_native_image_data_destroy(imageData_);
+        canvas_native_image_data_release(imageData_);
         imageData_ = nullptr;
     }
 
@@ -181,8 +181,7 @@ ImageDataImpl::GetData(v8::Local<v8::Name> name,
     if (ptr != nullptr) {
         auto isolate = info.GetIsolate();
 
-        auto data = new ImageDataBuffer(
-                canvas_native_image_data_get_shared_instance(ptr->GetImageData()));
+        auto data = new ImageDataBuffer(ptr->GetImageData());
 
         auto length = data->size();
         auto store = v8::ArrayBuffer::NewBackingStore(data->data(), length,

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.h

@@ -10,10 +10,10 @@
 
 class ImageDataImpl: ObjectWrapperImpl {
 public:
-    ImageDataImpl(ImageData* imageData);
-    
+    explicit ImageDataImpl(ImageData* imageData);
+
     ~ImageDataImpl(){
-        canvas_native_image_data_destroy(this->GetImageData());
+        canvas_native_image_data_release(this->GetImageData());
         this->imageData_ = nullptr;
     }
 

package/platforms/ios/src/cpp/canvas2d/MatrixImpl.h

@@ -10,9 +10,9 @@
 
 class MatrixImpl: public ObjectWrapperImpl {
 public:
-    MatrixImpl(Matrix* matrix);
+    explicit MatrixImpl(Matrix* matrix);
     ~MatrixImpl(){
-        canvas_native_matrix_destroy(this->GetMatrix());
+        canvas_native_matrix_release(this->GetMatrix());
         this->matrix_ = nullptr;
     }
 

package/platforms/ios/src/cpp/canvas2d/Path2D.h

@@ -11,10 +11,10 @@
 
 class Path2D : ObjectWrapperImpl {
 public:
-    Path2D(Path *path);
+    explicit Path2D(Path *path);
 
     ~Path2D() {
-        canvas_native_path_destroy(this->GetPath());
+        canvas_native_path_release(this->GetPath());
         this->path_ = nullptr;
     }
 

package/platforms/ios/src/cpp/canvas2d/TextMetricsImpl.h

@@ -10,10 +10,10 @@
 
 class TextMetricsImpl: public ObjectWrapperImpl {
 public:
-    TextMetricsImpl(TextMetrics* metrics);
-    
+    explicit TextMetricsImpl(TextMetrics* metrics);
+
     ~TextMetricsImpl(){
-        canvas_native_text_metrics_destroy(this->GetTextMetrics());
+        canvas_native_text_metrics_release(this->GetTextMetrics());
         this->metrics_ = nullptr;
     }
 

package/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp

@@ -719,7 +719,7 @@ v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *is
                                                           [](void *data, size_t length,
                                                              void *deleter_data) {
                                                               if (deleter_data != nullptr) {
-                                                                  canvas_native_f32_buffer_destroy(
+                                                                  canvas_native_f32_buffer_release(
                                                                           (F32Buffer *) deleter_data);
                                                               }
                                                           },
@@ -773,7 +773,7 @@ v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *is
                                                           [](void *data, size_t length,
                                                              void *deleter_data) {
                                                               if (deleter_data != nullptr) {
-                                                                  canvas_native_i32_buffer_destroy(
+                                                                  canvas_native_i32_buffer_release(
                                                                           (I32Buffer *) deleter_data);
                                                               }
                                                           },
@@ -2348,7 +2348,7 @@ void WebGLRenderingContext::GetAttachedShaders(const v8::FunctionCallbackInfo<v8
             }
             args.GetReturnValue().Set(array);
 
-            canvas_native_u32_buffer_destroy(info);
+            canvas_native_u32_buffer_release(info);
             return;
         }
     }
@@ -3126,7 +3126,7 @@ WebGLRenderingContext::GetSupportedExtensions(const v8::FunctionCallbackInfo<v8:
 
     args.GetReturnValue().Set(array);
 
-    canvas_native_string_buffer_destroy(exts);
+    canvas_native_string_buffer_release(exts);
 }
 
 void
@@ -3291,7 +3291,7 @@ WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &arg
                                                                      void *deleter_data) {
                                                                       if (deleter_data !=
                                                                           nullptr) {
-                                                                          canvas_native_f32_buffer_destroy(
+                                                                          canvas_native_f32_buffer_release(
                                                                                   (F32Buffer *) deleter_data);
                                                                       }
                                                                   },
@@ -3322,7 +3322,7 @@ WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &arg
                                                                      void *deleter_data) {
                                                                       if (deleter_data !=
                                                                           nullptr) {
-                                                                          canvas_native_i32_buffer_destroy(
+                                                                          canvas_native_i32_buffer_release(
                                                                                   (I32Buffer *) deleter_data);
                                                                       }
                                                                   },
@@ -3353,7 +3353,7 @@ WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &arg
                                                                      void *deleter_data) {
                                                                       if (deleter_data !=
                                                                           nullptr) {
-                                                                          canvas_native_u32_buffer_destroy(
+                                                                          canvas_native_u32_buffer_release(
                                                                                   (U32Buffer *) deleter_data);
                                                                       }
                                                                   },
@@ -3456,7 +3456,7 @@ WebGLRenderingContext::GetVertexAttrib(const v8::FunctionCallbackInfo<v8::Value>
                                                       [](void *data, size_t length,
                                                          void *deleter_data) {
                                                           if (deleter_data != nullptr) {
-                                                              canvas_native_f32_buffer_destroy(
+                                                              canvas_native_f32_buffer_release(
                                                                       (F32Buffer *) deleter_data);
                                                           }
                                                       },