From 672d46fda9bc3b6e87b9ba06727658e375810054 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 7 Aug 2021 08:23:48 -0700
Subject: [PATCH] fixup! url,buffer: implement URL.createObjectURL

---
 doc/api/buffer.md                          |   4 +-
 doc/api/url.md                             |   9 +-
 lib/internal/blob.js                       |  45 ++++----
 lib/internal/url.js                        |  58 +++++-----
 src/env-inl.h                              |  19 ----
 src/env.cc                                 |   2 -
 src/env.h                                  |  17 ---
 src/node_binding.cc                        |   1 +
 src/node_blob.cc                           | 117 ++++++++++++++++++---
 src/node_blob.h                            |  53 +++++++++-
 src/node_buffer.cc                         |   5 -
 src/node_external_reference.h              |   1 +
 src/node_snapshotable.cc                   |   1 +
 src/node_snapshotable.h                    |   3 +-
 test/parallel/test-blob-createobjecturl.js |   7 +-
 15 files changed, 228 insertions(+), 114 deletions(-)

diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index 0a0d0240256c27..f419be1181a61a 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -4959,11 +4959,11 @@ added: REPLACEME
 
 > Stability: 1 - Experimental
 
-* `id` {string} A `'blob:node:...` URL string returned by a prior call to
+* `id` {string} A `'blob:nodedata:...` URL string returned by a prior call to
   `URL.createObjectURL()`.
 * Returns: {Blob}
 
-Resolves a `'blob:node:...'` an associated {Blob} object registered using
+Resolves a `'blob:nodedata:...'` an associated {Blob} object registered using
 a prior call to `URL.createObjectURL()`.
 
 ### `buffer.transcode(source, fromEnc, toEnc)`
diff --git a/doc/api/url.md b/doc/api/url.md
index c9e9f641c4bc14..d4b212f515d4cc 100644
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -618,8 +618,8 @@ added: REPLACEME
 * `blob` {Blob}
 * Returns: {string}
 
-Creates a `'blob:node:...'` URL string that represents the given {Blob} object
-and can be used to retrieve the `Blob` later.
+Creates a `'blob:nodedata:...'` URL string that represents the given {Blob}
+object and can be used to retrieve the `Blob` later.
 
 ```js
 const {
@@ -641,8 +641,7 @@ The data stored by the registered {Blob} will be retained in memory until
 
 `Blob` objects are registered within the current thread. If using Worker
 Threads, `Blob` objects registered within one Worker will not be available
-to other workers or the main thread. The `threadId` of the owning thread
-is encoded within the generated object URL.
+to other workers or the main thread.
 
 #### `URL.revokeObjectURL(id)`
 <!-- YAML
@@ -651,7 +650,7 @@ added: REPLACEME
 
 > Stability: 1 - Experimental
 
-* `id` {string} A `'blob:node:...` URL string returned by a prior call to
+* `id` {string} A `'blob:nodedata:...` URL string returned by a prior call to
   `URL.createObjectURL()`.
 
 Removes the stored {Blob} identified by the given ID.
diff --git a/lib/internal/blob.js b/lib/internal/blob.js
index 7fa82ab9f080d1..a2d67e205be01a 100644
--- a/lib/internal/blob.js
+++ b/lib/internal/blob.js
@@ -7,10 +7,11 @@ const {
   ObjectDefineProperty,
   PromiseResolve,
   PromiseReject,
-  PromisePrototypeFinally,
+  SafePromisePrototypeFinally,
   ReflectConstruct,
   RegExpPrototypeTest,
   StringPrototypeToLowerCase,
+  StringPrototypeSplit,
   Symbol,
   SymbolIterator,
   SymbolToStringTag,
@@ -21,7 +22,7 @@ const {
   createBlob: _createBlob,
   FixedSizeBlobCopyJob,
   getDataObject,
-} = internalBinding('buffer');
+} = internalBinding('blob');
 
 const { TextDecoder } = require('internal/encoding');
 
@@ -66,35 +67,29 @@ const disallowedTypeCharacters = /[^\u{0020}-\u{007E}]/u;
 
 let Buffer;
 let ReadableStream;
-let threadId;
 let URL;
 
