@encharm/cws 4.4.1 → 4.5.1

package/src/headers/14/v8abbr.h

@@ -1,124 +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.
-*/
-
-/*
- * This header defines short names for V8 constants for use by the ustack
- * helper.
- */
-
-#ifndef SRC_V8ABBR_H_
-#define SRC_V8ABBR_H_
-
-/* Frame pointer offsets */
-#define V8_OFF_FP_FUNC              V8DBG_OFF_FP_FUNCTION
-#define V8_OFF_FP_CONTEXT           V8DBG_OFF_FP_CONTEXT
-#define V8_OFF_FP_MARKER            V8DBG_OFF_FP_MARKER
-
-/* Stack frame types */
-#define V8_FT_ENTRY                 V8DBG_FRAMETYPE_ENTRYFRAME
-#define V8_FT_ENTRYCONSTRUCT        V8DBG_FRAMETYPE_CONSTRUCTENTRYFRAME
-#define V8_FT_EXIT                  V8DBG_FRAMETYPE_EXITFRAME
-#define V8_FT_JAVASCRIPT            V8DBG_FRAMETYPE_JAVASCRIPTFRAME
-#define V8_FT_OPTIMIZED             V8DBG_FRAMETYPE_OPTIMIZEDFRAME
-#define V8_FT_INTERNAL              V8DBG_FRAMETYPE_INTERNALFRAME
-#define V8_FT_CONSTRUCT             V8DBG_FRAMETYPE_CONSTRUCTFRAME
-#define V8_FT_ADAPTOR               V8DBG_FRAMETYPE_ARGUMENTSADAPTORFRAME
-#define V8_FT_STUB                  V8DBG_FRAMETYPE_STUBFRAME
-
-/* Identification masks and tags */
-#define V8_SmiTagMask               (V8DBG_SMITAGMASK)
-#define V8_SmiTag                   (V8DBG_SMITAG)
-#define V8_SmiValueShift            (V8DBG_SMISHIFTSIZE + V8DBG_SMITAGMASK)
-
-#define V8_HeapObjectTagMask        V8DBG_HEAPOBJECTTAGMASK
-#define V8_HeapObjectTag            V8DBG_HEAPOBJECTTAG
-
-#define V8_IsNotStringMask          V8DBG_ISNOTSTRINGMASK
-#define V8_StringTag                V8DBG_STRINGTAG
-
-#define V8_StringEncodingMask       V8DBG_STRINGENCODINGMASK
-#define V8_AsciiStringTag           V8DBG_ONEBYTESTRINGTAG
-
-#define V8_StringRepresentationMask V8DBG_STRINGREPRESENTATIONMASK
-#define V8_SeqStringTag             V8DBG_SEQSTRINGTAG
-#define V8_ConsStringTag            V8DBG_CONSSTRINGTAG
-#define V8_ExternalStringTag        V8DBG_EXTERNALSTRINGTAG
-
-/* Instance types */
-#define V8_IT_FIXEDARRAY            V8DBG_TYPE_FIXEDARRAY__FIXED_ARRAY_TYPE
-#define V8_IT_CODE                  V8DBG_TYPE_CODE__CODE_TYPE
-#define V8_IT_SCRIPT                V8DBG_TYPE_SCRIPT__SCRIPT_TYPE
-
-/* Node-specific offsets */
-#define NODE_OFF_EXTSTR_DATA        sizeof(void*)
-
-/*
- * Not all versions of V8 have the offset for the "chars" array in the
- * SeqTwoByteString class, but it's the same as the one for SeqOneByteString.
- */
-#ifndef V8DBG_CLASS_SEQTWOBYTESTRING__CHARS__CHAR
-#define V8DBG_CLASS_SEQTWOBYTESTRING__CHARS__CHAR \
-  V8DBG_CLASS_SEQONEBYTESTRING__CHARS__CHAR
-#endif
-
-/* Heap class->field offsets */
-#define V8_OFF_HEAP(off)            ((off) - 1)
-
-#define V8_OFF_FUNC_SHARED  \
-    V8_OFF_HEAP(V8DBG_CLASS_JSFUNCTION__SHARED__SHAREDFUNCTIONINFO)
-#define V8_OFF_RAW_NAME  \
-    V8_OFF_HEAP(V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
-#define V8_OFF_SHARED_IDENT  \
-    V8_OFF_HEAP(             \
-      V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
-#define V8_OFF_SHARED_SCRIPT  \
-    V8_OFF_HEAP(              \
-        V8DBG_CLASS_SHAREDFUNCTIONINFO__SCRIPT_OR_DEBUG_INFO__HEAPOBJECT)
-#define V8_OFF_SHARED_FUNIDENT \
-    V8_OFF_HEAP(               \
-      V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
-#define V8_OFF_SCRIPT_NAME  \
-    V8_OFF_HEAP(V8DBG_CLASS_SCRIPT__NAME__OBJECT)
-#define V8_OFF_SCRIPT_LENDS \
-    V8_OFF_HEAP(V8DBG_CLASS_SCRIPT__LINE_ENDS__OBJECT)
-#define V8_OFF_STR_LENGTH \
-    V8_OFF_HEAP(V8DBG_CLASS_STRING__LENGTH__INT32_T)
-#define V8_OFF_STR_CHARS  \
-    V8_OFF_HEAP(V8DBG_CLASS_SEQONEBYTESTRING__CHARS__CHAR)
-#define V8_OFF_CONSSTR_CAR  \
-    V8_OFF_HEAP(V8DBG_CLASS_CONSSTRING__FIRST__STRING)
-#define V8_OFF_CONSSTR_CDR  \
-    V8_OFF_HEAP(V8DBG_CLASS_CONSSTRING__SECOND__STRING)
-#define V8_OFF_EXTSTR_RSRC  \
-    V8_OFF_HEAP(V8DBG_CLASS_EXTERNALSTRING__RESOURCE__OBJECT)
-#define V8_OFF_FA_SIZE    \
-    V8_OFF_HEAP(V8DBG_CLASS_FIXEDARRAYBASE__LENGTH__SMI)
-#define V8_OFF_FA_DATA    \
-    V8_OFF_HEAP(V8DBG_CLASS_FIXEDARRAY__DATA__UINTPTR_T)
-#define V8_OFF_HEAPOBJ_MAP  \
-    V8_OFF_HEAP(V8DBG_CLASS_HEAPOBJECT__MAP__MAP)
-#define V8_OFF_MAP_ATTRS  \
-    V8_OFF_HEAP(V8DBG_CLASS_MAP__INSTANCE_TYPE__UINT16_T)
-#define V8_OFF_TWOBYTESTR_CHARS  \
-    V8_OFF_HEAP(V8DBG_CLASS_SEQTWOBYTESTRING__CHARS__CHAR)
-
-#endif  /* SRC_V8ABBR_H_ */

package/src/headers/16/aliased_buffer.h

@@ -1,315 +0,0 @@
-#ifndef SRC_ALIASED_BUFFER_H_
-#define SRC_ALIASED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cinttypes>
-#include "util-inl.h"
-#include "v8.h"
-
-namespace node {
-
-typedef size_t AliasedBufferIndex;
-
-/**
- * Do not use this class directly when creating instances of it - use the
- * Aliased*Array defined at the end of this file instead.
- *
- * This class encapsulates the technique of having a native buffer mapped to
- * a JS object. Writes to the native buffer can happen efficiently without
- * going through JS, and the data is then available to user's via the exposed
- * JS object.
- *
- * While this technique is computationally efficient, it is effectively a
- * write to JS program state w/out going through the standard
- * (monitored) API. Thus any VM capabilities to detect the modification are
- * circumvented.
- *
- * The encapsulation herein provides a placeholder where such writes can be
- * observed. Any notification APIs will be left as a future exercise.
- */
-template <class NativeT,
-          class V8T,
-          // SFINAE NativeT to be scalar
-          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
-class AliasedBufferBase {
- public:
-  AliasedBufferBase(v8::Isolate* isolate,
-                    const size_t count,
-                    const AliasedBufferIndex* index = nullptr)
-      : isolate_(isolate), count_(count), byte_offset_(0), index_(index) {
-    CHECK_GT(count, 0);
-    if (index != nullptr) {
-      // Will be deserialized later.
-      return;
-    }
-    const v8::HandleScope handle_scope(isolate_);
-    const size_t size_in_bytes =
-        MultiplyWithOverflowCheck(sizeof(NativeT), count);
-
-    // allocate v8 ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, size_in_bytes);
-    buffer_ = static_cast<NativeT*>(ab->GetBackingStore()->Data());
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  /**
-   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
-   * The two will share a v8::ArrayBuffer instance &
-   * a native buffer, but will each read/write to different sections of the
-   * native buffer.
-   *
-   *  Note that byte_offset must by aligned by sizeof(NativeT).
-   */
-  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
-  AliasedBufferBase(
-      v8::Isolate* isolate,
-      const size_t byte_offset,
-      const size_t count,
-      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer,
-      const AliasedBufferIndex* index = nullptr)
-      : isolate_(isolate),
-        count_(count),
-        byte_offset_(byte_offset),
-        index_(index) {
-    if (index != nullptr) {
-      // Will be deserialized later.
-      return;
-    }
-    const v8::HandleScope handle_scope(isolate_);
-    v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
-
-    // validate that the byte_offset is aligned with sizeof(NativeT)
-    CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
-    // validate this fits inside the backing buffer
-    CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
-             ab->ByteLength() - byte_offset);
-
-    buffer_ = reinterpret_cast<NativeT*>(
-        const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
-
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  AliasedBufferBase(const AliasedBufferBase& that)
-      : isolate_(that.isolate_),
-        count_(that.count_),
-        byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_) {
-    DCHECK_NULL(index_);
-    js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
-  }
-
-  AliasedBufferIndex Serialize(v8::Local<v8::Context> context,
-                              v8::SnapshotCreator* creator) {
-    DCHECK_NULL(index_);
-    return creator->AddData(context, GetJSArray());
-  }
-
-  inline void Deserialize(v8::Local<v8::Context> context) {
-    DCHECK_NOT_NULL(index_);
-    v8::Local<V8T> arr =
-        context->GetDataFromSnapshotOnce<V8T>(*index_).ToLocalChecked();
-    // These may not hold true for AliasedBuffers that have grown, so should
-    // be removed when we expand the snapshot support.
-    DCHECK_EQ(count_, arr->Length());
-    DCHECK_EQ(byte_offset_, arr->ByteOffset());
-    uint8_t* raw =
-        static_cast<uint8_t*>(arr->Buffer()->GetBackingStore()->Data());
-    buffer_ = reinterpret_cast<NativeT*>(raw + byte_offset_);
-    js_array_.Reset(isolate_, arr);
-    index_ = nullptr;
-  }
-
-  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
-    DCHECK_NULL(index_);
-    this->~AliasedBufferBase();
-    isolate_ = that.isolate_;
-    count_ = that.count_;
-    byte_offset_ = that.byte_offset_;
-    buffer_ = that.buffer_;
-
-    js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
-
-    that.buffer_ = nullptr;
-    that.js_array_.Reset();
-    return *this;
-  }
-
-  /**
-   * Helper class that is returned from operator[] to support assignment into
-   * a specified location.
-   */
-  class Reference {
-   public:
-    Reference(AliasedBufferBase<NativeT, V8T>* aliased_buffer, size_t index)
-        : aliased_buffer_(aliased_buffer), index_(index) {}
-
-    Reference(const Reference& that)
-        : aliased_buffer_(that.aliased_buffer_),
-          index_(that.index_) {
-    }
-
-    inline Reference& operator=(const NativeT& val) {
-      aliased_buffer_->SetValue(index_, val);
-      return *this;
-    }
-
-    inline Reference& operator=(const Reference& val) {
-      return *this = static_cast<NativeT>(val);
-    }
-
-    operator NativeT() const {
-      return aliased_buffer_->GetValue(index_);
-    }
-
-    inline Reference& operator+=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current + val);
-      return *this;
-    }
-
-    inline Reference& operator+=(const Reference& val) {
-      return this->operator+=(static_cast<NativeT>(val));
-    }
-
-    inline Reference& operator-=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current - val);
-      return *this;
-    }
-
-   private:
-    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;
-    size_t index_;
-  };
-
-  /**
-   *  Get the underlying v8 TypedArray overlayed on top of the native buffer
-   */
-  v8::Local<V8T> GetJSArray() const {
-    DCHECK_NULL(index_);
-    return js_array_.Get(isolate_);
-  }
-
-  void Release() {
-    DCHECK_NULL(index_);
-    js_array_.Reset();
-  }
-
-  /**
-  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
-  *  overlaying the native buffer
-  */
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return GetJSArray()->Buffer();
-  }
-
-  /**
-   *  Get the underlying native buffer. Note that all reads/writes should occur
-   *  through the GetValue/SetValue/operator[] methods
-   */
-  inline const NativeT* GetNativeBuffer() const {
-    DCHECK_NULL(index_);
-    return buffer_;
-  }
-
-  /**
-   *  Synonym for GetBuffer()
-   */
-  inline const NativeT* operator * () const {
-    return GetNativeBuffer();
-  }
-
-  /**
-   *  Set position index to given value.
-   */
-  inline void SetValue(const size_t index, NativeT value) {
-    DCHECK_LT(index, count_);
-    DCHECK_NULL(index_);
-    buffer_[index] = value;
-  }
-
-  /**
-   *  Get value at position index
-   */
-  inline const NativeT GetValue(const size_t index) const {
-    DCHECK_NULL(index_);
-    DCHECK_LT(index, count_);
-    return buffer_[index];
-  }
-
-  /**
-   *  Effectively, a synonym for GetValue/SetValue
-   */
-  Reference operator[](size_t index) {
-    DCHECK_NULL(index_);
-    return Reference(this, index);
-  }
-
-  NativeT operator[](size_t index) const {
-    return GetValue(index);
-  }
-
-  size_t Length() const {
-    return count_;
-  }
-
-  // Should only be used to extend the array.
-  // Should only be used on an owning array, not one created as a sub array of
-  // an owning `AliasedBufferBase`.
-  void reserve(size_t new_capacity) {
-    DCHECK_NULL(index_);
-    DCHECK_GE(new_capacity, count_);
-    DCHECK_EQ(byte_offset_, 0);
-    const v8::HandleScope handle_scope(isolate_);
-
-    const size_t old_size_in_bytes = sizeof(NativeT) * count_;
-    const size_t new_size_in_bytes = MultiplyWithOverflowCheck(sizeof(NativeT),
-                                                              new_capacity);
-
-    // allocate v8 new ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, new_size_in_bytes);
-
-    // allocate new native buffer
-    NativeT* new_buffer = static_cast<NativeT*>(ab->GetBackingStore()->Data());
-    // copy old content
-    memcpy(new_buffer, buffer_, old_size_in_bytes);
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
-
-    // move over old v8 TypedArray
-    js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
-
-    buffer_ = new_buffer;
-    count_ = new_capacity;
-  }
-
- private:
-  v8::Isolate* isolate_ = nullptr;
-  size_t count_ = 0;
-  size_t byte_offset_ = 0;
-  NativeT* buffer_ = nullptr;
-  v8::Global<V8T> js_array_;
-
-  // Deserialize data
-  const AliasedBufferIndex* index_ = nullptr;
-};
-
-typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
-typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
-typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
-typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/16/aliased_struct-inl.h

