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

src/value-serializer.cc

 // 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.
 
 #include "src/value-serializer.h"
 
 #include <type_traits>
 
 #include "src/base/logging.h"
 #include "src/conversions.h"
@@ skipping 53 matching lines @@
   // Number represented as 32-bit unsigned integer, varint-encoded
   // (like uint32 in protobuf)
   kUint32 = 'U',
   // Number represented as a 64-bit double.
   // Host byte order is used (N.B. this makes the format non-portable).
   kDouble = 'N',
   // byteLength:uint32_t, then raw data
   kUtf8String = 'S',
   kOneByteString = '"',
   kTwoByteString = 'c',
+  // ID:uint32_t. Only used if the client requests it.
+  kLongString = '>',
   // Reference to a serialized object. objectID:uint32_t
   kObjectReference = '^',
   // Beginning of a JS object.
   kBeginJSObject = 'o',
   // End of a JS object. numProperties:uint32_t
   kEndJSObject = '{',
   // Beginning of a sparse JS array. length:uint32_t
   // Elements and properties are written as key/value pairs, like objects.
   kBeginSparseJSArray = 'a',
   // End of a sparse JS array. numProperties:uint32_t length:uint32_t
@@ skipping 69 matching lines @@
 };
 
 }  // namespace
 
 ValueSerializer::ValueSerializer(Isolate* isolate,
                                  v8::ValueSerializer::Delegate* delegate)
     : isolate_(isolate),
       delegate_(delegate),
       zone_(isolate->allocator(), ZONE_NAME),
       id_map_(isolate->heap(), ZoneAllocationPolicy(&zone_)),
-      array_buffer_transfer_map_(isolate->heap(),
-                                 ZoneAllocationPolicy(&zone_)) {}
+      array_buffer_transfer_map_(isolate->heap(), ZoneAllocationPolicy(&zone_)),
+      long_string_map_(isolate->heap(), ZoneAllocationPolicy(&zone_)) {}
 
 ValueSerializer::~ValueSerializer() {
   if (buffer_) {
     if (delegate_) {
       delegate_->FreeBufferMemory(buffer_);
     } else {
       free(buffer_);
     }
   }
 }
@@ skipping 159 matching lines @@
         Handle<JSArrayBuffer> buffer(
             view->IsJSTypedArray()
                 ? Handle<JSTypedArray>::cast(view)->GetBuffer()
                 : handle(JSArrayBuffer::cast(view->buffer()), isolate_));
         if (!WriteJSReceiver(buffer).FromMaybe(false)) return Nothing<bool>();
       }
       return WriteJSReceiver(view);
     }
     default:
       if (object->IsString()) {
-        WriteString(Handle<String>::cast(object));
-        return ThrowIfOutOfMemory();
+        return WriteString(Handle<String>::cast(object));
       } else if (object->IsJSReceiver()) {
         return WriteJSReceiver(Handle<JSReceiver>::cast(object));
       } else {
         ThrowDataCloneError(MessageTemplate::kDataCloneError, object);
         return Nothing<bool>();
       }
   }
 }
 
 void ValueSerializer::WriteOddball(Oddball* oddball) {
@@ skipping 22 matching lines @@
   static_assert(kSmiValueSize <= 32, "Expected SMI <= 32 bits.");
   WriteTag(SerializationTag::kInt32);
   WriteZigZag<int32_t>(smi->value());
 }
 
 void ValueSerializer::WriteHeapNumber(HeapNumber* number) {
   WriteTag(SerializationTag::kDouble);
   WriteDouble(number->value());
 }
 
-void ValueSerializer::WriteString(Handle<String> string) {
+Maybe<bool> ValueSerializer::WriteString(Handle<String> string) {
+  if (long_string_threshold_ >= 0 &&
+      V8_UNLIKELY(string->length() >= long_string_threshold_)) {
+    uint32_t* entry = long_string_map_.Find(string);
+    if (!entry) {
+      entry = long_string_map_.Get(string);
+      Maybe<uint32_t> index = delegate_->GetLongStringId(
+          reinterpret_cast<v8::Isolate*>(isolate_), Utils::ToLocal(string));
+      RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate_, Nothing<bool>());
+      *entry = index.FromJust();
+    }
+    WriteTag(SerializationTag::kLongString);
+    WriteVarint(*entry);
+    return ThrowIfOutOfMemory();
+  }
+
   string = String::Flatten(string);
   DisallowHeapAllocation no_gc;
   String::FlatContent flat = string->GetFlatContent();
   DCHECK(flat.IsFlat());
   if (flat.IsOneByte()) {
     Vector<const uint8_t> chars = flat.ToOneByteVector();
     WriteTag(SerializationTag::kOneByteString);
     WriteOneByteString(chars);
   } else if (flat.IsTwoByte()) {
     Vector<const uc16> chars = flat.ToUC16Vector();
     uint32_t byte_length = chars.length() * sizeof(uc16);
     // The existing reading code expects 16-byte strings to be aligned.
     if ((buffer_size_ + 1 + BytesNeededForVarint(byte_length)) & 1)
       WriteTag(SerializationTag::kPadding);
     WriteTag(SerializationTag::kTwoByteString);
     WriteTwoByteString(chars);
   } else {
     UNREACHABLE();
   }
+  return ThrowIfOutOfMemory();
 }
 
 Maybe<bool> ValueSerializer::WriteJSReceiver(Handle<JSReceiver> receiver) {
   // If the object has already been serialized, just write its ID.
   uint32_t* id_map_entry = id_map_.Get(receiver);
   if (uint32_t id = *id_map_entry) {
     WriteTag(SerializationTag::kObjectReference);
     WriteVarint(id - 1);
     return ThrowIfOutOfMemory();
   }
@@ skipping 644 matching lines @@
   Handle<SeededNumberDictionary> new_dictionary =
       SeededNumberDictionary::AtNumberPut(dictionary, transfer_id, array_buffer,
                                           not_a_prototype_holder);
   if (!new_dictionary.is_identical_to(dictionary)) {
     GlobalHandles::Destroy(Handle<Object>::cast(dictionary).location());
     array_buffer_transfer_map_ = Handle<SeededNumberDictionary>::cast(
         isolate_->global_handles()->Create(*new_dictionary));
   }
 }
 
