Support delegating serialization of host objects.

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 1663 matching lines @@
   class V8_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
 
     /*
      * Handles the case where a DataCloneError would be thrown in the structured
      * clone spec. Other V8 embedders may throw some other appropriate exception
      * type.
      */
     virtual void ThrowDataCloneError(Local<String> message) = 0;
+
+    /*
+     * The embedder overrides this method to write some kind of host object, if
+     * possible. If not, a suitable exception should be thrown and
+     * Nothing<bool>() returned.
+     */
+    virtual Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object);

[jochen (gone - plz use gerrit), 2016/09/14 15:44:31]

should this be pure virtual?

[jbroman, 2016/09/14 16:35:23]

Ideally, yes. How does V8 usually manage rollout of this sort of thing? (That
will immediately fail to pass the Blink bots, since that method is missing
there.)

Options include:
- land an implementation in Blink first (without "override", and possibly with
suppression of compiler warnings for missing "override" depending on what the
warning settings are there)
- land this default implementation, then remove it once Blink implements
- continue to have a default implementation

WDYT?

   };
 
   explicit ValueSerializer(Isolate* isolate);
   ValueSerializer(Isolate* isolate, Delegate* delegate);
   ~ValueSerializer();
 
   /*
    * Writes out a header, which includes the format version.
    */
   void WriteHeader();
@@ skipping 17 matching lines @@
    */
   void TransferArrayBuffer(uint32_t transfer_id,
                            Local<ArrayBuffer> array_buffer);
 
   /*
    * Similar to TransferArrayBuffer, but for SharedArrayBuffer.
    */
   void TransferSharedArrayBuffer(uint32_t transfer_id,
                                  Local<SharedArrayBuffer> shared_array_buffer);
 
+  /*
+   * Write raw data in various common formats to the buffer.
+   * Note that integer types are written in base-128 varint format, not with a
+   * binary copy. For use during an override of Delegate::WriteHostObject.
+   */
+  void WriteUint32(uint32_t value);
+  void WriteUint64(uint64_t value);
+  void WriteRawBytes(const void* source, size_t length);
+
  private:
   ValueSerializer(const ValueSerializer&) = delete;
   void operator=(const ValueSerializer&) = delete;
 
   struct PrivateData;
   PrivateData* private_;
 };
 
 /**
  * Deserializes values from data written with ValueSerializer, or a compatible
  * implementation.
  *
  * WARNING: This API is under development, and changes (including incompatible
  * changes to the API or wire format) may occur without notice until this
  * warning is removed.
  */
 class V8_EXPORT ValueDeserializer {
  public:
+  class V8_EXPORT Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    /*
+     * The embedder overrides this method to read some kind of host object, if
+     * possible. If not, a suitable exception should be thrown and
+     * MaybeLocal<Object>() returned.
+     */
+    virtual MaybeLocal<Object> ReadHostObject(Isolate* isolate);

[jochen (gone - plz use gerrit), 2016/09/14 15:44:31]

same here?

+  };
+
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);
+  ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size,
+                    Delegate* delegate);
   ~ValueDeserializer();
 
   /*
    * Reads and validates a header (including the format version).
    * May, for example, reject an invalid or unsupported wire format.
    */
   V8_WARN_UNUSED_RESULT Maybe<bool> ReadHeader(Local<Context> context);
   V8_DEPRECATE_SOON("Use Local<Context> version", Maybe<bool> ReadHeader());
 
   /*
@@ skipping 24 matching lines @@
    */
   void SetSupportsLegacyWireFormat(bool supports_legacy_wire_format);
 
   /*
    * Reads the underlying wire format version. Likely mostly to be useful to
    * legacy code reading old wire format versions. Must be called after
    * ReadHeader.
    */
   uint32_t GetWireFormatVersion() const;
 
+  /*
+   * Reads raw data in various common formats to the buffer.
+   * Note that integer types are read in base-128 varint format, not with a
+   * binary copy. For use during an override of Delegate::ReadHostObject.
+   */
+  V8_WARN_UNUSED_RESULT bool ReadUint32(uint32_t* value);
+  V8_WARN_UNUSED_RESULT bool ReadUint64(uint64_t* value);
+  V8_WARN_UNUSED_RESULT bool ReadRawBytes(size_t length, const void** data);
+
  private:
   ValueDeserializer(const ValueDeserializer&) = delete;
   void operator=(const ValueDeserializer&) = delete;
 
   struct PrivateData;
   PrivateData* private_;
 };
 
 /**
  * A map whose keys are referenced weakly. It is similar to JavaScript WeakMap
@@ skipping 7699 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_