@@ -1,54 +0,0 @@
-#ifndef SRC_ALIASED_STRUCT_INL_H_
-#define SRC_ALIASED_STRUCT_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_struct.h"
-#include "v8.h"
-#include <memory>
-
-namespace node {
-
-template <typename T>
-template <typename... Args>
-AliasedStruct<T>::AliasedStruct(v8::Isolate* isolate, Args&&... args)
-    : isolate_(isolate) {
-  const v8::HandleScope handle_scope(isolate);
-
-  store_ = v8::ArrayBuffer::NewBackingStore(isolate, sizeof(T));
-  ptr_ = new (store_->Data()) T(std::forward<Args>(args)...);
-  DCHECK_NOT_NULL(ptr_);
-
-  v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, store_);
-  buffer_ = v8::Global<v8::ArrayBuffer>(isolate, buffer);
-}
-
-template <typename T>
-AliasedStruct<T>::AliasedStruct(const AliasedStruct& that)
-    : AliasedStruct(that.isolate_, *that) {}
-
-template <typename T>
-AliasedStruct<T>& AliasedStruct<T>::operator=(
-    AliasedStruct<T>&& that) noexcept {
-  this->~AliasedStruct();
-  isolate_ = that.isolate_;
-  store_ = that.store_;
-  ptr_ = that.ptr_;
-
-  buffer_ = std::move(that.buffer_);
-
-  that.ptr_ = nullptr;
-  that.store_.reset();
-  return *this;
-}
-
-template <typename T>
-AliasedStruct<T>::~AliasedStruct() {
-  if (ptr_ != nullptr) ptr_->~T();
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_STRUCT_INL_H_

package/src/headers/16/aliased_struct.h

@@ -1,63 +0,0 @@
-#ifndef SRC_ALIASED_STRUCT_H_
-#define SRC_ALIASED_STRUCT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_internals.h"
-#include "v8.h"
-#include <memory>
-
-namespace node {
-
-// AliasedStruct is a utility that allows uses a V8 Backing Store
-// to be exposed to the C++/C side as a struct and to the
-// JavaScript side as an ArrayBuffer to efficiently share
-// data without marshalling. It is similar in nature to
-// AliasedBuffer.
-//
-//   struct Foo { int x; }
-//
-//   AliasedStruct<Foo> foo;
-//   foo->x = 1;
-//
-//   Local<ArrayBuffer> ab = foo.GetArrayBuffer();
-template <typename T>
-class AliasedStruct final {
- public:
-  template <typename... Args>
-  explicit AliasedStruct(v8::Isolate* isolate, Args&&... args);
-
-  inline AliasedStruct(const AliasedStruct& that);
-
-  inline ~AliasedStruct();
-
-  inline AliasedStruct& operator=(AliasedStruct&& that) noexcept;
-
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return buffer_.Get(isolate_);
-  }
-
-  const T* Data() const { return ptr_; }
-
-  T* Data() { return ptr_; }
-
-  const T& operator*() const { return *ptr_; }
-
-  T& operator*()  { return *ptr_; }
-
-  const T* operator->() const { return ptr_; }
-
-  T* operator->() { return ptr_; }
-
- private:
-  v8::Isolate* isolate_;
-  std::shared_ptr<v8::BackingStore> store_;
-  T* ptr_;
-  v8::Global<v8::ArrayBuffer> buffer_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_STRUCT_H_

package/src/headers/16/allocated_buffer-inl.h

@@ -1,110 +0,0 @@
-#ifndef SRC_ALLOCATED_BUFFER_INL_H_
-#define SRC_ALLOCATED_BUFFER_INL_H_
-
-#include "allocated_buffer.h"
-#include "base_object-inl.h"
-#include "node_buffer.h"
-#include "env-inl.h"
-#include "uv.h"
-#include "v8.h"
-#include "util-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-// It's a bit awkward to define this Buffer::New() overload here, but it
-// avoids a circular dependency with node_internals.h.
-namespace Buffer {
-v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
-                                   v8::Local<v8::ArrayBuffer> ab,
-                                   size_t byte_offset,
-                                   size_t length);
-}
-
-NoArrayBufferZeroFillScope::NoArrayBufferZeroFillScope(
-    IsolateData* isolate_data)
-  : node_allocator_(isolate_data->node_allocator()) {
-  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 0;
-}
-
-NoArrayBufferZeroFillScope::~NoArrayBufferZeroFillScope() {
-  if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 1;
-}
-
-AllocatedBuffer AllocatedBuffer::AllocateManaged(
-    Environment* env,
-    size_t size) {
-  NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-  std::unique_ptr<v8::BackingStore> bs =
-      v8::ArrayBuffer::NewBackingStore(env->isolate(), size);
-  return AllocatedBuffer(env, std::move(bs));
-}
-
-AllocatedBuffer::AllocatedBuffer(
-    Environment* env, std::unique_ptr<v8::BackingStore> bs)
-    : env_(env), backing_store_(std::move(bs)) {}
-
-AllocatedBuffer::AllocatedBuffer(
-    Environment* env, uv_buf_t buffer)
-    : env_(env) {
-  if (buffer.base == nullptr) return;
-  auto map = env->released_allocated_buffers();
-  auto it = map->find(buffer.base);
-  CHECK_NE(it, map->end());
-  backing_store_ = std::move(it->second);
-  map->erase(it);
-}
-
-void AllocatedBuffer::Resize(size_t len) {
-  if (len == 0) {
-    backing_store_ = v8::ArrayBuffer::NewBackingStore(env_->isolate(), 0);
-    return;
-  }
-  NoArrayBufferZeroFillScope no_zero_fill_scope(env_->isolate_data());
-  backing_store_ = v8::BackingStore::Reallocate(
-      env_->isolate(), std::move(backing_store_), len);
-}
-
-uv_buf_t AllocatedBuffer::release() {
-  if (data() == nullptr) return uv_buf_init(nullptr, 0);
-
-  CHECK_NOT_NULL(env_);
-  uv_buf_t ret = uv_buf_init(data(), size());
-  env_->released_allocated_buffers()->emplace(
-      ret.base, std::move(backing_store_));
-  return ret;
-}
-
-char* AllocatedBuffer::data() {
-  if (!backing_store_) return nullptr;
-  return static_cast<char*>(backing_store_->Data());
-}
-
-const char* AllocatedBuffer::data() const {
-  if (!backing_store_) return nullptr;
-  return static_cast<char*>(backing_store_->Data());
-}
-
-
-size_t AllocatedBuffer::size() const {
-  if (!backing_store_) return 0;
-  return backing_store_->ByteLength();
-}
-
-void AllocatedBuffer::clear() {
-  backing_store_.reset();
-}
-
-v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
-  v8::Local<v8::ArrayBuffer> ab = ToArrayBuffer();
-  return Buffer::New(env_, ab, 0, ab->ByteLength())
-      .FromMaybe(v8::Local<v8::Uint8Array>());
-}
-
-v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
-  return v8::ArrayBuffer::New(env_->isolate(), std::move(backing_store_));
-}
-
-}  // namespace node
-
-#endif  // SRC_ALLOCATED_BUFFER_INL_H_