@nativescript/canvas 2.0.0-beta.8 → 2.0.0-webgpu.0

package/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h

@@ -0,0 +1,95 @@
+//
+// Created by Osei Fortune on 18/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUDEVICEIMPL_H
+#define CANVAS_ANDROID_GPUDEVICEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUDeviceImpl : ObjectWrapperImpl {
+public:
+    GPUDeviceImpl(const CanvasGPUDevice *device);
+
+    ~GPUDeviceImpl() {
+        canvas_native_webgpu_device_release(this->device_);
+    }
+
+    const CanvasGPUDevice *GetGPUDevice();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUDeviceImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUDeviceImpl *device) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUDeviceImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUDevice);
+        object->SetAlignedPointerInInternalField(0, device);
+        device->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+
+    static void GetFeatures(v8::Local<v8::Name> name,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLimits(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetQueue(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLost(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateCommandEncoder(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateComputePipeline(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateComputePipelineAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreatePipelineLayout(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateQuerySet(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderBundleEncoder(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderPipelineAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateShaderModule(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PopErrorScope(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PushErrorScope(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void SetUncapturedError(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPUDevice *device_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUDEVICEIMPL_H

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

@@ -0,0 +1,186 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#include "GPUImpl.h"
+#include "Caches.h"
+
+GPUImpl::GPUImpl(const CanvasWebGPUInstance *instance) : instance_(instance) {}
+
+const CanvasWebGPUInstance *GPUImpl::GetGPUInstance() {
+    return this->instance_;
+}
+
+void GPUImpl::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPU"), func).FromJust();;
+}
+
+
+GPUImpl *GPUImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate, Ctor);
+
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPU"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "__getPointer"),
+              v8::FunctionTemplate::New(isolate, __GetPointer));
+
+    tmpl->Set(ConvertToV8String(isolate, "requestAdapter"),
+              v8::FunctionTemplate::New(isolate, &RequestAdapter));
+
+    cache->GPUTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void GPUImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+
+    auto ret = args.This();
+
+    auto instance = canvas_native_webgpu_instance_create();
+
+    auto object = new GPUImpl(instance);
+
+    ret->SetAlignedPointerInInternalField(0, object);
+
+    SetNativeType(ret, NativeType::GPUInstance);
+
+    object->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+}
+
+
+void GPUImpl::RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    GPUImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args[1].As<v8::Function>()->Call(context, context->Global(), 0, nullptr);
+        return;
+    }
+
+
+    CanvasGPURequestAdapterOptions opts{};
+    opts.force_fallback_adapter = false;
+    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceNone;
+    auto optionsValue = args[0];
+
+    if (optionsValue->IsObject()) {
+        auto options = optionsValue.As<v8::Object>();
+        v8::Local<v8::Value> ppValue;
+        options->Get(context, ConvertToV8String(isolate, "powerPreference")).ToLocal(&ppValue);
+        if (ppValue->IsNumber()) {
+            switch (ppValue->Int32Value(context).ToChecked()) {
+                case 1:
+                    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceLowPower;
+                    break;
+                case 2:
+                    opts.power_preference = CanvasGPUPowerPreference::CanvasGPUPowerPreferenceHighPerformance;
+                    break;
+                default:
+                    break;
+            }
+
+        }
+
+        v8::Local<v8::Value> forceFallbackValue;
+
+        options->Get(context, ConvertToV8String(isolate, "forceFallbackAdapter")).ToLocal(
+                &forceFallbackValue);
+
+
+        if (!forceFallbackValue.IsEmpty()) {
+            opts.force_fallback_adapter = forceFallbackValue->BooleanValue(isolate);
+        }
+    }
+
+    v8::Global<v8::Function> func(isolate, args[1].As<v8::Function>());
+    auto callback = new AsyncCallback{
+            isolate,
+            std::move(func)
+    };
+    canvas_native_webgpu_request_adapter(ptr->GetGPUInstance(), &opts,
+                                         [](const CanvasGPUAdapter *adapter, 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 (adapter != nullptr) {
+                                                         auto impl = new GPUAdapterImpl(adapter);
+                                                         auto ret = GPUAdapterImpl::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);
+                                                     } else {
+                                                         v8::Local<v8::Value> args[1] = {
+                                                                 v8::Null(isolate)};
+
+                                                         callback->Call(context, context->Global(),
+                                                                        1,
+                                                                        args);  // ignore JS return value
+                                                         delete static_cast<AsyncCallback *>(data);
+                                                     }
+                                                 }
+                                             }
+                                         }, callback);
+}
+
+
+void GPUImpl::__GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto pointer = (intptr_t *) ptr->GetGPUInstance();
+    auto ret = std::to_string((intptr_t) pointer);
+    args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+}

package/platforms/ios/src/cpp/webgpu/GPUImpl.h

@@ -0,0 +1,55 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUIMPL_H
+#define CANVAS_ANDROID_GPUIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "GPUAdapterImpl.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUImpl : ObjectWrapperImpl {
+public:
+    GPUImpl(const CanvasWebGPUInstance *instance);
+
+    ~GPUImpl() {
+        if (this->instance_ != nullptr) {
+            canvas_native_webgpu_instance_release(this->instance_);
+            this->instance_ = nullptr;
+        }
+    }
+
+    const CanvasWebGPUInstance *GetGPUInstance();
+
+    static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
+
+    static GPUImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUImpl *instance) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUInstance);
+        object->SetAlignedPointerInInternalField(0, instance);
+        instance->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void __GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+private:
+    const CanvasWebGPUInstance *instance_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUIMPL_H

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

@@ -0,0 +1,54 @@
+//
+// Created by Osei Fortune on 26/06/2024.
+//
+
+#include "GPUPipelineLayoutImpl.h"
+#include "Caches.h"
+
+GPUPipelineLayoutImpl::GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline) : pipeline_(
+        pipeline) {}
+
+const CanvasGPUPipelineLayout *GPUPipelineLayoutImpl::GetPipeline() {
+    return this->pipeline_;
+}
+
+
+void GPUPipelineLayoutImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUPipelineLayout"), func).FromJust();;
+}
+
+GPUPipelineLayoutImpl *GPUPipelineLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUPipelineLayoutImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUPipelineLayoutImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUPipelineLayoutTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUPipelineLayout"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    cache->GPUPipelineLayoutTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+

