@encharm/cws 4.1.0 → 4.2.0

package/src/headers/{12/base64.h → 18/base64-inl.h}

@@ -1,50 +1,12 @@
-#ifndef SRC_BASE64_H_
-#define SRC_BASE64_H_
+#ifndef SRC_BASE64_INL_H_
+#define SRC_BASE64_INL_H_
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "base64.h"
 #include "util.h"
 
-#include <cstddef>
-#include <cstdint>
-
 namespace node {
-//// Base 64 ////
-static inline constexpr size_t base64_encoded_size(size_t size) {
-  return ((size + 2 - ((size + 2) % 3)) / 3 * 4);
-}
-
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-static inline size_t base64_decoded_size_fast(size_t size) {
-  size_t remainder = size % 4;
-
-  size = (size / 4) * 3;
-  if (remainder) {
-    if (size == 0 && remainder == 1) {
-      // special case: 1-byte input cannot be decoded
-      size = 0;
-    } else {
-      // non-padded input, add 1 or 2 extra bytes
-      size += 1 + (remainder == 3);
-    }
-  }
-
-  return size;
-}
-
-template <typename TypeName>
-size_t base64_decoded_size(const TypeName* src, size_t size) {
-  if (size == 0)
-    return 0;
-
-  if (src[size - 1] == '=')
-    size--;
-  if (size > 0 && src[size - 1] == '=')
-    size--;
-
-  return base64_decoded_size_fast(size);
-}
-
 
 extern const int8_t unbase64_table[256];
 
@@ -54,27 +16,36 @@ inline static int8_t unbase64(uint8_t x) {
 }
 
 
+inline uint32_t ReadUint32BE(const unsigned char* p) {
+  return static_cast<uint32_t>(p[0] << 24U) |
+         static_cast<uint32_t>(p[1] << 16U) |
+         static_cast<uint32_t>(p[2] << 8U) |
+         static_cast<uint32_t>(p[3]);
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// MSVC C4003: not enough actual parameters for macro 'identifier'
+#pragma warning(disable : 4003)
+#endif
+
 template <typename TypeName>
 bool base64_decode_group_slow(char* const dst, const size_t dstlen,
                               const TypeName* const src, const size_t srclen,
                               size_t* const i, size_t* const k) {
   uint8_t hi;
   uint8_t lo;
-#define V(expr)                                                               \
-  for (;;) {                                                                  \
-    const uint8_t c = src[*i];                                                \
-    lo = unbase64(c);                                                         \
-    *i += 1;                                                                  \
-    if (lo < 64)                                                              \
-      break;  /* Legal character. */                                          \
-    if (c == '=' || *i >= srclen)                                             \
-      return false;  /* Stop decoding. */                                     \
-  }                                                                           \
-  expr;                                                                       \
-  if (*i >= srclen)                                                           \
-    return false;                                                             \
-  if (*k >= dstlen)                                                           \
-    return false;                                                             \
+#define V(expr)                                                                \
+  for (;;) {                                                                   \
+    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
+    lo = unbase64(c);                                                          \
+    *i += 1;                                                                   \
+    if (lo < 64) break;                         /* Legal character. */         \
+    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
+  }                                                                            \
+  expr;                                                                        \
+  if (*i >= srclen) return false;                                              \
+  if (*k >= dstlen) return false;                                              \
   hi = lo;
   V(/* Nothing. */);
   V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
@@ -84,6 +55,9 @@ bool base64_decode_group_slow(char* const dst, const size_t dstlen,
   return true;  // Continue decoding.
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
 template <typename TypeName>
 size_t base64_decode_fast(char* const dst, const size_t dstlen,
@@ -95,11 +69,14 @@ size_t base64_decode_fast(char* const dst, const size_t dstlen,
   size_t i = 0;
   size_t k = 0;
   while (i < max_i && k < max_k) {
-    const uint32_t v =
-        unbase64(src[i + 0]) << 24 |
-        unbase64(src[i + 1]) << 16 |
-        unbase64(src[i + 2]) << 8 |
-        unbase64(src[i + 3]);
+    const unsigned char txt[] = {
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
+    };
+
+    const uint32_t v = ReadUint32BE(txt);
     // If MSB is set, input contains whitespace or is not valid base64.
     if (v & 0x80808080) {
       if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
@@ -120,6 +97,21 @@ size_t base64_decode_fast(char* const dst, const size_t dstlen,
 }
 
 
+template <typename TypeName>
+size_t base64_decoded_size(const TypeName* src, size_t size) {
+  // 1-byte input cannot be decoded
+  if (size < 2)
+    return 0;
+
+  if (src[size - 1] == '=') {
+    size--;
+    if (src[size - 1] == '=')
+      size--;
+  }
+  return base64_decoded_size_fast(size);
+}
+
+
 template <typename TypeName>
 size_t base64_decode(char* const dst, const size_t dstlen,
                      const TypeName* const src, const size_t srclen) {
@@ -127,15 +119,17 @@ size_t base64_decode(char* const dst, const size_t dstlen,
   return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
 }
 
-static size_t base64_encode(const char* src,
+
+inline size_t base64_encode(const char* src,
                             size_t slen,
                             char* dst,
-                            size_t dlen) {
+                            size_t dlen,
+                            Base64Mode mode) {
   // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen) &&
+  CHECK(dlen >= base64_encoded_size(slen, mode) &&
         "not enough space provided for base64 encode");
 
-  dlen = base64_encoded_size(slen);
+  dlen = base64_encoded_size(slen, mode);
 
   unsigned a;
   unsigned b;
@@ -144,9 +138,7 @@ static size_t base64_encode(const char* src,
   unsigned k;
   unsigned n;
 
-  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                              "abcdefghijklmnopqrstuvwxyz"
-                              "0123456789+/";
+  const char* table = base64_select_table(mode);
 
   i = 0;
   k = 0;
@@ -166,32 +158,32 @@ static size_t base64_encode(const char* src,
     k += 4;
   }
 
-  if (n != slen) {
-    switch (slen - n) {
-      case 1:
-        a = src[i + 0] & 0xff;
-        dst[k + 0] = table[a >> 2];
-        dst[k + 1] = table[(a & 3) << 4];
+  switch (slen - n) {
+    case 1:
+      a = src[i + 0] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[(a & 3) << 4];
+      if (mode == Base64Mode::NORMAL) {
         dst[k + 2] = '=';
         dst[k + 3] = '=';
-        break;
-
-      case 2:
-        a = src[i + 0] & 0xff;
-        b = src[i + 1] & 0xff;
-        dst[k + 0] = table[a >> 2];
-        dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
-        dst[k + 2] = table[(b & 0x0f) << 2];
+      }
+      break;
+    case 2:
+      a = src[i + 0] & 0xff;
+      b = src[i + 1] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
+      dst[k + 2] = table[(b & 0x0f) << 2];
+      if (mode == Base64Mode::NORMAL)
         dst[k + 3] = '=';
-        break;
-    }
+      break;
   }
 
   return dlen;
 }
-}  // namespace node
 
+}  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#endif  // SRC_BASE64_H_
+#endif  // SRC_BASE64_INL_H_

package/src/headers/18/base64.h

@@ -0,0 +1,69 @@
+#ifndef SRC_BASE64_H_
+#define SRC_BASE64_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+
+namespace node {
+//// Base 64 ////
+
+enum class Base64Mode {
+  NORMAL,
+  URL
+};
+
+static constexpr char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                       "abcdefghijklmnopqrstuvwxyz"
+                                       "0123456789+/";
+
+static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                           "abcdefghijklmnopqrstuvwxyz"
+                                           "0123456789-_";
+
+static inline const char* base64_select_table(Base64Mode mode) {
+  switch (mode) {
+    case Base64Mode::NORMAL: return base64_table;
+    case Base64Mode::URL: return base64_table_url;
+    default: UNREACHABLE();
+  }
+}
+
+static inline constexpr size_t base64_encoded_size(
+    size_t size,
+    Base64Mode mode = Base64Mode::NORMAL) {
+  return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
+                                    : static_cast<size_t>(std::ceil(
+                                          static_cast<double>(size * 4) / 3));
+}
+
+// Doesn't check for padding at the end.  Can be 1-2 bytes over.
+static inline constexpr size_t base64_decoded_size_fast(size_t size) {
+  // 1-byte input cannot be decoded
+  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
+}
+
+inline uint32_t ReadUint32BE(const unsigned char* p);
+
+template <typename TypeName>
+size_t base64_decoded_size(const TypeName* src, size_t size);
+
+template <typename TypeName>
+size_t base64_decode(char* const dst, const size_t dstlen,
+                     const TypeName* const src, const size_t srclen);
+
+inline size_t base64_encode(const char* src,
+                            size_t slen,
+                            char* dst,
+                            size_t dlen,
+                            Base64Mode mode = Base64Mode::NORMAL);
+}  // namespace node
+
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE64_H_

package/src/headers/{12 → 18}/base_object-inl.h

@@ -28,14 +28,7 @@
 #include "env-inl.h"
 #include "util.h"
 
-#if (__GNUC__ >= 8) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-function-type"
-#endif
 #include "v8.h"
-#if (__GNUC__ >= 8) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
 
 namespace node {
 
@@ -90,7 +83,8 @@ v8::Local<v8::Object> BaseObject::object() const {
 v8::Local<v8::Object> BaseObject::object(v8::Isolate* isolate) const {
   v8::Local<v8::Object> handle = object();
 
-  DCHECK_EQ(handle->CreationContext()->GetIsolate(), isolate);
+  DCHECK_EQ(handle->GetCreationContext().ToLocalChecked()->GetIsolate(),
+            isolate);
   DCHECK_EQ(env()->isolate(), isolate);
 
   return handle;
@@ -100,15 +94,16 @@ Environment* BaseObject::env() const {
   return env_;
 }
 
-BaseObject* BaseObject::FromJSObject(v8::Local<v8::Object> obj) {
-  CHECK_GT(obj->InternalFieldCount(), 0);
+BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+  DCHECK_GE(obj->InternalFieldCount(), BaseObject::kSlot);
   return static_cast<BaseObject*>(
       obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
 }
 
 
 template <typename T>
-T* BaseObject::FromJSObject(v8::Local<v8::Object> object) {
+T* BaseObject::FromJSObject(v8::Local<v8::Value> object) {
   return static_cast<T*>(FromJSObject(object));
 }
 
@@ -145,16 +140,26 @@ void BaseObject::ClearWeak() {
   persistent_handle_.ClearWeak();
 }
 
+bool BaseObject::IsWeakOrDetached() const {
+  if (persistent_handle_.IsWeak()) return true;
+
+  if (!has_pointer_data()) return false;
+  const PointerData* pd = const_cast<BaseObject*>(this)->pointer_data();
+  return pd->wants_weak_jsobj || pd->is_detached;
+}
+
+void BaseObject::LazilyInitializedJSTemplateConstructor(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  DCHECK(args.IsConstructCall());
+  DCHECK_GT(args.This()->InternalFieldCount(), 0);
+  args.This()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
+}
 
 v8::Local<v8::FunctionTemplate>
 BaseObject::MakeLazilyInitializedJSTemplate(Environment* env) {
-  auto constructor = [](const v8::FunctionCallbackInfo<v8::Value>& args) {
-    DCHECK(args.IsConstructCall());
-    DCHECK_GT(args.This()->InternalFieldCount(), 0);
-    args.This()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
-  };
-
-  v8::Local<v8::FunctionTemplate> t = env->NewFunctionTemplate(constructor);
+  v8::Local<v8::FunctionTemplate> t =
+      env->NewFunctionTemplate(LazilyInitializedJSTemplateConstructor);
+  t->Inherit(BaseObject::GetConstructorTemplate(env));
   t->InstanceTemplate()->SetInternalFieldCount(
       BaseObject::kInternalFieldCount);
   return t;
@@ -198,7 +203,7 @@ void BaseObject::decrease_refcount() {
   unsigned int new_refcount = --metadata->strong_ptr_count;
   if (new_refcount == 0) {
     if (metadata->is_detached) {
-      delete this;
+      OnGCCollect();
     } else if (metadata->wants_weak_jsobj && !persistent_handle_.IsEmpty()) {
       MakeWeak();
     }
@@ -216,20 +221,22 @@ BaseObject::PointerData*
 BaseObjectPtrImpl<T, kIsWeak>::pointer_data() const {
   if (kIsWeak) {
     return data_.pointer_data;
-  } else {
-    if (get_base_object() == nullptr) return nullptr;
-    return get_base_object()->pointer_data();
   }
+  if (get_base_object() == nullptr) {
+    return nullptr;
+  }
+  return get_base_object()->pointer_data();
 }
 
 template <typename T, bool kIsWeak>
 BaseObject* BaseObjectPtrImpl<T, kIsWeak>::get_base_object() const {
   if (kIsWeak) {
-    if (pointer_data() == nullptr) return nullptr;
+    if (pointer_data() == nullptr) {
+      return nullptr;
+    }
     return pointer_data()->self;
-  } else {
-    return data_.target;
   }
+  return data_.target;
 }
 
 template <typename T, bool kIsWeak>
@@ -334,6 +341,20 @@ BaseObjectPtrImpl<T, kIsWeak>::operator bool() const {
   return get() != nullptr;
 }
 
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+bool BaseObjectPtrImpl<T, kIsWeak>::operator ==(
+    const BaseObjectPtrImpl<U, kW>& other) const {
+  return get() == other.get();
+}
+
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+bool BaseObjectPtrImpl<T, kIsWeak>::operator !=(
+    const BaseObjectPtrImpl<U, kW>& other) const {
+  return get() != other.get();
+}
+
 template <typename T, typename... Args>
 BaseObjectPtr<T> MakeBaseObject(Args&&... args) {
   return BaseObjectPtr<T>(new T(std::forward<Args>(args)...));

package/src/headers/{12 → 18}/base_object.h

@@ -24,9 +24,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <type_traits>  // std::remove_reference
 #include "memory_tracker.h"
 #include "v8.h"
-#include <type_traits>  // std::remove_reference
 
 namespace node {
 
@@ -34,6 +34,10 @@ class Environment;
 template <typename T, bool kIsWeak>
 class BaseObjectPtrImpl;
 
+namespace worker {
+class TransferData;
+}
+
 class BaseObject : public MemoryRetainer {
  public:
   enum InternalFields { kSlot, kInternalFieldCount };
@@ -61,9 +65,11 @@ class BaseObject : public MemoryRetainer {
   // was also passed to the `BaseObject()` constructor initially.
   // This may return `nullptr` if the C++ object has not been constructed yet,
   // e.g. when the JS object used `MakeLazilyInitializedJSTemplate`.
-  static inline BaseObject* FromJSObject(v8::Local<v8::Object> object);
+  static inline void LazilyInitializedJSTemplateConstructor(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static inline BaseObject* FromJSObject(v8::Local<v8::Value> object);
   template <typename T>
-  static inline T* FromJSObject(v8::Local<v8::Object> object);
+  static inline T* FromJSObject(v8::Local<v8::Value> object);
 
   // Make the `v8::Global` a weak reference and, `delete` this object once
   // the JS object has been garbage collected and there are no (strong)
@@ -74,6 +80,11 @@ class BaseObject : public MemoryRetainer {
   // root and will not be touched by the garbage collector.
   inline void ClearWeak();
 
+  // Reports whether this BaseObject is using a weak reference or detached,
+  // i.e. whether is can be deleted by GC once no strong BaseObjectPtrs refer
+  // to it anymore.
+  inline bool IsWeakOrDetached() const;
+
   // Utility to create a FunctionTemplate with one internal field (used for
   // the `BaseObject*` pointer) and a constructor that initializes that field
   // to `nullptr`.
@@ -84,7 +95,7 @@ class BaseObject : public MemoryRetainer {
   template <int Field>
   static void InternalFieldGet(v8::Local<v8::String> property,
                                const v8::PropertyCallbackInfo<v8::Value>& info);
-  template <int Field, bool (v8::Value::* typecheck)() const>
+  template <int Field, bool (v8::Value::*typecheck)() const>
   static void InternalFieldSet(v8::Local<v8::String> property,
                                v8::Local<v8::Value> value,
                                const v8::PropertyCallbackInfo<void>& info);
@@ -92,24 +103,75 @@ class BaseObject : public MemoryRetainer {
   // This is a bit of a hack. See the override in async_wrap.cc for details.
   virtual bool IsDoneInitializing() const;
 
-  // Can be used to avoid this object keepling itself alive as a GC root
+  // Can be used to avoid this object keeping itself alive as a GC root
   // indefinitely, for example when this object is owned and deleted by another
   // BaseObject once that is torn down. This can only be called when there is
   // a BaseObjectPtr to this object.
   inline void Detach();
 
- protected:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  // Interface for transferring BaseObject instances using the .postMessage()
+  // method of MessagePorts (and, by extension, Workers).
+  // GetTransferMode() returns a transfer mode that indicates how to deal with
+  // the current object:
+  // - kUntransferable:
+  //     No transfer is possible, either because this type of BaseObject does
+  //     not know how to be transferred, or because it is not in a state in
+  //     which it is possible to do so (e.g. because it has already been
+  //     transferred).
+  // - kTransferable:
+  //     This object can be transferred in a destructive fashion, i.e. will be
+  //     rendered unusable on the sending side of the channel in the process
+  //     of being transferred. (In C++ this would be referred to as movable but
+  //     not copyable.) Objects of this type need to be listed in the
+  //     `transferList` argument of the relevant postMessage() call in order to
+  //     make sure that they are not accidentally destroyed on the sending side.
+  //     TransferForMessaging() will be called to get a representation of the
+  //     object that is used for subsequent deserialization.
+  //     The NestedTransferables() method can be used to transfer other objects
+  //     along with this one, if a situation requires it.
+  // - kCloneable:
+  //     This object can be cloned without being modified.
+  //     CloneForMessaging() will be called to get a representation of the
+  //     object that is used for subsequent deserialization, unless the
+  //     object is listed in transferList, in which case TransferForMessaging()
+  //     is attempted first.
+  // After a successful clone, FinalizeTransferRead() is called on the receiving
+  // end, and can read deserialize JS data possibly serialized by a previous
+  // FinalizeTransferWrite() call.
+  enum class TransferMode {
+    kUntransferable,
+    kTransferable,
+    kCloneable
+  };
+  virtual TransferMode GetTransferMode() const;
+  virtual std::unique_ptr<worker::TransferData> TransferForMessaging();
+  virtual std::unique_ptr<worker::TransferData> CloneForMessaging() const;
+  virtual v8::Maybe<std::vector<BaseObjectPtrImpl<BaseObject, false>>>
+      NestedTransferables() const;
+  virtual v8::Maybe<bool> FinalizeTransferRead(
+      v8::Local<v8::Context> context, v8::ValueDeserializer* deserializer);
+
+  // Indicates whether this object is expected to use a strong reference during
+  // a clean process exit (due to an empty event loop).
+  virtual bool IsNotIndicativeOfMemoryLeakAtExit() const;
+
   virtual inline void OnGCCollect();
 
+  virtual inline bool is_snapshotable() const { return false; }
+
  private:
   v8::Local<v8::Object> WrappedObject() const override;
+  bool IsRootNode() const override;
   static void DeleteMe(void* data);
 
   // persistent_handle_ needs to be at a fixed offset from the start of the
   // class because it is used by src/node_postmortem_metadata.cc to calculate
   // offsets and generate debug symbols for BaseObject, which assumes that the
   // position of members in memory are predictable. For more information please
-  // refer to `doc/guides/node-postmortem-support.md`
+  // refer to `doc/contributing/node-postmortem-support.md`
   friend int GenDebugSymbols();
   friend class CleanupHookCallback;
   template <typename T, bool kIsWeak>
@@ -131,7 +193,7 @@ class BaseObject : public MemoryRetainer {
     // Indicates whether MakeWeak() has been called.
     bool wants_weak_jsobj = false;
     // Indicates whether Detach() has been called. If that is the case, this
-    // object will be destryoed once the strong pointer count drops to zero.
+    // object will be destroyed once the strong pointer count drops to zero.
     bool is_detached = false;
     // Reference to the original BaseObject. This is used by weak pointers.
     BaseObject* self = nullptr;
@@ -152,17 +214,15 @@ class BaseObject : public MemoryRetainer {
 
 // Global alias for FromJSObject() to avoid churn.
 template <typename T>
-inline T* Unwrap(v8::Local<v8::Object> obj) {
+inline T* Unwrap(v8::Local<v8::Value> obj) {
   return BaseObject::FromJSObject<T>(obj);
 }
 
-
-#define ASSIGN_OR_RETURN_UNWRAP(ptr, obj, ...)                                \
-  do {                                                                        \
-    *ptr = static_cast<typename std::remove_reference<decltype(*ptr)>::type>( \
-        BaseObject::FromJSObject(obj));                                       \
-    if (*ptr == nullptr)                                                      \
-      return __VA_ARGS__;                                                     \
+#define ASSIGN_OR_RETURN_UNWRAP(ptr, obj, ...)                                 \
+  do {                                                                         \
+    *ptr = static_cast<typename std::remove_reference<decltype(*ptr)>::type>(  \
+        BaseObject::FromJSObject(obj));                                        \
+    if (*ptr == nullptr) return __VA_ARGS__;                                   \
   } while (0)
 
 // Implementation of a generic strong or weak pointer to a BaseObject.
@@ -196,9 +256,14 @@ class BaseObjectPtrImpl final {
   inline T* operator->() const;
   inline operator bool() const;
 
+  template <typename U, bool kW>
+  inline bool operator ==(const BaseObjectPtrImpl<U, kW>& other) const;
+  template <typename U, bool kW>
+  inline bool operator !=(const BaseObjectPtrImpl<U, kW>& other) const;
+
  private:
   union {
-    BaseObject* target;  // Used for strong pointers.
+    BaseObject* target;                     // Used for strong pointers.
     BaseObject::PointerData* pointer_data;  // Used for weak pointers.
   } data_;
 

package/src/headers/{12 → 18}/callback_queue-inl.h

@@ -10,8 +10,8 @@ namespace node {
 template <typename R, typename... Args>
 template <typename Fn>
 std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
-CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, bool refed) {
-  return std::make_unique<CallbackImpl<Fn>>(std::move(fn), refed);
+CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
+  return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
 }
 
 template <typename R, typename... Args>
@@ -22,8 +22,8 @@ CallbackQueue<R, Args...>::Shift() {
     head_ = ret->get_next();
     if (!head_)
       tail_ = nullptr;  // The queue is now empty.
+    size_--;
   }
-  size_--;
   return ret;
 }
 
@@ -57,12 +57,12 @@ size_t CallbackQueue<R, Args...>::size() const {
 }
 
 template <typename R, typename... Args>
-CallbackQueue<R, Args...>::Callback::Callback(bool refed)
-  : refed_(refed) {}
+CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
+  : flags_(flags) {}
 
 template <typename R, typename... Args>
-bool CallbackQueue<R, Args...>::Callback::is_refed() const {
-  return refed_;
+CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
+  return flags_;
 }
 
 template <typename R, typename... Args>
@@ -80,8 +80,8 @@ void CallbackQueue<R, Args...>::Callback::set_next(
 template <typename R, typename... Args>
 template <typename Fn>
 CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
-    Fn&& callback, bool refed)
-  : Callback(refed),
+    Fn&& callback, CallbackFlags::Flags flags)
+  : Callback(flags),
     callback_(std::move(callback)) {}
 
 template <typename R, typename... Args>