Blink-compatible serialization of Boolean, Number and String objects.

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/factory.h"
@@ skipping 54 matching lines @@
   kBeginSparseJSArray = 'a',
   // End of a sparse JS array. numProperties:uint32_t length:uint32_t
   kEndSparseJSArray = '@',
   // Beginning of a dense JS array. length:uint32_t
   // |length| elements, followed by properties as key/value pairs
   kBeginDenseJSArray = 'A',
   // End of a dense JS array. numProperties:uint32_t length:uint32_t
   kEndDenseJSArray = '$',
   // Date. millisSinceEpoch:double
   kDate = 'D',
+  // Boolean object. No data.
+  kTrueObject = 'y',
+  kFalseObject = 'x',
+  // Number object. value:double
+  kNumberObject = 'n',
+  // String object, UTF-8 encoding. byteLength:uint32_t, then raw data.
+  kStringObject = 's',
 };
 
 ValueSerializer::ValueSerializer(Isolate* isolate)
     : isolate_(isolate),
       zone_(isolate->allocator()),
       id_map_(isolate->heap(), &zone_) {}
 
 ValueSerializer::~ValueSerializer() {}
 
 void ValueSerializer::WriteHeader() {
@@ skipping 49 matching lines @@
 }
 
 void ValueSerializer::WriteTwoByteString(Vector<const uc16> chars) {
   // Warning: this uses host endianness.
   WriteVarint<uint32_t>(chars.length() * sizeof(uc16));
   buffer_.insert(buffer_.end(), reinterpret_cast<const uint8_t*>(chars.begin()),
                  reinterpret_cast<const uint8_t*>(chars.end()));
 }
 
 uint8_t* ValueSerializer::ReserveRawBytes(size_t bytes) {
+  if (!bytes) return nullptr;

[jbroman, 2016/08/19 19:11:16]

This sometimes triggered the debug std::vector checks (it complains when trying
to compute the address of &buffer_[old_size] if that's at the end of the
vector). Returning nullptr is fine, since the caller has promised to write at
most zero bytes.

   auto old_size = buffer_.size();
   buffer_.resize(buffer_.size() + bytes);
   return &buffer_[old_size];
 }
 
 Maybe<bool> ValueSerializer::WriteObject(Handle<Object> object) {
   if (object->IsSmi()) {
     WriteSmi(Smi::cast(*object));
     return Just(true);
   }
@@ skipping 112 matching lines @@
   HandleScope scope(isolate_);
   switch (instance_type) {
     case JS_ARRAY_TYPE:
       return WriteJSArray(Handle<JSArray>::cast(receiver));
     case JS_OBJECT_TYPE:
     case JS_API_OBJECT_TYPE:
       return WriteJSObject(Handle<JSObject>::cast(receiver));
     case JS_DATE_TYPE:
       WriteJSDate(JSDate::cast(*receiver));
       return Just(true);
+    case JS_VALUE_TYPE:
+      return WriteJSValue(Handle<JSValue>::cast(receiver));
     default:
       UNIMPLEMENTED();
       break;
   }
   return Nothing<bool>();
 }
 
 Maybe<bool> ValueSerializer::WriteJSObject(Handle<JSObject> object) {
   WriteTag(SerializationTag::kBeginJSObject);
   Handle<FixedArray> keys;
@@ skipping 70 matching lines @@
     WriteVarint<uint32_t>(length);
   }
   return Just(true);
 }
 
 void ValueSerializer::WriteJSDate(JSDate* date) {
   WriteTag(SerializationTag::kDate);
   WriteDouble(date->value()->Number());
 }
 
