WIP: Allow ValueSerializer clients to transfer long strings out of band.

src/value-serializer.h

 // Copyright 2016 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.
 
 #ifndef V8_VALUE_SERIALIZER_H_
 #define V8_VALUE_SERIALIZER_H_
 
 #include <cstdint>
 #include <vector>
 
@@ skipping 76 matching lines @@
 
   /*
    * Indicate whether to treat ArrayBufferView objects as host objects,
    * i.e. pass them to Delegate::WriteHostObject. This should not be
    * called when no Delegate was passed.
    *
    * The default is not to treat ArrayBufferViews as host objects.
    */
   void SetTreatArrayBufferViewsAsHostObjects(bool mode);
 
+  /*
+   * If a positive values is assigned, strings of at least that length will be
+   * passed to the delegate instead of serialized inline into the buffer.
+   * This option is recommended only if the delegate has a more efficient means
+   * of delivering those strings. By default, this feature is disabled.
+   */
+  void SetMinimumLongStringLength(int length) {
+    long_string_threshold_ = length;
+  }
+
  private:
   // Managing allocations of the internal buffer.
   Maybe<bool> ExpandBuffer(size_t required_capacity);
 
   // Writing the wire format.
   void WriteTag(SerializationTag tag);
   template <typename T>
   void WriteVarint(T value);
   template <typename T>
   void WriteZigZag(T value);
   void WriteOneByteString(Vector<const uint8_t> chars);
   void WriteTwoByteString(Vector<const uc16> chars);
   Maybe<uint8_t*> ReserveRawBytes(size_t bytes);
 
   // Writing V8 objects of various kinds.
   void WriteOddball(Oddball* oddball);
   void WriteSmi(Smi* smi);
   void WriteHeapNumber(HeapNumber* number);
-  void WriteString(Handle<String> string);
+  Maybe<bool> WriteString(Handle<String> string);
   Maybe<bool> WriteJSReceiver(Handle<JSReceiver> receiver) WARN_UNUSED_RESULT;
   Maybe<bool> WriteJSObject(Handle<JSObject> object) WARN_UNUSED_RESULT;
   Maybe<bool> WriteJSObjectSlow(Handle<JSObject> object) WARN_UNUSED_RESULT;
   Maybe<bool> WriteJSArray(Handle<JSArray> array) WARN_UNUSED_RESULT;
   void WriteJSDate(JSDate* date);
   Maybe<bool> WriteJSValue(Handle<JSValue> value) WARN_UNUSED_RESULT;
   void WriteJSRegExp(JSRegExp* regexp);
   Maybe<bool> WriteJSMap(Handle<JSMap> map) WARN_UNUSED_RESULT;
   Maybe<bool> WriteJSSet(Handle<JSSet> map) WARN_UNUSED_RESULT;
   Maybe<bool> WriteJSArrayBuffer(Handle<JSArrayBuffer> array_buffer)
@@ skipping 31 matching lines @@
 
   // To avoid extra lookups in the identity map, ID+1 is actually stored in the
   // map (checking if the used identity is zero is the fast way of checking if
   // the entry is new).
   IdentityMap<uint32_t, ZoneAllocationPolicy> id_map_;
   uint32_t next_id_ = 0;
 
   // A similar map, for transferred array buffers.
   IdentityMap<uint32_t, ZoneAllocationPolicy> array_buffer_transfer_map_;
 
+  // Used for tracking long strings.
+  int long_string_threshold_ = -1;
+  IdentityMap<uint32_t, ZoneAllocationPolicy> long_string_map_;
+
   DISALLOW_COPY_AND_ASSIGN(ValueSerializer);
 };
 
 /*
  * Deserializes values from data written with ValueSerializer, or a compatible
  * implementation.
  */
 class ValueDeserializer {
  public:
   ValueDeserializer(Isolate* isolate, Vector<const uint8_t> data,
@@ skipping 28 matching lines @@
       WARN_UNUSED_RESULT;
 
   /*
    * Accepts the array buffer corresponding to the one passed previously to
    * ValueSerializer::TransferArrayBuffer.
    */
   void TransferArrayBuffer(uint32_t transfer_id,
                            Handle<JSArrayBuffer> array_buffer);
 
   /*
+   * Accepts a long string corresponding to one passed previously to
+   * ValueSerializer::Delegate::GetLongStringId.
+   */
+  void TransferLongString(uint32_t transfer_id, Handle<String> string);
+
+  /*
    * Publicly exposed wire format writing methods.
    * These are intended for use within the delegate's WriteHostObject method.
    */
   bool ReadUint32(uint32_t* value) WARN_UNUSED_RESULT;
   bool ReadUint64(uint64_t* value) WARN_UNUSED_RESULT;
   bool ReadDouble(double* value) WARN_UNUSED_RESULT;
   bool ReadRawBytes(size_t length, const void** data) WARN_UNUSED_RESULT;
   void set_expect_inline_wasm(bool expect_inline_wasm) {
     expect_inline_wasm_ = expect_inline_wasm;
   }
@@ skipping 22 matching lines @@
   // Reads a string intended to be part of a more complicated object.
   // Before v12, these are UTF-8 strings. After, they can be any encoding
   // permissible for a string (with the relevant tag).
   MaybeHandle<String> ReadString() WARN_UNUSED_RESULT;
 
   // Reading V8 objects of specific kinds.
   // The tag is assumed to have already been read.
   MaybeHandle<String> ReadUtf8String() WARN_UNUSED_RESULT;
   MaybeHandle<String> ReadOneByteString() WARN_UNUSED_RESULT;
   MaybeHandle<String> ReadTwoByteString() WARN_UNUSED_RESULT;
+  MaybeHandle<String> ReadLongString() WARN_UNUSED_RESULT;
   MaybeHandle<JSObject> ReadJSObject() WARN_UNUSED_RESULT;
   MaybeHandle<JSArray> ReadSparseJSArray() WARN_UNUSED_RESULT;
   MaybeHandle<JSArray> ReadDenseJSArray() WARN_UNUSED_RESULT;
   MaybeHandle<JSDate> ReadJSDate() WARN_UNUSED_RESULT;
   MaybeHandle<JSValue> ReadJSValue(SerializationTag tag) WARN_UNUSED_RESULT;
   MaybeHandle<JSRegExp> ReadJSRegExp() WARN_UNUSED_RESULT;
   MaybeHandle<JSMap> ReadJSMap() WARN_UNUSED_RESULT;
   MaybeHandle<JSSet> ReadJSSet() WARN_UNUSED_RESULT;
   MaybeHandle<JSArrayBuffer> ReadJSArrayBuffer() WARN_UNUSED_RESULT;
   MaybeHandle<JSArrayBuffer> ReadTransferredJSArrayBuffer(bool is_shared)
@@ skipping 22 matching lines @@
   const uint8_t* position_;
   const uint8_t* const end_;
   PretenureFlag pretenure_;
   uint32_t version_ = 0;
   uint32_t next_id_ = 0;
   bool expect_inline_wasm_ = false;
 
   // Always global handles.
   Handle<FixedArray> id_map_;
   MaybeHandle<SeededNumberDictionary> array_buffer_transfer_map_;
+  MaybeHandle<SeededNumberDictionary> long_string_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ValueDeserializer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_VALUE_SERIALIZER_H_