@encharm/cws 4.4.1 → 4.5.2

package/src/headers/18/node_http2_state.h

@@ -1,149 +0,0 @@
-#ifndef SRC_NODE_HTTP2_STATE_H_
-#define SRC_NODE_HTTP2_STATE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_buffer.h"
-
-struct nghttp2_rcbuf;
-
-namespace node {
-namespace http2 {
-
-  enum Http2SettingsIndex {
-    IDX_SETTINGS_HEADER_TABLE_SIZE,
-    IDX_SETTINGS_ENABLE_PUSH,
-    IDX_SETTINGS_INITIAL_WINDOW_SIZE,
-    IDX_SETTINGS_MAX_FRAME_SIZE,
-    IDX_SETTINGS_MAX_CONCURRENT_STREAMS,
-    IDX_SETTINGS_MAX_HEADER_LIST_SIZE,
-    IDX_SETTINGS_ENABLE_CONNECT_PROTOCOL,
-    IDX_SETTINGS_COUNT
-  };
-
-  enum Http2SessionStateIndex {
-    IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE,
-    IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH,
-    IDX_SESSION_STATE_NEXT_STREAM_ID,
-    IDX_SESSION_STATE_LOCAL_WINDOW_SIZE,
-    IDX_SESSION_STATE_LAST_PROC_STREAM_ID,
-    IDX_SESSION_STATE_REMOTE_WINDOW_SIZE,
-    IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE,
-    IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE,
-    IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE,
-    IDX_SESSION_STATE_COUNT
-  };
-
-  enum Http2StreamStateIndex {
-    IDX_STREAM_STATE,
-    IDX_STREAM_STATE_WEIGHT,
-    IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT,
-    IDX_STREAM_STATE_LOCAL_CLOSE,
-    IDX_STREAM_STATE_REMOTE_CLOSE,
-    IDX_STREAM_STATE_LOCAL_WINDOW_SIZE,
-    IDX_STREAM_STATE_COUNT
-  };
-
-  enum Http2OptionsIndex {
-    IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE,
-    IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS,
-    IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH,
-    IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS,
-    IDX_OPTIONS_PADDING_STRATEGY,
-    IDX_OPTIONS_MAX_HEADER_LIST_PAIRS,
-    IDX_OPTIONS_MAX_OUTSTANDING_PINGS,
-    IDX_OPTIONS_MAX_OUTSTANDING_SETTINGS,
-    IDX_OPTIONS_MAX_SESSION_MEMORY,
-    IDX_OPTIONS_MAX_SETTINGS,
-    IDX_OPTIONS_FLAGS
-  };
-
-  enum Http2StreamStatisticsIndex {
-    IDX_STREAM_STATS_ID,
-    IDX_STREAM_STATS_TIMETOFIRSTBYTE,
-    IDX_STREAM_STATS_TIMETOFIRSTHEADER,
-    IDX_STREAM_STATS_TIMETOFIRSTBYTESENT,
-    IDX_STREAM_STATS_SENTBYTES,
-    IDX_STREAM_STATS_RECEIVEDBYTES,
-    IDX_STREAM_STATS_COUNT
-  };
-
-  enum Http2SessionStatisticsIndex {
-    IDX_SESSION_STATS_TYPE,
-    IDX_SESSION_STATS_PINGRTT,
-    IDX_SESSION_STATS_FRAMESRECEIVED,
-    IDX_SESSION_STATS_FRAMESSENT,
-    IDX_SESSION_STATS_STREAMCOUNT,
-    IDX_SESSION_STATS_STREAMAVERAGEDURATION,
-    IDX_SESSION_STATS_DATA_SENT,
-    IDX_SESSION_STATS_DATA_RECEIVED,
-    IDX_SESSION_STATS_MAX_CONCURRENT_STREAMS,
-    IDX_SESSION_STATS_COUNT
-  };
-
-class Http2State : public BaseObject {
- public:
-  Http2State(Environment* env, v8::Local<v8::Object> obj)
-      : BaseObject(env, obj),
-        root_buffer(env->isolate(), sizeof(http2_state_internal)),
-        session_state_buffer(
-            env->isolate(),
-            offsetof(http2_state_internal, session_state_buffer),
-            IDX_SESSION_STATE_COUNT,
-            root_buffer),
-        stream_state_buffer(
-            env->isolate(),
-            offsetof(http2_state_internal, stream_state_buffer),
-            IDX_STREAM_STATE_COUNT,
-            root_buffer),
-        stream_stats_buffer(
-            env->isolate(),
-            offsetof(http2_state_internal, stream_stats_buffer),
-            IDX_STREAM_STATS_COUNT,
-            root_buffer),
-        session_stats_buffer(
-            env->isolate(),
-            offsetof(http2_state_internal, session_stats_buffer),
-            IDX_SESSION_STATS_COUNT,
-            root_buffer),
-        options_buffer(env->isolate(),
-                        offsetof(http2_state_internal, options_buffer),
-                        IDX_OPTIONS_FLAGS + 1,
-                        root_buffer),
-        settings_buffer(env->isolate(),
-                        offsetof(http2_state_internal, settings_buffer),
-                        IDX_SETTINGS_COUNT + 1,
-                        root_buffer) {}
-
-  AliasedUint8Array root_buffer;
-  AliasedFloat64Array session_state_buffer;
-  AliasedFloat64Array stream_state_buffer;
-  AliasedFloat64Array stream_stats_buffer;
-  AliasedFloat64Array session_stats_buffer;
-  AliasedUint32Array options_buffer;
-  AliasedUint32Array settings_buffer;
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_SELF_SIZE(Http2State)
-  SET_MEMORY_INFO_NAME(Http2State)
-
-  static constexpr FastStringKey type_name { "http2" };
-
- private:
-  struct http2_state_internal {
-    // doubles first so that they are always sizeof(double)-aligned
-    double session_state_buffer[IDX_SESSION_STATE_COUNT];
-    double stream_state_buffer[IDX_STREAM_STATE_COUNT];
-    double stream_stats_buffer[IDX_STREAM_STATS_COUNT];
-    double session_stats_buffer[IDX_SESSION_STATS_COUNT];
-    uint32_t options_buffer[IDX_OPTIONS_FLAGS + 1];
-    uint32_t settings_buffer[IDX_SETTINGS_COUNT + 1];
-  };
-};
-
-}  // namespace http2
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_HTTP2_STATE_H_

package/src/headers/18/node_mem-inl.h

@@ -1,112 +0,0 @@
-#ifndef SRC_NODE_MEM_INL_H_
-#define SRC_NODE_MEM_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_mem.h"
-#include "node_internals.h"
-
-namespace node {
-namespace mem {
-
-template <typename Class, typename AllocatorStruct>
-AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() {
-  return AllocatorStruct {
-    static_cast<void*>(static_cast<Class*>(this)),
-    MallocImpl,
-    FreeImpl,
-    CallocImpl,
-    ReallocImpl
-  };
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
-                                             size_t size,
-                                             void* user_data) {
-  Class* manager = static_cast<Class*>(user_data);
-
-  size_t previous_size = 0;
-  char* original_ptr = nullptr;
-
-  // We prepend each allocated buffer with a size_t containing the full
-  // size of the allocation.
-  if (size > 0) size += sizeof(size_t);
-
-  if (ptr != nullptr) {
-    // We are free()ing or re-allocating.
-    original_ptr = static_cast<char*>(ptr) - sizeof(size_t);
-    previous_size = *reinterpret_cast<size_t*>(original_ptr);
-    // This means we called StopTracking() on this pointer before.
-    if (previous_size == 0) {
-      // Fall back to the standard Realloc() function.
-      char* ret = UncheckedRealloc(original_ptr, size);
-      if (ret != nullptr)
-        ret += sizeof(size_t);
-      return ret;
-    }
-  }
-
-  manager->CheckAllocatedSize(previous_size);
-
-  char* mem = UncheckedRealloc(original_ptr, size);
-
-  if (mem != nullptr) {
-    // Adjust the memory info counter.
-    // TODO(addaleax): Avoid the double bookkeeping we do with
-    // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory
-    // and provide versions of our memory allocation utilities that take an
-    // Environment*/Isolate* parameter and call the V8 method transparently.
-    const int64_t new_size = size - previous_size;
-    manager->IncreaseAllocatedSize(new_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        new_size);
-    *reinterpret_cast<size_t*>(mem) = size;
-    mem += sizeof(size_t);
-  } else if (size == 0) {
-    manager->DecreaseAllocatedSize(previous_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        -static_cast<int64_t>(previous_size));
-  }
-  return mem;
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) {
-  return ReallocImpl(nullptr, size, user_data);
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) {
-  if (ptr == nullptr) return;
-  CHECK_NULL(ReallocImpl(ptr, 0, user_data));
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb,
-                                            size_t size,
-                                            void* user_data) {
-  size_t real_size = MultiplyWithOverflowCheck(nmemb, size);
-  void* mem = MallocImpl(real_size, user_data);
-  if (mem != nullptr)
-    memset(mem, 0, real_size);
-  return mem;
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
-  size_t* original_ptr = reinterpret_cast<size_t*>(
-      static_cast<char*>(ptr) - sizeof(size_t));
-  Class* manager = static_cast<Class*>(this);
-  manager->DecreaseAllocatedSize(*original_ptr);
-  manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-      -static_cast<int64_t>(*original_ptr));
-  *original_ptr = 0;
-}
-
-}  // namespace mem
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_MEM_INL_H_

package/src/headers/18/node_native_module.h

@@ -1,109 +0,0 @@
-#ifndef SRC_NODE_NATIVE_MODULE_H_
-#define SRC_NODE_NATIVE_MODULE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include "node_mutex.h"
-#include "node_union_bytes.h"
-#include "v8.h"
-
-// Forward declare test fixture for `friend` declaration.
-class PerProcessTest;
-
-namespace node {
-class SnapshotBuilder;
-namespace native_module {
-
-using NativeModuleRecordMap = std::map<std::string, UnionBytes>;
-using NativeModuleCacheMap =
-    std::unordered_map<std::string,
-                       std::unique_ptr<v8::ScriptCompiler::CachedData>>;
-
-struct CodeCacheInfo {
-  std::string id;
-  std::vector<uint8_t> data;
-};
-
-// The native (C++) side of the NativeModule in JS land, which
-// handles compilation and caching of builtin modules (NativeModule)
-// and bootstrappers, whose source are bundled into the binary
-// as static data.
-// This class should not depend on any Environment, or depend on access to
-// the its own singleton - that should be encapsulated in NativeModuleEnv
-// instead.
-class NODE_EXTERN_PRIVATE NativeModuleLoader {
- public:
-  NativeModuleLoader(const NativeModuleLoader&) = delete;
-  NativeModuleLoader& operator=(const NativeModuleLoader&) = delete;
-
- private:
-  // Only allow access from friends.
-  friend class NativeModuleEnv;
-  friend class CodeCacheBuilder;
-
-  NativeModuleLoader();
-  static NativeModuleLoader* GetInstance();
-
-  // Generated by tools/js2c.py as node_javascript.cc
-  void LoadJavaScriptSource();  // Loads data into source_
-  UnionBytes GetConfig();       // Return data for config.gypi
-
-  bool Exists(const char* id);
-  bool Add(const char* id, const UnionBytes& source);
-
-  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
-  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
-  std::vector<std::string> GetModuleIds();
-
-  struct ModuleCategories {
-    bool is_initialized = false;
-    std::set<std::string> can_be_required;
-    std::set<std::string> cannot_be_required;
-  };
-  void InitializeModuleCategories();
-  const std::set<std::string>& GetCannotBeRequired();
-  const std::set<std::string>& GetCanBeRequired();
-
-  bool CanBeRequired(const char* id);
-  bool CannotBeRequired(const char* id);
-
-  NativeModuleCacheMap* code_cache();
-  const Mutex& code_cache_mutex() const { return code_cache_mutex_; }
-
-  v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
-  enum class Result { kWithCache, kWithoutCache };
-  v8::MaybeLocal<v8::String> LoadBuiltinModuleSource(v8::Isolate* isolate,
-                                                     const char* id);
-  // If an exception is encountered (e.g. source code contains
-  // syntax error), the returned value is empty.
-  v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Result* result);
-  v8::MaybeLocal<v8::Function> CompileAsModule(v8::Local<v8::Context> context,
-                                               const char* id,
-                                               Result* result);
-
-  static NativeModuleLoader instance_;
-  ModuleCategories module_categories_;
-  NativeModuleRecordMap source_;
-  NativeModuleCacheMap code_cache_;
-  UnionBytes config_;
-
-  // Used to synchronize access to the code cache map
-  Mutex code_cache_mutex_;
-
-  friend class ::PerProcessTest;
-};
-}  // namespace native_module
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_NATIVE_MODULE_H_

package/src/headers/18/node_native_module_env.h

@@ -1,71 +0,0 @@
-#ifndef SRC_NODE_NATIVE_MODULE_ENV_H_
-#define SRC_NODE_NATIVE_MODULE_ENV_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <vector>
-#include "node_native_module.h"
-
-namespace node {
-class Environment;
-class ExternalReferenceRegistry;
-namespace native_module {
-
-// TODO(joyeecheung): since it's safer to make the code cache part of the
-// embedded snapshot, there is no need to separate NativeModuleEnv and
-// NativeModuleLoader. Merge the two.
-class NativeModuleEnv {
- public:
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-
-  static v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Environment* optional_env);
-
-  static v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
-  // Returns config.gypi as a JSON string
-  static v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
-  static bool Exists(const char* id);
-  static bool Add(const char* id, const UnionBytes& source);
-
-  static bool CompileAllModules(v8::Local<v8::Context> context);
-  static void RefreshCodeCache(const std::vector<CodeCacheInfo>& in);
-  static void CopyCodeCache(std::vector<CodeCacheInfo>* out);
-
- private:
-  static void RecordResult(const char* id,
-                           NativeModuleLoader::Result result,
-                           Environment* env);
-  static void GetModuleCategories(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  // Passing ids of builtin module source code into JS land as
-  // internalBinding('native_module').moduleIds
-  static void ModuleIdsGetter(v8::Local<v8::Name> property,
-                              const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Passing config.gypi into JS land as internalBinding('native_module').config
-  static void ConfigStringGetter(
-      v8::Local<v8::Name> property,
-      const v8::PropertyCallbackInfo<v8::Value>& info);
-  // Compile a specific native module as a function
-  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void HasCachedBuiltins(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static bool has_code_cache_;
-};
-
-}  // namespace native_module
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_NATIVE_MODULE_ENV_H_

package/src/headers/18/node_object_wrap.h

@@ -1,132 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_NODE_OBJECT_WRAP_H_
-#define SRC_NODE_OBJECT_WRAP_H_
-
-#include "v8.h"
-#include <cassert>
-
-
-namespace node {
-
-class ObjectWrap {
- public:
-  ObjectWrap() {
-    refs_ = 0;
-  }
-
-
-  virtual ~ObjectWrap() {
-    if (persistent().IsEmpty())
-      return;
-    persistent().ClearWeak();
-    persistent().Reset();
-  }
-
-
-  template <class T>
-  static inline T* Unwrap(v8::Local<v8::Object> handle) {
-    assert(!handle.IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
-    // to T won't work right when T has more than one base class.
-    void* ptr = handle->GetAlignedPointerFromInternalField(0);
-    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
-    return static_cast<T*>(wrap);
-  }
-
-
-  inline v8::Local<v8::Object> handle() {
-    return handle(v8::Isolate::GetCurrent());
-  }
-
-
-  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
-    return v8::Local<v8::Object>::New(isolate, persistent());
-  }
-
-
-  // NOLINTNEXTLINE(runtime/v8_persistent)
-  inline v8::Persistent<v8::Object>& persistent() {
-    return handle_;
-  }
-
-
- protected:
-  inline void Wrap(v8::Local<v8::Object> handle) {
-    assert(persistent().IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    handle->SetAlignedPointerInInternalField(0, this);
-    persistent().Reset(v8::Isolate::GetCurrent(), handle);
-    MakeWeak();
-  }
-
-
-  inline void MakeWeak() {
-    persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
-  }
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref() {
-    assert(!persistent().IsEmpty());
-    persistent().ClearWeak();
-    refs_++;
-  }
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistent handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref() {
-    assert(!persistent().IsEmpty());
-    assert(!persistent().IsWeak());
-    assert(refs_ > 0);
-    if (--refs_ == 0)
-      MakeWeak();
-  }
-
-  int refs_;  // ro
-
- private:
-  static void WeakCallback(
-      const v8::WeakCallbackInfo<ObjectWrap>& data) {
-    ObjectWrap* wrap = data.GetParameter();
-    assert(wrap->refs_ == 0);
-    wrap->handle_.Reset();
-    delete wrap;
-  }
-
-  // NOLINTNEXTLINE(runtime/v8_persistent)
-  v8::Persistent<v8::Object> handle_;
-};
-
-}  // namespace node
-
-#endif  // SRC_NODE_OBJECT_WRAP_H_

package/src/headers/18/node_snapshot_builder.h

@@ -1,43 +0,0 @@
-
-#ifndef SRC_NODE_SNAPSHOT_BUILDER_H_
-#define SRC_NODE_SNAPSHOT_BUILDER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cstdint>
-#include "node_mutex.h"
-#include "v8.h"
-
-namespace node {
-
-class ExternalReferenceRegistry;
-struct SnapshotData;
-
-class NODE_EXTERN_PRIVATE SnapshotBuilder {
- public:
-  static std::string Generate(const std::vector<std::string> args,
-                              const std::vector<std::string> exec_args);
-
-  // Generate the snapshot into out.
-  static void Generate(SnapshotData* out,
-                       const std::vector<std::string> args,
-                       const std::vector<std::string> exec_args);
-
-  // If nullptr is returned, the binary is not built with embedded
-  // snapshot.
-  static const SnapshotData* GetEmbeddedSnapshotData();
-  static void InitializeIsolateParams(const SnapshotData* data,
-                                      v8::Isolate::CreateParams* params);
-
- private:
-  // Used to synchronize access to the snapshot data
-  static Mutex snapshot_data_mutex_;
-  static const std::vector<intptr_t>& CollectExternalReferences();
-
-  static std::unique_ptr<ExternalReferenceRegistry> registry_;
-};
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_SNAPSHOT_BUILDER_H_