wasmer-napi 0.702.0

NAPI library for Wasmer WebAssembly runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include "internal/napi_ref.h"

#include <new>

#include "internal/napi_lifetime_tracker.h"
#include "internal/napi_v8_env.h"

namespace {

inline bool CanBeHeldWeakly(v8::Local<v8::Value> value) {
  return value->IsObject() || value->IsSymbol();
}

}  // namespace

napi_ref__::napi_ref__(napi_env__* env,
                       v8::Local<v8::Value> value,
                       uint32_t initial_refcount,
                       napi_ref_ownership__ ownership)
    : env_(env),
      value_(env->isolate, value),
      refcount_(initial_refcount),
      ownership_(ownership),
      can_be_weak_(CanBeHeldWeakly(value)) {
  if (refcount_ == 0) {
    SetWeak();
  }
}

napi_ref__::~napi_ref__() {
  if (!value_.IsEmpty() && can_be_weak_ && refcount_ == 0) {
    value_.ClearWeak();
  }
  value_.Reset();
  Unlink();
}

napi_ref__* napi_ref__::New(napi_env__* env,
                            v8::Local<v8::Value> value,
                            uint32_t initial_refcount,
                            napi_ref_ownership__ ownership) {
  napi_ref__* reference = env->allocate<napi_ref__>(
      env, value, initial_refcount, ownership);
  if (reference != nullptr) {
    reference->Link(&env->reflist);
  }
  return reference;
}

void napi_ref__::Destroy() {
  napi_env__* env = env_;
  if (env != nullptr) {
    env->release(this);
  }
}

uint32_t napi_ref__::Ref() {
  if (value_.IsEmpty()) {
    return 0;
  }
  if (++refcount_ == 1 && can_be_weak_) {
    value_.ClearWeak();
  }
  return refcount_;
}

uint32_t napi_ref__::Unref() {
  if (value_.IsEmpty() || refcount_ == 0) {
    return 0;
  }
  if (--refcount_ == 0) {
    SetWeak();
  }
  return refcount_;
}

v8::Local<v8::Value> napi_ref__::Get() const {
  if (env_ == nullptr || value_.IsEmpty()) {
    return v8::Local<v8::Value>();
  }
  return value_.Get(env_->isolate);
}

void napi_ref__::Invalidate() {
  if (!value_.IsEmpty()) {
    if (can_be_weak_ && refcount_ == 0) {
      value_.ClearWeak();
    }
    value_.Reset();
  }
  Unlink();
}

void napi_ref__::Finalize() {
  value_.Reset();
  bool deleteMe = ownership_ == napi_ref_ownership__::kRuntime;
  Unlink();
  CallUserFinalizer();
  if (deleteMe) {
    Destroy();
  }
}

void napi_ref__::InvokeFinalizerFromGC() {
  Finalize();
}

void napi_ref__::SetWeak() {
  if (can_be_weak_) {
    value_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
  } else {
    value_.Reset();
  }
}

void napi_ref__::WeakCallback(const v8::WeakCallbackInfo<napi_ref__>& info) {
  napi_ref__* ref = info.GetParameter();
  if (ref == nullptr) return;
  ref->value_.Reset();
  ref->InvokeFinalizerFromGC();
}