+
+// Yes, lazy loading is annoying but because of circular
+// references between the url, internal/blob, and buffer
+// modules, lazy loading here makes sure that things work.
+
 function lazyURL(id) {
-  if (URL === undefined)
-    URL = require('url').URL;
+  URL ??= require('url').URL;
   return new URL(id);
 }
 
 function lazyBuffer() {
-  if (Buffer === undefined)
-    Buffer = require('buffer').Buffer;
+  Buffer ??= require('buffer').Buffer;
   return Buffer;
 }
 
 function lazyReadableStream(options) {
-  if (ReadableStream === undefined) {
-    ReadableStream =
-      require('internal/webstreams/readablestream').ReadableStream;
-  }
+  ReadableStream ??=
+    require('internal/webstreams/readablestream').ReadableStream;
   return new ReadableStream(options);
 }
 
-function lazyThreadId() {
-  if (threadId === undefined)
-    threadId = require('worker_threads').threadId;
-  return threadId;
-}
-
 function isBlob(object) {
   return object?.[kHandle] !== undefined;
 }
@@ -275,7 +270,7 @@ class Blob {
       resolve(ab);
     };
     this[kArrayBufferPromise] =
-    PromisePrototypeFinally(
+    SafePromisePrototypeFinally(
       promise,
       () => this[kArrayBufferPromise] = undefined);
 
@@ -283,7 +278,6 @@ class Blob {
   }
 
   /**
-   *
    * @returns {Promise<string>}
    */
   async text() {
@@ -334,13 +328,18 @@ function resolveObjectURL(url) {
   url = `${url}`;
   try {
     const parsed = new lazyURL(url);
+
+    const split = StringPrototypeSplit(parsed.pathname, ':');
+
+    if (split.length !== 2)
+      return;
+
     const {
       0: base,
-      1: threadId,
-      2: id,
-    } = parsed.pathname.split(':');
+      1: id,
+    } = split;
 
-    if (base !== 'node' || +threadId !== lazyThreadId())
+    if (base !== 'nodedata')
       return;
 
     const ret = getDataObject(id);
diff --git a/lib/internal/url.js b/lib/internal/url.js
index 3a09be2694c4df..7dcf8ea213898e 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -42,17 +42,20 @@ const {
 
 const { getConstructorOf, removeColors } = require('internal/util');
 const {
-  ERR_ARG_NOT_ITERABLE,
-  ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_ARG_VALUE,
-  ERR_INVALID_FILE_URL_HOST,
-  ERR_INVALID_FILE_URL_PATH,
-  ERR_INVALID_THIS,
-  ERR_INVALID_TUPLE,
-  ERR_INVALID_URL,
-  ERR_INVALID_URL_SCHEME,
-  ERR_MISSING_ARGS
-} = require('internal/errors').codes;
+  codes: {
+    ERR_ARG_NOT_ITERABLE,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_FILE_URL_HOST,
+    ERR_INVALID_FILE_URL_PATH,
+    ERR_INVALID_THIS,
+    ERR_INVALID_TUPLE,
+    ERR_INVALID_URL,
+    ERR_INVALID_URL_SCHEME,
+    ERR_MISSING_ARGS,
+    ERR_NO_CRYPTO,
+  },
+} = require('internal/errors');
 const {
   CHAR_AMPERSAND,
   CHAR_BACKWARD_SLASH,
@@ -103,7 +106,7 @@ const {
 const {
   storeDataObject,
   revokeDataObject,
-} = internalBinding('buffer');
+} = internalBinding('blob');
 
 const context = Symbol('context');
 const cannotBeBase = Symbol('cannot-be-base');
@@ -115,26 +118,22 @@ const kFormat = Symbol('format');
 
 let blob;
 let cryptoRandom;
-let threadId;
 
 function lazyBlob() {
-  if (blob === undefined)
-    blob = require('internal/blob');
+  blob ??= require('internal/blob');
   return blob;
 }
 
 function lazyCryptoRandom() {
-  if (cryptoRandom === undefined)
-    cryptoRandom = require('internal/crypto/random');
+  try {
+    cryptoRandom ??= require('internal/crypto/random');
+  } catch {
+    // If Node.js built without crypto support, we'll fall
+    // through here and handle it later.
+  }
   return cryptoRandom;
 }
 
-function lazyThreadId() {
-  if (threadId === undefined)
-    threadId = require('worker_threads').threadId;
-  return threadId;
-}
-
 // https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
 const IteratorPrototype = ObjectGetPrototypeOf(
   ObjectGetPrototypeOf([][SymbolIterator]())
@@ -959,22 +958,29 @@ class URL {
   }
 
   static createObjectURL(obj) {
+    const cryptoRandom = lazyCryptoRandom();
+    if (cryptoRandom === undefined)
+      throw new ERR_NO_CRYPTO();
+
+    // Yes, lazy loading is annoying but because of circular
+    // references between the url, internal/blob, and buffer
+    // modules, lazy loading here makes sure that things work.
     const blob = lazyBlob();
     if (!blob.isBlob(obj))
       throw new ERR_INVALID_ARG_TYPE('obj', 'Blob', obj);
 
-    const id = lazyCryptoRandom().randomUUID();
+    const id = cryptoRandom.randomUUID();
 
     storeDataObject(id, obj[blob.kHandle], obj.size, obj.type);
 
-    return `blob:node:${lazyThreadId()}:${id}`;
+    return `blob:nodedata:${id}`;
   }
 
   static revokeObjectURL(url) {
     url = `${url}`;
     try {
       const parsed = new URL(url);
-      const { 2: id } = parsed.pathname.split(':');
+      const { 1: id } = StringPrototypeSplit(parsed.pathname, ':');
       if (id !== undefined)
         revokeDataObject(id);
     } catch {
diff --git a/src/env-inl.h b/src/env-inl.h
index 1ba5909e7f0809..b3b1ea908253b9 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -1182,25 +1182,6 @@ void Environment::set_process_exit_handler(
   process_exit_handler_ = std::move(handler);
 }
 
-void Environment::store_data_object(
-    const std::string& uuid,
-    const Environment::StoredDataObject& data_object) {
-  data_objects[uuid] = data_object;
-}
-
-void Environment::erase_data_object(const std::string& uuid) {
-  data_objects.erase(uuid);
-}
-
-Environment::StoredDataObject Environment::get_data_object(
-    const std::string& uuid) {
-  auto item = data_objects.find(uuid);
-  if (item == data_objects.end()) {
-    return Environment::StoredDataObject {};
-  }
-  return item->second;
-}
-
 #define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
 #define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
 #define VS(PropertyName, StringValue) V(v8::String, PropertyName)
diff --git a/src/env.cc b/src/env.cc
index ab360fc5419dea..1cc7da1ce15f43 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -644,8 +644,6 @@ void Environment::CleanupHandles() {
          !handle_wrap_queue_.IsEmpty()) {
     uv_run(event_loop(), UV_RUN_ONCE);
   }
-
-  data_objects.clear();
 }
 
 void Environment::StartProfilerIdleNotifier() {
diff --git a/src/env.h b/src/env.h
index 95d97629aa05e7..24b4a48b5f9657 100644
--- a/src/env.h
+++ b/src/env.h
@@ -1389,20 +1389,6 @@ class Environment : public MemoryRetainer {
 
   inline int32_t stack_trace_limit() const { return 10; }
 
-  struct StoredDataObject {
-    BaseObjectPtr<BaseObject> data_object;
-    size_t length;
-    std::string type;
-  };
-
-  inline void store_data_object(
-      const std::string& uuid,
-      const StoredDataObject& object);
-
-  inline void erase_data_object(const std::string& uuid);
-
-  inline StoredDataObject get_data_object(const std::string& uuid);
-
 #if HAVE_INSPECTOR
   void set_coverage_connection(
       std::unique_ptr<profiler::V8CoverageConnection> connection);
@@ -1625,9 +1611,6 @@ class Environment : public MemoryRetainer {
   // a given pointer.
   std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
       released_allocated_buffers_;
-
-  // Maintains stored Blobs used with the URL.createObjectURL() API
-  std::unordered_map<std::string, StoredDataObject> data_objects;
 };
 
 }  // namespace node
diff --git a/src/node_binding.cc b/src/node_binding.cc
index b5e42af79510b6..3c9776e655d0e4 100644
--- a/src/node_binding.cc
+++ b/src/node_binding.cc
@@ -40,6 +40,7 @@
 // __attribute__((constructor)) like mechanism in GCC.
 #define NODE_BUILTIN_STANDARD_MODULES(V)                                       \
   V(async_wrap)                                                                \
+  V(blob)                                                                      \
   V(block_list)                                                                \
   V(buffer)                                                                    \
   V(cares_wrap)                                                                \
diff --git a/src/node_blob.cc b/src/node_blob.cc
index 8ad84155a07177..c583d5e0a93791 100644
--- a/src/node_blob.cc
+++ b/src/node_blob.cc
@@ -31,7 +31,17 @@ using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
 
-void Blob::Initialize(Environment* env, v8::Local<v8::Object> target) {
+void Blob::Initialize(
+    Local<Object> target,
+    Local<Value> unused,
+    Local<Context> context,
+    void* priv) {
+  Environment* env = Environment::GetCurrent(context);
+
+  BlobBindingData* const binding_data =
+      env->AddBindingData<BlobBindingData>(context, target);
+  if (binding_data == nullptr) return;
+
   env->SetMethod(target, "createBlob", New);
   env->SetMethod(target, "storeDataObject", StoreDataObject);
   env->SetMethod(target, "getDataObject", GetDataObject);
@@ -226,6 +236,9 @@ std::unique_ptr<worker::TransferData> Blob::CloneForMessaging() const {
 
 void Blob::StoreDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Environment* env = Environment::GetCurrent(args);
+  BlobBindingData* binding_data =
+      Environment::GetBindingData<BlobBindingData>(args);
+
   CHECK(args[0]->IsString());  // ID key
   CHECK(Blob::HasInstance(env, args[1]));  // Blob
   CHECK(args[2]->IsUint32());  // Length
@@ -238,33 +251,38 @@ void Blob::StoreDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
   size_t length = args[2].As<Uint32>()->Value();
   Utf8Value type(env->isolate(), args[3]);
 
-  env->store_data_object(
-      std::string(*key),
-      Environment::StoredDataObject {
-        BaseObjectPtr<BaseObject>(blob),
+  binding_data->store_data_object(
+      std::string(*key, key.length()),
+      BlobBindingData::StoredDataObject(
+        BaseObjectPtr<Blob>(blob),
         length,
-        std::string(*type)
-      });
+        std::string(*type, type.length())));
 }
 
 void Blob::RevokeDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  BlobBindingData* binding_data =
+      Environment::GetBindingData<BlobBindingData>(args);
+
   Environment* env = Environment::GetCurrent(args);
   CHECK(args[0]->IsString());  // ID key
 
   Utf8Value key(env->isolate(), args[0]);
 
-  env->erase_data_object(std::string(*key));
+  binding_data->revoke_data_object(std::string(*key, key.length()));
 }
 
 void Blob::GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  BlobBindingData* binding_data =
+      Environment::GetBindingData<BlobBindingData>(args);
+
   Environment* env = Environment::GetCurrent(args);
   CHECK(args[0]->IsString());
 
   Utf8Value key(env->isolate(), args[0]);
 
-  Environment::StoredDataObject stored =
-      env->get_data_object(std::string(*key));
-  if (stored.data_object) {
+  BlobBindingData::StoredDataObject stored =
+      binding_data->get_data_object(std::string(*key, key.length()));
+  if (stored.blob) {
     Local<Value> type;
     if (!String::NewFromUtf8(
             env->isolate(),
@@ -275,7 +293,7 @@ void Blob::GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
     }
 
     Local<Value> values[] = {
-      stored.data_object->object(),
+      stored.blob->object(),
       Uint32::NewFromUnsigned(env->isolate(), stored.length),
       type
     };
@@ -396,6 +414,76 @@ void FixedSizeBlobCopyJob::RegisterExternalReferences(
   registry->Register(Run);
 }
 
+void BlobBindingData::StoredDataObject::MemoryInfo(
+    MemoryTracker* tracker) const {
+  tracker->TrackField("blob", blob);
+  tracker->TrackFieldWithSize("type", type.length());
+}
+
+BlobBindingData::StoredDataObject::StoredDataObject(
+    const BaseObjectPtr<Blob>& blob_,
+    size_t length_,
+    const std::string& type_)
+    : blob(blob_),
+      length(length_),
+      type(type_) {}
+
+BlobBindingData::BlobBindingData(Environment* env, Local<Object> wrap)
+    : SnapshotableObject(env, wrap, type_int) {
+  MakeWeak();
+}
+
+void BlobBindingData::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("data_objects", data_objects_);
+}
+
+void BlobBindingData::store_data_object(
+    const std::string& uuid,
+    const BlobBindingData::StoredDataObject& object) {
+  data_objects_[uuid] = object;
+}
+
+void BlobBindingData::revoke_data_object(const std::string& uuid) {
+  CHECK_NE(data_objects_.find(uuid), data_objects_.end());
+  data_objects_.erase(uuid);
+  CHECK_EQ(data_objects_.find(uuid), data_objects_.end());
+}
+
+BlobBindingData::StoredDataObject BlobBindingData::get_data_object(
+    const std::string& uuid) {
+  auto entry = data_objects_.find(uuid);
+  if (entry == data_objects_.end())
+    return BlobBindingData::StoredDataObject {};
+  return entry->second;
+}
+
+void BlobBindingData::Deserialize(
+    Local<Context> context,
+    Local<Object> holder,
+    int index,
+    InternalFieldInfo* info) {
+  DCHECK_EQ(index, BaseObject::kSlot);
+  HandleScope scope(context->GetIsolate());
+  Environment* env = Environment::GetCurrent(context);
+  BlobBindingData* binding =
+      env->AddBindingData<BlobBindingData>(context, holder);
+  CHECK_NOT_NULL(binding);
+}
+
+void BlobBindingData::PrepareForSerialization(
+    Local<Context> context,
+    v8::SnapshotCreator* creator) {
+  // Stored blob objects are not actually persisted.
+}
+
+InternalFieldInfo* BlobBindingData::Serialize(int index) {
+  DCHECK_EQ(index, BaseObject::kSlot);
+  InternalFieldInfo* info = InternalFieldInfo::New(type());
+  return info;
+}
+
+constexpr FastStringKey BlobBindingData::type_name;
+
 void Blob::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Blob::New);
   registry->Register(Blob::ToArrayBuffer);
@@ -403,6 +491,11 @@ void Blob::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Blob::StoreDataObject);
   registry->Register(Blob::GetDataObject);
   registry->Register(Blob::RevokeDataObject);
+
+  FixedSizeBlobCopyJob::RegisterExternalReferences(registry);
 }
 
 }  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(blob, node::Blob::Initialize);
+NODE_MODULE_EXTERNAL_REFERENCE(blob, node::Blob::RegisterExternalReferences);
diff --git a/src/node_blob.h b/src/node_blob.h
index 7e6aa6f88f3e98..61f4da655c93cd 100644
--- a/src/node_blob.h
+++ b/src/node_blob.h
@@ -8,9 +8,12 @@
 #include "env.h"
 #include "memory_tracker.h"
 #include "node_internals.h"
+#include "node_snapshotable.h"
 #include "node_worker.h"
 #include "v8.h"
 
+#include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace node {
@@ -25,7 +28,12 @@ class Blob : public BaseObject {
  public:
   static void RegisterExternalReferences(
       ExternalReferenceRegistry* registry);
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+
+  static void Initialize(
+      v8::Local<v8::Object> target,
+      v8::Local<v8::Value> unused,
+      v8::Local<v8::Context> context,
+      void* priv);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -134,6 +142,49 @@ class FixedSizeBlobCopyJob : public AsyncWrap, public ThreadPoolWork {
   size_t length_ = 0;
 };
 
+class BlobBindingData : public SnapshotableObject {
+ public:
+  explicit BlobBindingData(Environment* env, v8::Local<v8::Object> wrap);
+
+  SERIALIZABLE_OBJECT_METHODS()
+
+  static constexpr FastStringKey type_name{"node::BlobBindingData"};
+  static constexpr EmbedderObjectType type_int =
+      EmbedderObjectType::k_blob_binding_data;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BlobBindingData)
+  SET_MEMORY_INFO_NAME(BlobBindingData)
+
+  struct StoredDataObject : public MemoryRetainer {
+    BaseObjectPtr<Blob> blob;
+    size_t length;
+    std::string type;
+
+    StoredDataObject() = default;
+
+    StoredDataObject(
+        const BaseObjectPtr<Blob>& blob_,
+        size_t length_,
+        const std::string& type_);
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_SELF_SIZE(StoredDataObject)
+    SET_MEMORY_INFO_NAME(StoredDataObject)
+  };
+
+  void store_data_object(
+      const std::string& uuid,
+      const StoredDataObject& object);
+
+  void revoke_data_object(const std::string& uuid);
+
+  StoredDataObject get_data_object(const std::string& uuid);
+
+ private:
+  std::unordered_map<std::string, StoredDataObject> data_objects_;
+};
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index b5651b5e325fc9..962a4a11aab8e6 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -1266,8 +1266,6 @@ void Initialize(Local<Object> target,
   env->SetMethod(target, "utf8Write", StringWrite<UTF8>);
 
   env->SetMethod(target, "getZeroFillToggle", GetZeroFillToggle);
-
-  Blob::Initialize(env, target);
 }
 
 }  // anonymous namespace
@@ -1311,9 +1309,6 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
 
   registry->Register(DetachArrayBuffer);
   registry->Register(CopyArrayBuffer);
-
-  Blob::RegisterExternalReferences(registry);
-  FixedSizeBlobCopyJob::RegisterExternalReferences(registry);
 }
 
 }  // namespace Buffer
diff --git a/src/node_external_reference.h b/src/node_external_reference.h
index 094558783f770e..8d2de64ad43445 100644
--- a/src/node_external_reference.h
+++ b/src/node_external_reference.h
@@ -49,6 +49,7 @@ class ExternalReferenceRegistry {
 #define EXTERNAL_REFERENCE_BINDING_LIST_BASE(V)                                \
   V(async_wrap)                                                                \
   V(binding)                                                                   \
+  V(blob)                                                                      \
   V(buffer)                                                                    \
   V(contextify)                                                                \
   V(credentials)                                                               \
diff --git a/src/node_snapshotable.cc b/src/node_snapshotable.cc
index 35e0ed3f6df4bf..6e284bb66a0de5 100644
--- a/src/node_snapshotable.cc
+++ b/src/node_snapshotable.cc
@@ -5,6 +5,7 @@
 #include "base_object-inl.h"
 #include "debug_utils-inl.h"
 #include "env-inl.h"
+#include "node_blob.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_file.h"
diff --git a/src/node_snapshotable.h b/src/node_snapshotable.h
index 38da68f6d28eb2..ceb84fc9bf0382 100644
--- a/src/node_snapshotable.h
+++ b/src/node_snapshotable.h
@@ -15,7 +15,8 @@ struct SnapshotData;
 
 #define SERIALIZABLE_OBJECT_TYPES(V)                                           \
   V(fs_binding_data, fs::BindingData)                                          \
-  V(v8_binding_data, v8_utils::BindingData)
+  V(v8_binding_data, v8_utils::BindingData)                                    \
+  V(blob_binding_data, BlobBindingData)
 
 enum class EmbedderObjectType : uint8_t {
   k_default = 0,
diff --git a/test/parallel/test-blob-createobjecturl.js b/test/parallel/test-blob-createobjecturl.js
index 5f74886210694d..a8fd377dd3ef70 100644
--- a/test/parallel/test-blob-createobjecturl.js
+++ b/test/parallel/test-blob-createobjecturl.js
@@ -3,6 +3,11 @@
 
 const common = require('../common');
 
+// Because registering a Blob URL requires generating a random
+// UUID, it can only be done if crypto support is enabled.
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
 const {
   URL,
 } = require('url');
@@ -32,7 +37,7 @@ const assert = require('assert');
 
 })().then(common.mustCall());
 
-['not a url', undefined, 1, 'blob:node:1:wrong', {}].forEach((i) => {
+['not a url', undefined, 1, 'blob:nodedata:1:wrong', {}].forEach((i) => {
   assert.strictEqual(resolveObjectURL(i), undefined);
 });