+Maybe<bool> ValueSerializer::WriteJSValue(Handle<JSValue> value) {
+  Object* inner_value = value->value();
+  if (value->HasSpecificClassOf(isolate_->heap()->Boolean_string())) {
+    if (inner_value->IsTrue(isolate_)) {
+      WriteTag(SerializationTag::kTrueObject);
+    } else {
+      DCHECK(inner_value->IsFalse(isolate_));
+      WriteTag(SerializationTag::kFalseObject);
+    }
+  } else if (value->HasSpecificClassOf(isolate_->heap()->Number_string())) {
+    DCHECK(inner_value->IsNumber());
+    WriteTag(SerializationTag::kNumberObject);
+    WriteDouble(inner_value->Number());
+  } else if (value->HasSpecificClassOf(isolate_->heap()->String_string())) {
+    DCHECK(inner_value->IsString());
+    // TODO(jbroman): Replace UTF-8 encoding with the same options available for
+    // ordinary strings.
+    WriteTag(SerializationTag::kStringObject);
+    v8::Local<v8::String> api_string =
+        Utils::ToLocal(handle(String::cast(inner_value), isolate_));
+    uint32_t utf8_length = api_string->Utf8Length();
+    WriteVarint(utf8_length);
+    api_string->WriteUtf8(reinterpret_cast<char*>(ReserveRawBytes(utf8_length)),
+                          utf8_length, nullptr,
+                          v8::String::NO_NULL_TERMINATION);
+  } else {
+    return Nothing<bool>();
+  }
+  return Just(true);
+}
+
 Maybe<uint32_t> ValueSerializer::WriteJSObjectProperties(
     Handle<JSObject> object, Handle<FixedArray> keys) {
   uint32_t properties_written = 0;
   int length = keys->length();
   for (int i = 0; i < length; i++) {
     Handle<Object> key(keys->get(i), isolate_);
 
     bool success;
     LookupIterator it = LookupIterator::PropertyOrElement(
         isolate_, object, key, &success, LookupIterator::OWN);
@@ skipping 162 matching lines @@
       return GetObjectWithID(id);
     }
     case SerializationTag::kBeginJSObject:
       return ReadJSObject();
     case SerializationTag::kBeginSparseJSArray:
       return ReadSparseJSArray();
     case SerializationTag::kBeginDenseJSArray:
       return ReadDenseJSArray();
     case SerializationTag::kDate:
       return ReadJSDate();
+    case SerializationTag::kTrueObject:
+    case SerializationTag::kFalseObject:
+    case SerializationTag::kNumberObject:
+    case SerializationTag::kStringObject:
+      return ReadJSValue(tag);
     default:
       return MaybeHandle<Object>();
   }
 }
 
 MaybeHandle<String> ValueDeserializer::ReadUtf8String() {
   uint32_t utf8_length;
   Vector<const uint8_t> utf8_bytes;
   if (!ReadVarint<uint32_t>().To(&utf8_length) ||
       utf8_length >
@@ skipping 121 matching lines @@
   uint32_t id = next_id_++;
   Handle<JSDate> date;
   if (!JSDate::New(isolate_->date_function(), isolate_->date_function(), value)
            .ToHandle(&date)) {
     return MaybeHandle<JSDate>();
   }
   AddObjectWithID(id, date);
   return date;
 }
 
+MaybeHandle<JSValue> ValueDeserializer::ReadJSValue(SerializationTag tag) {
+  uint32_t id = next_id_++;
+  Handle<JSValue> value;
+  switch (tag) {
+    case SerializationTag::kTrueObject:
+      value = Handle<JSValue>::cast(
+          isolate_->factory()->NewJSObject(isolate_->boolean_function()));
+      value->set_value(isolate_->heap()->true_value());
+      break;
+    case SerializationTag::kFalseObject:
+      value = Handle<JSValue>::cast(
+          isolate_->factory()->NewJSObject(isolate_->boolean_function()));
+      value->set_value(isolate_->heap()->false_value());
+      break;
+    case SerializationTag::kNumberObject: {
+      double number;
+      if (!ReadDouble().To(&number)) return MaybeHandle<JSValue>();
+      value = Handle<JSValue>::cast(
+          isolate_->factory()->NewJSObject(isolate_->number_function()));
+      value->set_value(*isolate_->factory()->NewNumber(number));
+      break;
+    }
+    case SerializationTag::kStringObject: {
+      Handle<String> string;
+      if (!ReadUtf8String().ToHandle(&string)) return MaybeHandle<JSValue>();
+      value = Handle<JSValue>::cast(
+          isolate_->factory()->NewJSObject(isolate_->string_function()));
+      value->set_value(*string);
+      break;
+    }
+    default:
+      return MaybeHandle<JSValue>();
+  }
+  AddObjectWithID(id, value);
+  return value;
+}
+
 Maybe<uint32_t> ValueDeserializer::ReadJSObjectProperties(
     Handle<JSObject> object, SerializationTag end_tag) {
   for (uint32_t num_properties = 0;; num_properties++) {
     SerializationTag tag;
     if (!PeekTag().To(&tag)) return Nothing<uint32_t>();
     if (tag == end_tag) {
       ConsumeTag(end_tag);
       return Just(num_properties);
     }
 
@@ skipping 144 matching lines @@
   }
 #endif
   position_ = end_;
 
   if (stack.size() != 1) return MaybeHandle<Object>();
   return scope.CloseAndEscape(stack[0]);
 }
 
 }  // namespace internal
 }  // namespace v8