fixup! src: migrate from deprecated SnapshotCreator constructor

Author: joyeecheung

lib/internal/buffer.js

@@ -1102,6 +1102,8 @@ function createUnsafeBuffer(size) {
   if (!zeroFill) {
     zeroFill = getZeroFillToggle();
     if (isBuildingSnapshot()) {
+      // Reset the toggle so that after serialization, we'll re-create a real
+      // toggle connected to the C++ one via getZeroFillToggle().
       addAfterUserSerializeCallback(() => {
         zeroFill = undefined;
       });
@@ -1115,14 +1117,6 @@ function createUnsafeBuffer(size) {
   }
 }
 
-// The connection between the JS land zero fill toggle and the
-// C++ one in the NodeArrayBufferAllocator gets lost if the toggle
-// is deserialized from the snapshot, because V8 owns the underlying
-// memory of this toggle. This resets the connection.
-function reconnectZeroFillToggle() {
-  zeroFill = getZeroFillToggle();
-}
-
 module.exports = {
   FastBuffer,
   addBufferPrototypeMethods,

src/api/embed_helpers.cc

@@ -116,6 +116,10 @@ CommonEnvironmentSetup::CommonEnvironmentSetup(
   Isolate::CreateParams params;
   params.array_buffer_allocator = impl_->allocator.get();
   params.external_references = external_references.data();
+  params.external_references = external_references.data();
+  params.cpp_heap =
+      v8::CppHeap::Create(platform, v8::CppHeapCreateParams{{}}).release();
+
   Isolate* isolate;
 
   // Isolates created for snapshotting should be set up differently since
@@ -234,10 +238,10 @@ CommonEnvironmentSetup::~CommonEnvironmentSetup() {
       *static_cast<bool*>(data) = true;
     }, &platform_finished);
     impl_->platform->UnregisterIsolate(isolate);
-    if (impl_->snapshot_creator.has_value())
+    if (impl_->snapshot_creator.has_value()) {
       impl_->snapshot_creator.reset();
-    else
-      isolate->Dispose();
+    }
+    isolate->Dispose();
 
     // Wait until the platform has cleaned up all relevant resources.
     while (!platform_finished)

src/node_buffer.cc

@@ -1222,18 +1222,20 @@ void GetZeroFillToggle(const FunctionCallbackInfo<Value>& args) {
   Local<ArrayBuffer> ab;
   // It can be a nullptr when running inside an isolate where we
   // do not own the ArrayBuffer allocator.
-  if (allocator == nullptr) {
+  if (allocator == nullptr || env->isolate_data()->is_building_snapshot()) {
     // Create a dummy Uint32Array - the JS land can only toggle the C++ land
     // setting when the allocator uses our toggle. With this the toggle in JS
     // land results in no-ops.
+    // When building a snapshot, just use a dummy toggle as well to avoid
+    // introducing the dynamic external reference. We'll re-initialize the
+    // toggle with a real one connected to the C++ allocator after snapshot
+    // deserialization.
 
     ab = ArrayBuffer::New(env->isolate(), sizeof(uint32_t));
-  } else if (env->isolate_data()->is_building_snapshot()) {
-    ab = ArrayBuffer::New(env->isolate(), sizeof(uint32_t));
+  } else {
     // TODO(joyeecheung): save ab->GetBackingStore()->Data() in the Node.js
     // array buffer allocator and include it into the C++ toggle while the
     // Environment is still alive.
-  } else {
     uint32_t* zero_fill_field = allocator->zero_fill_field();
     std::unique_ptr<BackingStore> backing =
         ArrayBuffer::NewBackingStore(zero_fill_field,