[snapshot] serialize embedder-provided external references.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 5475 matching lines @@
  * thread at any given time.  The Locker/Unlocker API must be used to
  * synchronize.
  */
 class V8_EXPORT Isolate {
  public:
   /**
    * Initial configuration parameters for a new Isolate.
    */
   struct CreateParams {
     CreateParams()
-        : entry_hook(NULL),
-          code_event_handler(NULL),
-          snapshot_blob(NULL),
-          counter_lookup_callback(NULL),
-          create_histogram_callback(NULL),
-          add_histogram_sample_callback(NULL),
-          array_buffer_allocator(NULL) {}
+        : entry_hook(nullptr),
+          code_event_handler(nullptr),
+          snapshot_blob(nullptr),
+          counter_lookup_callback(nullptr),
+          create_histogram_callback(nullptr),
+          add_histogram_sample_callback(nullptr),
+          array_buffer_allocator(nullptr),
+          external_references(nullptr) {}
 
     /**
      * The optional entry_hook allows the host application to provide the
      * address of a function that's invoked on entry to every V8-generated
      * function.  Note that entry_hook is invoked at the very start of each
      * generated function. Furthermore, if an entry_hook is given, V8 will
      * not use a snapshot, including custom snapshots.
      */
     FunctionEntryHook entry_hook;
 
@@ skipping 27 matching lines @@
      * function.
      */
     CreateHistogramCallback create_histogram_callback;
     AddHistogramSampleCallback add_histogram_sample_callback;
 
     /**
      * The ArrayBuffer::Allocator to use for allocating and freeing the backing
      * store of ArrayBuffers.
      */
     ArrayBuffer::Allocator* array_buffer_allocator;
+
+    /**
+     * Specifies an optional null-terminated array of raw addresses in the

[jochen (gone - plz use gerrit), 2016/06/20 13:11:12]

nullptr

+     * embedder that V8 can match against during serialization and use for
+     * deserialization. This array and its content must stay valid for the
+     * entire lifetime of the isolate.
+     */
+    intptr_t* external_references;
   };
 
 
   /**
    * Stack-allocated class which sets the isolate for all operations
    * executed within a local scope.
    */
   class V8_EXPORT Scope {
    public:
     explicit Scope(Isolate* isolate) : isolate_(isolate) {
@@ skipping 1208 matching lines @@
  * Helper class to create a snapshot data blob.
  */
 class SnapshotCreator {
  public:
   enum class FunctionCodeHandling { kClear, kKeep };
 
   /**
    * Create and enter an isolate, and set it up for serialization.
    * The isolate is either created from scratch or from an existing snapshot.
    * The caller keeps ownership of the argument snapshot.
+   * \param existing_blob existing snapshot from which to create this one.
+   * \param external_references a null-terminated array of external references
+   *        that must be equivalent to CreateParams::external_references.
    */
-  explicit SnapshotCreator(StartupData* existing_blob = nullptr);
+  SnapshotCreator(intptr_t* external_references = nullptr,

[jochen (gone - plz use gerrit), 2016/06/20 13:11:12]

maybe make that the second parameter, so it's backward compatible?

+                  StartupData* existing_blob = nullptr);
 
   ~SnapshotCreator();
 
   /**
    * \returns the isolate prepared by the snapshot creator.
    */
   Isolate* GetIsolate();
 
   /**
    * Add a context to be included in the snapshot blob.
    * \returns the index of the context in the snapshot blob.
    */
   size_t AddContext(Local<Context> context);
 
   /**
    * Created a snapshot data blob.
+   * This must not be called from within a handle scope.
    * \param function_code_handling whether to include compiled function code
    *        in the snapshot.
    * \returns { nullptr, 0 } on failure, and a startup snapshot on success. The
    *        caller acquires ownership of the data array in the return value.
    */
   StartupData CreateBlob(FunctionCodeHandling function_code_handling);
 
  private:
   void* data_;
 
@@ skipping 2047 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_