src: delete AllocatedBuffer

Since all its uses are now gone, it's time to say goodbye to
AllocatedBuffer.

Refs: https://github.com/nodejs/node/pull/39941
Signed-off-by: Darshan Sen <raisinten@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/43008
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Mohammed Keyvanzadeh <mohammadkeyvanzade94@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Zeyu "Alex" Yang <himself65@outlook.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

node.gyp

@@ -590,8 +590,6 @@
         'src/aliased_buffer.h',
         'src/aliased_struct.h',
         'src/aliased_struct-inl.h',
-        'src/allocated_buffer.h',
-        'src/allocated_buffer-inl.h',
         'src/async_wrap.h',
         'src/async_wrap-inl.h',
         'src/base_object.h',

src/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_

src/allocated_buffer.h

@@ -1,73 +0,0 @@
-#ifndef SRC_ALLOCATED_BUFFER_H_
-#define SRC_ALLOCATED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "uv.h"
-#include "v8.h"
-#include "env.h"
-
-namespace node {
-
-class Environment;
-
-// Disables zero-filling for ArrayBuffer allocations in this scope. This is
-// similar to how we implement Buffer.allocUnsafe() in JS land.
-class NoArrayBufferZeroFillScope{
- public:
-  inline explicit NoArrayBufferZeroFillScope(IsolateData* isolate_data);
-  inline ~NoArrayBufferZeroFillScope();
-
- private:
-  NodeArrayBufferAllocator* node_allocator_;
-
-  friend class Environment;
-};
-
-// A unique-pointer-ish object that is compatible with the JS engine's
-// ArrayBuffer::Allocator.
-// TODO(addaleax): We may want to start phasing this out as it's only a
-// thin wrapper around v8::BackingStore at this point
-struct AllocatedBuffer {
- public:
-  // Utilities that allocate memory using the Isolate's ArrayBuffer::Allocator.
-  // In particular, using AllocateManaged() will provide a RAII-style object
-  // with easy conversion to `Buffer` and `ArrayBuffer` objects.
-  inline static AllocatedBuffer AllocateManaged(Environment* env, size_t size);
-
-  AllocatedBuffer() = default;
-  inline AllocatedBuffer(
-      Environment* env, std::unique_ptr<v8::BackingStore> bs);
-  // For this constructor variant, `buffer` *must* come from an earlier call
-  // to .release
-  inline AllocatedBuffer(Environment* env, uv_buf_t buffer);
-
-  inline void Resize(size_t len);
-
-  inline uv_buf_t release();
-  inline char* data();
-  inline const char* data() const;
-  inline size_t size() const;
-  inline void clear();
-
-  inline v8::MaybeLocal<v8::Object> ToBuffer();
-  inline v8::Local<v8::ArrayBuffer> ToArrayBuffer();
-
-  AllocatedBuffer(AllocatedBuffer&& other) = default;
-  AllocatedBuffer& operator=(AllocatedBuffer&& other) = default;
-  AllocatedBuffer(const AllocatedBuffer& other) = delete;
-  AllocatedBuffer& operator=(const AllocatedBuffer& other) = delete;
-
- private:
-  Environment* env_ = nullptr;
-  std::unique_ptr<v8::BackingStore> backing_store_;
-
-  friend class Environment;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALLOCATED_BUFFER_H_

src/crypto/README.md

@@ -112,17 +112,6 @@ their underlying data pointers. It is used extensively through `src/crypto`
 to make it easier to deal with inputs that allow any `ArrayBuffer`-backed
 object.
 
-### `AllocatedBuffer`
-
-The `AllocatedBuffer` utility is defined in `allocated_buffer.h` and is not
-specific to `src/crypto`. It is used extensively within `src/crypto` to hold
-allocated data that is intended to be output in response to various
-crypto functions (generated hash values, or ciphertext, for instance).
-
-_Currently, we are working to transition away from using `AllocatedBuffer`
-to directly using the `v8::BackingStore` API. This will take some time.
-New uses of `AllocatedBuffer` should be avoided if possible._
-
 ### Key objects
 
 Most crypto operations involve the use of keys -- cryptographic inputs

src/crypto/crypto_aes.cc

@@ -1,10 +1,9 @@
 #include "crypto/crypto_aes.h"
+#include "async_wrap-inl.h"
+#include "base_object-inl.h"
 #include "crypto/crypto_cipher.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
-#include "async_wrap-inl.h"
-#include "base_object-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"
@@ -30,7 +29,7 @@ namespace crypto {
 namespace {
 // Implements general AES encryption and decryption for CBC
 // The key_data must be a secret key.
-// On success, this function sets out to a new AllocatedBuffer
+// On success, this function sets out to a new ByteSource
 // instance containing the results and returns WebCryptoCipherStatus::OK.
 WebCryptoCipherStatus AES_Cipher(
     Environment* env,

src/crypto/crypto_aes.h

@@ -6,7 +6,6 @@
 #include "crypto/crypto_cipher.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
 #include "env.h"
 #include "v8.h"
 

src/crypto/crypto_bio.cc

@@ -22,7 +22,6 @@
 #include "crypto/crypto_bio.h"
 #include "base_object-inl.h"
 #include "memory_tracker-inl.h"
-#include "allocated_buffer-inl.h"
 #include "util-inl.h"
 
 #include <openssl/bio.h>

src/crypto/crypto_cipher.cc

@@ -1,7 +1,6 @@
 #include "crypto/crypto_cipher.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
 #include "base_object-inl.h"
+#include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_common.cc

@@ -1,4 +1,3 @@
-#include "allocated_buffer-inl.h"
 #include "base_object-inl.h"
 #include "env-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_dh.cc

@@ -1,9 +1,8 @@
 #include "crypto/crypto_dh.h"
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_groups.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
+#include "crypto/crypto_groups.h"
+#include "crypto/crypto_keys.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"

src/crypto/crypto_ec.cc

@@ -1,9 +1,8 @@
 #include "crypto/crypto_ec.h"
-#include "crypto/crypto_common.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
+#include "crypto/crypto_common.h"
+#include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_ec.h

@@ -3,12 +3,11 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_keygen.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
 #include "async_wrap.h"
 #include "base_object.h"
+#include "crypto/crypto_keygen.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "node_internals.h"

src/crypto/crypto_hash.cc

@@ -1,5 +1,4 @@
 #include "crypto/crypto_hash.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
 #include "env-inl.h"

src/crypto/crypto_hash.h

@@ -3,10 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "base_object.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
-#include "base_object.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "v8.h"

src/crypto/crypto_hkdf.cc

@@ -1,8 +1,7 @@
 #include "crypto/crypto_hkdf.h"
-#include "crypto/crypto_keys.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
+#include "crypto/crypto_keys.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"

src/crypto/crypto_hkdf.h

@@ -3,11 +3,10 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
 #include "async_wrap.h"
 #include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
 #include "v8.h"
 
 namespace node {

src/crypto/crypto_hmac.cc

@@ -1,10 +1,9 @@
 #include "crypto/crypto_hmac.h"
+#include "async_wrap-inl.h"
+#include "base_object-inl.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_sig.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
-#include "async_wrap-inl.h"
-#include "base_object-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_hmac.h

@@ -3,11 +3,10 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "base_object.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_sig.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
-#include "base_object.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "v8.h"

src/crypto/crypto_keygen.cc

@@ -1,5 +1,4 @@
 #include "crypto/crypto_keygen.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
 #include "debug_utils-inl.h"

src/crypto/crypto_keygen.h

@@ -3,11 +3,10 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "crypto/crypto_keys.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
 #include "async_wrap.h"
 #include "base_object.h"
+#include "crypto/crypto_keys.h"
+#include "crypto/crypto_util.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "v8.h"

src/crypto/crypto_pbkdf2.cc

@@ -1,7 +1,6 @@
 #include "crypto/crypto_pbkdf2.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
+#include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_random.cc

@@ -1,7 +1,6 @@
 #include "crypto/crypto_random.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
+#include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"

src/crypto/crypto_random.h

@@ -3,9 +3,8 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "crypto/crypto_util.h"
 #include "base_object.h"
-#include "allocated_buffer.h"
+#include "crypto/crypto_util.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "node_internals.h"

src/crypto/crypto_rsa.cc

@@ -1,10 +1,9 @@
 #include "crypto/crypto_rsa.h"
+#include "async_wrap-inl.h"
+#include "base_object-inl.h"
 #include "crypto/crypto_bio.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
-#include "async_wrap-inl.h"
-#include "base_object-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"

src/crypto/crypto_rsa.h

@@ -7,7 +7,6 @@
 #include "crypto/crypto_keygen.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "v8.h"

src/crypto/crypto_scrypt.cc

@@ -1,7 +1,6 @@
 #include "crypto/crypto_scrypt.h"
-#include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap-inl.h"
+#include "crypto/crypto_util.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_sig.cc

@@ -1,10 +1,9 @@
 #include "crypto/crypto_sig.h"
+#include "async_wrap-inl.h"
+#include "base_object-inl.h"
 #include "crypto/crypto_ec.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer-inl.h"
-#include "async_wrap-inl.h"
-#include "base_object-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "threadpoolwork-inl.h"

src/crypto/crypto_sig.h

@@ -3,10 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "base_object.h"
 #include "crypto/crypto_keys.h"
 #include "crypto/crypto_util.h"
-#include "allocated_buffer.h"
-#include "base_object.h"
 #include "env.h"
 #include "memory_tracker.h"
 

src/crypto/crypto_util.cc

@@ -1,8 +1,7 @@
 #include "crypto/crypto_util.h"
+#include "async_wrap-inl.h"
 #include "crypto/crypto_bio.h"
 #include "crypto/crypto_keys.h"
-#include "allocated_buffer-inl.h"
-#include "async_wrap-inl.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"

src/crypto/crypto_util.h

@@ -3,15 +3,14 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "env.h"
 #include "async_wrap.h"
-#include "allocated_buffer.h"
+#include "env.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
+#include "string_bytes.h"
 #include "util.h"
 #include "v8.h"
-#include "string_bytes.h"
 
 #include <openssl/err.h>
 #include <openssl/evp.h>

src/env-inl.h

@@ -25,11 +25,11 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "aliased_buffer.h"
-#include "allocated_buffer-inl.h"
 #include "callback_queue-inl.h"
 #include "env.h"
 #include "node.h"
 #include "node_context_data.h"
+#include "node_internals.h"
 #include "node_perf_common.h"
 #include "util-inl.h"
 #include "uv.h"
@@ -43,6 +43,16 @@
 
 namespace node {
 
+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;
+}
+
 inline v8::Isolate* IsolateData::isolate() const {
   return isolate_;
 }
@@ -979,7 +989,7 @@ inline uv_buf_t Environment::allocate_managed_buffer(
   std::unique_ptr<v8::BackingStore> bs =
       v8::ArrayBuffer::NewBackingStore(isolate(), suggested_size);
   uv_buf_t buf = uv_buf_init(static_cast<char*>(bs->Data()), bs->ByteLength());
-  released_allocated_buffers()->emplace(buf.base, std::move(bs));
+  released_allocated_buffers_.emplace(buf.base, std::move(bs));
   return buf;
 }
 
@@ -987,20 +997,14 @@ inline std::unique_ptr<v8::BackingStore> Environment::release_managed_buffer(
     const uv_buf_t& buf) {
   std::unique_ptr<v8::BackingStore> bs;
   if (buf.base != nullptr) {
-    auto map = released_allocated_buffers();
-    auto it = map->find(buf.base);
-    CHECK_NE(it, map->end());
+    auto it = released_allocated_buffers_.find(buf.base);
+    CHECK_NE(it, released_allocated_buffers_.end());
     bs = std::move(it->second);
-    map->erase(it);
+    released_allocated_buffers_.erase(it);
   }
   return bs;
 }
 
-std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>*
-    Environment::released_allocated_buffers() {
-  return &released_allocated_buffers_;
-}
-
 inline void Environment::ThrowError(const char* errmsg) {
   ThrowError(v8::Exception::Error, errmsg);
 }

src/env.cc

@@ -1,5 +1,4 @@
 #include "env.h"
-#include "allocated_buffer-inl.h"
 #include "async_wrap.h"
 #include "base_object-inl.h"
 #include "debug_utils-inl.h"

src/env.h

@@ -138,6 +138,19 @@ enum class FsStatsOffset {
 constexpr size_t kFsStatsBufferLength =
     static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber) * 2;
 
+// Disables zero-filling for ArrayBuffer allocations in this scope. This is
+// similar to how we implement Buffer.allocUnsafe() in JS land.
+class NoArrayBufferZeroFillScope {
+ public:
+  inline explicit NoArrayBufferZeroFillScope(IsolateData* isolate_data);
+  inline ~NoArrayBufferZeroFillScope();
+
+ private:
+  NodeArrayBufferAllocator* node_allocator_;
+
+  friend class Environment;
+};
+
 // PER_ISOLATE_* macros: We have a lot of per-isolate properties
 // and adding and maintaining their getters and setters by hand would be
 // difficult so let's make the preprocessor generate them for us.
@@ -555,7 +568,6 @@ constexpr size_t kFsStatsBufferLength =
   V(wasm_streaming_object_constructor, v8::Function)
 
 class Environment;
-struct AllocatedBuffer;
 
 typedef size_t SnapshotIndex;
 class NODE_EXTERN_PRIVATE IsolateData : public MemoryRetainer {
@@ -1457,8 +1469,6 @@ class Environment : public MemoryRetainer {
   inline uv_buf_t allocate_managed_buffer(const size_t suggested_size);
   inline std::unique_ptr<v8::BackingStore> release_managed_buffer(
       const uv_buf_t& buf);
-  inline std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>*
-      released_allocated_buffers();
 
   void AddUnmanagedFd(int fd);
   void RemoveUnmanagedFd(int fd);
@@ -1632,8 +1642,8 @@ class Environment : public MemoryRetainer {
   // the source passed to LoadEnvironment() directly instead.
   std::unique_ptr<v8::String::Value> main_utf16_;
 
-  // Used by AllocatedBuffer::release() to keep track of the BackingStore for
-  // a given pointer.
+  // Used by allocate_managed_buffer() and release_managed_buffer() to keep
+  // track of the BackingStore for a given pointer.
   std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
       released_allocated_buffers_;
 };

src/node.cc

@@ -43,7 +43,6 @@
 #include "node_version.h"
 
 #if HAVE_OPENSSL
-#include "allocated_buffer-inl.h"  // Inlined functions needed by node_crypto.h
 #include "node_crypto.h"
 #endif
 

src/node_buffer.cc

@@ -20,7 +20,6 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "node_buffer.h"
-#include "allocated_buffer-inl.h"
 #include "node.h"
 #include "node_blob.h"
 #include "node_errors.h"

src/node_http2.cc

@@ -1,12 +1,11 @@
+#include "node_http2.h"
 #include "aliased_buffer.h"
-#include "allocated_buffer-inl.h"
 #include "aliased_struct-inl.h"
 #include "debug_utils-inl.h"
 #include "histogram-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
 #include "node_buffer.h"
-#include "node_http2.h"
 #include "node_http_common-inl.h"
 #include "node_mem-inl.h"
 #include "node_perf.h"

src/stream_base.cc

@@ -1,7 +1,6 @@
 #include "stream_base.h"  // NOLINT(build/include_inline)
 #include "stream_base-inl.h"
 #include "stream_wrap.h"
-#include "allocated_buffer-inl.h"
 
 #include "env-inl.h"
 #include "js_stream.h"