package/platforms/ios/src/cpp/webgpu/GPUPipelineLayoutImpl.h

@@ -0,0 +1,46 @@
+//
+// Created by Osei Fortune on 26/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H
+#define CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+
+class GPUPipelineLayoutImpl : ObjectWrapperImpl {
+public:
+    GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline);
+
+    ~GPUPipelineLayoutImpl() {
+        canvas_native_webgpu_pipeline_layout_release(this->GetPipeline());
+    }
+
+    const CanvasGPUPipelineLayout *GetPipeline();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUPipelineLayoutImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUPipelineLayoutImpl *device) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUPipelineLayoutImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUPipelineLayout);
+        object->SetAlignedPointerInInternalField(0, device);
+        device->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+
+private:
+    const CanvasGPUPipelineLayout *pipeline_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUPIPELINELAYOUTIMPL_H

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

@@ -0,0 +1,137 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#include "GPUQuerySetImpl.h"
+#include "Caches.h"
+
+GPUQuerySetImpl::GPUQuerySetImpl(const CanvasGPUQuerySet *querySet) : querySet_(querySet) {}
+
+const CanvasGPUQuerySet *GPUQuerySetImpl::GetQuerySet() {
+    return this->querySet_;
+}
+
+
+void GPUQuerySetImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUQuerySet"), func).FromJust();;
+}
+
+GPUQuerySetImpl *GPUQuerySetImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUQuerySetImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUQuerySetImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUQuerySetTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUQuerySet"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "count"),
+            GetCount
+    );
+
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "type"),
+            GetType
+    );
+
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
+
+    cache->GPUQuerySetTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+GPUQuerySetImpl::GetCount(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        info.GetReturnValue().Set(canvas_native_webgpu_query_set_get_count(ptr->GetQuerySet()));
+        return;
+    }
+
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUQuerySetImpl::GetType(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto type = canvas_native_webgpu_query_set_get_type(ptr->GetQuerySet());
+        switch (type) {
+            case CanvasQueryTypeOcclusion:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "occlusion"));
+                break;
+            case CanvasQueryTypeTimestamp:
+                info.GetReturnValue().Set(ConvertToV8String(isolate, "timestamp"));
+                break;
+        }
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+GPUQuerySetImpl::GetLabel(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_query_set_get_label(ptr->GetQuerySet());
+        if (label != nullptr) {
+            info.GetReturnValue().Set(ConvertToV8String(isolate, label));
+            canvas_native_string_destroy(label);
+            return;
+        }
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
+void GPUQuerySetImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    // todo
+
+}

package/platforms/ios/src/cpp/webgpu/GPUQuerySetImpl.h

@@ -0,0 +1,55 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUQUERYSETIMPL_H
+#define CANVAS_ANDROID_GPUQUERYSETIMPL_H
+
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUQuerySetImpl : ObjectWrapperImpl {
+public:
+    GPUQuerySetImpl(const CanvasGPUQuerySet *querySet);
+
+    ~GPUQuerySetImpl() {
+        canvas_native_webgpu_query_set_release(this->GetQuerySet());
+    }
+
+    const CanvasGPUQuerySet *GetQuerySet();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUQuerySetImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUQuerySetImpl *querySet) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUQuerySetImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUQuerySet);
+        object->SetAlignedPointerInInternalField(0, querySet);
+        querySet->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetType(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetCount(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPUQuerySet *querySet_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUQUERYSETIMPL_H