src: add an ExternalReferenceRegistry class

Author: joyeecheung

node.gyp

@@ -579,6 +579,7 @@
         'src/node_domain.cc',
         'src/node_env_var.cc',
         'src/node_errors.cc',
+        'src/node_external_reference.cc',
         'src/node_file.cc',
         'src/node_http_parser.cc',
         'src/node_http2.cc',
@@ -668,6 +669,7 @@
         'src/node_contextify.h',
         'src/node_dir.h',
         'src/node_errors.h',
+        'src/node_external_reference.h',
         'src/node_file.h',
         'src/node_file-inl.h',
         'src/node_http_common.h',

src/node.cc

@@ -1038,6 +1038,7 @@ int Start(int argc, char** argv) {
       if (blob != nullptr) {
         // TODO(joyeecheung): collect external references and set it in
         // params.external_references.
+        external_references = NodeMainInstance::CollectExternalReferences();
         external_references.push_back(reinterpret_cast<intptr_t>(nullptr));
         params.external_references = external_references.data();
         params.snapshot_blob = blob;

src/node_external_reference.cc

@@ -0,0 +1,15 @@
+#include "node_external_reference.h"
+#include <cinttypes>
+#include <vector>
+#include "util.h"
+
+namespace node {
+
+const std::vector<intptr_t>& ExternalReferenceRegistry::external_references() {
+  CHECK(!is_finalized_);
+  external_references_.push_back(reinterpret_cast<intptr_t>(nullptr));
+  is_finalized_ = true;
+  return external_references_;
+}
+
+}  // namespace node

src/node_external_reference.h

@@ -0,0 +1,35 @@
+#ifndef SRC_NODE_EXTERNAL_REFERENCE_H_
+#define SRC_NODE_EXTERNAL_REFERENCE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include <vector>
+
+namespace node {
+
+// This class manages the external references from the V8 heap
+// to the C++ addresses in Node.js.
+class ExternalReferenceRegistry {
+ public:
+  ExternalReferenceRegistry() {}
+
+  template <typename T>
+  void Register(T* address) {
+    external_references_.push_back(reinterpret_cast<intptr_t>(address));
+  }
+
+  // This can be called only once.
+  const std::vector<intptr_t>& external_references();
+
+  bool is_empty() { return external_references_.empty(); }
+
+ private:
+  bool is_finalized_ = false;
+  std::vector<intptr_t> external_references_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_EXTERNAL_REFERENCE_H_

src/node_main_instance.cc

@@ -1,6 +1,8 @@
 #include <memory>
 
 #include "node_main_instance.h"
+#include "node_errors.h"
+#include "node_external_reference.h"
 #include "node_internals.h"
 #include "node_options-inl.h"
 #include "node_v8_platform-inl.h"
@@ -23,6 +25,8 @@ using v8::Locker;
 using v8::Object;
 using v8::SealHandleScope;
 
+std::unique_ptr<ExternalReferenceRegistry> NodeMainInstance::registry_ =
+    nullptr;
 NodeMainInstance::NodeMainInstance(Isolate* isolate,
                                    uv_loop_t* event_loop,
                                    MultiIsolatePlatform* platform,
@@ -43,6 +47,15 @@ NodeMainInstance::NodeMainInstance(Isolate* isolate,
   SetIsolateMiscHandlers(isolate_, misc);
 }
 
+const std::vector<intptr_t>& NodeMainInstance::CollectExternalReferences() {
+  // Cannot be called more than once.
+  CHECK_NULL(registry_);
+  registry_.reset(new ExternalReferenceRegistry());
+
+  // TODO(joyeecheung): collect more external references here.
+  return registry_->external_references();
+}
+
 std::unique_ptr<NodeMainInstance> NodeMainInstance::Create(
     Isolate* isolate,
     uv_loop_t* event_loop,

src/node_main_instance.h

@@ -13,6 +13,8 @@
 
 namespace node {
 
+class ExternalReferenceRegistry;
+
 // TODO(joyeecheung): align this with the Worker/WorkerThreadData class.
 // We may be able to create an abstract class to reuse some of the routines.
 class NodeMainInstance {
@@ -66,6 +68,7 @@ class NodeMainInstance {
   // snapshot.
   static const std::vector<size_t>* GetIsolateDataIndexes();
   static v8::StartupData* GetEmbeddedSnapshotBlob();
+  static const std::vector<intptr_t>& CollectExternalReferences();
 
   static const size_t kNodeContextIndex = 0;
   NodeMainInstance(const NodeMainInstance&) = delete;
@@ -80,6 +83,7 @@ class NodeMainInstance {
                    const std::vector<std::string>& args,
                    const std::vector<std::string>& exec_args);
 
+  static std::unique_ptr<ExternalReferenceRegistry> registry_;
   std::vector<std::string> args_;
   std::vector<std::string> exec_args_;
   std::unique_ptr<ArrayBufferAllocator> array_buffer_allocator_;

tools/snapshot/snapshot_builder.cc

@@ -1,6 +1,8 @@
 #include "snapshot_builder.h"
 #include <iostream>
 #include <sstream>
+#include "env-inl.h"
+#include "node_external_reference.h"
 #include "node_internals.h"
 #include "node_main_instance.h"
 #include "node_v8_platform-inl.h"
@@ -63,10 +65,8 @@ const std::vector<size_t>* NodeMainInstance::GetIsolateDataIndexes() {
 std::string SnapshotBuilder::Generate(
     const std::vector<std::string> args,
     const std::vector<std::string> exec_args) {
-  // TODO(joyeecheung): collect external references and set it in
-  // params.external_references.
-  std::vector<intptr_t> external_references = {
-      reinterpret_cast<intptr_t>(nullptr)};
+  const std::vector<intptr_t>& external_references =
+      NodeMainInstance::CollectExternalReferences();
   Isolate* isolate = Isolate::Allocate();
   per_process::v8_platform.Platform()->RegisterIsolate(isolate,
                                                        uv_default_loop());