[serializer] pass internal fields deserializer callback as argument.

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 6289 matching lines @@
    */
   struct CreateParams {
     CreateParams()
         : 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),
-          deserialize_internal_fields_callback(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 35 matching lines @@
      */
     ArrayBuffer::Allocator* array_buffer_allocator;
 
     /**
      * Specifies an optional nullptr-terminated array of raw addresses in the
      * 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;
-
-    /**
-     * Specifies an optional callback to deserialize internal fields. It
-     * should match the SerializeInternalFieldCallback used to serialize.
-     */
-    DeserializeInternalFieldsCallback deserialize_internal_fields_callback;
   };
 
 
   /**
    * 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 1286 matching lines @@
    * Set the default context to be included in the snapshot blob.
    * The snapshot will not contain the global proxy, and we expect one or a
    * global object template to create one, to be provided upon deserialization.
    */
   void SetDefaultContext(Local<Context> context);
 
   /**
    * Add additional context to be included in the snapshot blob.
    * The snapshot will include the global proxy.
    *
+   * \param callback optional callback to serialize internal fields.
+   *
    * \returns the index of the context in the snapshot blob.
    */
-  size_t AddContext(Local<Context> context);
+  size_t AddContext(Local<Context> context,
+                    SerializeInternalFieldsCallback callback = nullptr);
 
   /**
    * Add a template to be included in the snapshot blob.
    * \returns the index of the template in the snapshot blob.
    */
   size_t AddTemplate(Local<Template> template_obj);
 
   /**
    * 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.
-   * \param callback to serialize embedder-set internal fields.
    * \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,
-                         SerializeInternalFieldsCallback callback = nullptr);
+  StartupData CreateBlob(FunctionCodeHandling function_code_handling);
 
   // Disallow copying and assigning.
   SnapshotCreator(const SnapshotCreator&) = delete;
   void operator=(const SnapshotCreator&) = delete;
 
  private:
   void* data_;
 };
 
 /**
@@ skipping 292 matching lines @@
   /**
    * Create a new context from a (non-default) context snapshot. There
    * is no way to provide a global object template since we do not create
    * a new global object from template, but we can reuse a global object.
    *
    * \param isolate See v8::Context::New.
    *
    * \param context_snapshot_index The index of the context snapshot to
    * deserialize from. Use v8::Context::New for the default snapshot.
    *
+   * \param internal_fields_deserializer Optional callback to deserialize
+   * internal fields. It should match the SerializeInternalFieldCallback used
+   * to serialize.
+   *
    * \param extensions See v8::Context::New.
    *
    * \param global_object See v8::Context::New.
    */
 
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
+      DeserializeInternalFieldsCallback internal_fields_deserializer = nullptr,
       ExtensionConfiguration* extensions = nullptr,
       MaybeLocal<Value> global_object = MaybeLocal<Value>());
 
   /**
    * Returns an global object that isn't backed by an actual context.
    *
    * The global template needs to have access checks with handlers installed.
    * If an existing global object is passed in, the global object is detached
    * from its context.
    *
@@ skipping 1747 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_