+void ValueDeserializer::TransferLongString(uint32_t transfer_id,
+                                           Handle<String> string) {
+  if (long_string_map_.is_null()) {
+    long_string_map_ =
+        Handle<SeededNumberDictionary>::cast(isolate_->global_handles()->Create(
+            *SeededNumberDictionary::New(isolate_, 0)));
+  }
+  Handle<SeededNumberDictionary> dictionary =
+      long_string_map_.ToHandleChecked();
+  Handle<JSObject> not_a_prototype_holder;
+  Handle<SeededNumberDictionary> new_dictionary =
+      SeededNumberDictionary::AtNumberPut(dictionary, transfer_id, string,
+                                          not_a_prototype_holder);
+  if (!new_dictionary.is_identical_to(dictionary)) {
+    GlobalHandles::Destroy(Handle<Object>::cast(dictionary).location());
+    long_string_map_ = Handle<SeededNumberDictionary>::cast(
+        isolate_->global_handles()->Create(*new_dictionary));
+  }
+}
+
 MaybeHandle<Object> ValueDeserializer::ReadObject() {
   MaybeHandle<Object> result = ReadObjectInternal();
 
   // ArrayBufferView is special in that it consumes the value before it, even
   // after format version 0.
   Handle<Object> object;
   SerializationTag tag;
   if (result.ToHandle(&object) && V8_UNLIKELY(object->IsJSArrayBuffer()) &&
       PeekTag().To(&tag) && tag == SerializationTag::kArrayBufferView) {
     ConsumeTag(SerializationTag::kArrayBufferView);
@@ skipping 40 matching lines @@
       Maybe<double> number = ReadDouble();
       if (number.IsNothing()) return MaybeHandle<Object>();
       return isolate_->factory()->NewNumber(number.FromJust(), pretenure_);
     }
     case SerializationTag::kUtf8String:
       return ReadUtf8String();
     case SerializationTag::kOneByteString:
       return ReadOneByteString();
     case SerializationTag::kTwoByteString:
       return ReadTwoByteString();
+    case SerializationTag::kLongString:
+      return ReadLongString();
     case SerializationTag::kObjectReference: {
       uint32_t id;
       if (!ReadVarint<uint32_t>().To(&id)) return MaybeHandle<Object>();
       return GetObjectWithID(id);
     }
     case SerializationTag::kBeginJSObject:
       return ReadJSObject();
     case SerializationTag::kBeginSparseJSArray:
       return ReadSparseJSArray();
     case SerializationTag::kBeginDenseJSArray:
@@ skipping 92 matching lines @@
            .ToHandle(&string)) {
     return MaybeHandle<String>();
   }
 
   // Copy the bytes directly into the new string.
   // Warning: this uses host endianness.
   memcpy(string->GetChars(), bytes.begin(), bytes.length());
   return string;
 }
 
+MaybeHandle<String> ValueDeserializer::ReadLongString() {
+  uint32_t transfer_id;
+  Handle<SeededNumberDictionary> transfer_map;
+  if (!ReadVarint<uint32_t>().To(&transfer_id) ||
+      !long_string_map_.ToHandle(&transfer_map)) {
+    return MaybeHandle<String>();
+  }
+  int index = transfer_map->FindEntry(isolate_, transfer_id);
+  if (index == SeededNumberDictionary::kNotFound) {
+    return MaybeHandle<String>();
+  }
+  return handle(String::cast(transfer_map->ValueAt(index)), isolate_);
+}
+
 bool ValueDeserializer::ReadExpectedString(Handle<String> expected) {
   // In the case of failure, the position in the stream is reset.
   const uint8_t* original_position = position_;
 
   SerializationTag tag;
   uint32_t byte_length;
   Vector<const uint8_t> bytes;
   if (!ReadTag().To(&tag) || !ReadVarint<uint32_t>().To(&byte_length) ||
       byte_length >
           static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) ||
@@ skipping 757 matching lines @@
   if (stack.size() != 1) {
     isolate_->Throw(*isolate_->factory()->NewError(
         MessageTemplate::kDataCloneDeserializationError));
     return MaybeHandle<Object>();
   }
   return scope.CloseAndEscape(stack[0]);
 }
 
 }  // namespace internal
 }  // namespace v8