Blink-compatible serialization of dates.

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 52 matching lines @@
   // 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
   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',
 };
 
 ValueSerializer::ValueSerializer(Isolate* isolate)
     : isolate_(isolate),
       zone_(isolate->allocator()),
       id_map_(isolate->heap(), &zone_) {}
 
 ValueSerializer::~ValueSerializer() {}
 
 void ValueSerializer::WriteHeader() {
@@ skipping 178 matching lines @@
   // If we are at the end of the stack, abort. This function may recurse.
   if (StackLimitCheck(isolate_).HasOverflowed()) return Nothing<bool>();
 
   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);
     default:
       UNIMPLEMENTED();
       break;
   }
   return Nothing<bool>();
 }
 
 Maybe<bool> ValueSerializer::WriteJSObject(Handle<JSObject> object) {
   WriteTag(SerializationTag::kBeginJSObject);
   Handle<FixedArray> keys;
@@ skipping 65 matching lines @@
         !WriteJSObjectProperties(array, keys).To(&properties_written)) {
       return Nothing<bool>();
     }
     WriteTag(SerializationTag::kEndSparseJSArray);
     WriteVarint<uint32_t>(properties_written);
     WriteVarint<uint32_t>(length);
   }
   return Just(true);
 }
 
+void ValueSerializer::WriteJSDate(JSDate* date) {
+  WriteTag(SerializationTag::kDate);
+  WriteDouble(date->value()->Number());
+}
+
 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 160 matching lines @@
       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:
       return ReadDenseJSArray();
+    case SerializationTag::kDate:
+      return ReadJSDate();
     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 108 matching lines @@
       !ReadVarint<uint32_t>().To(&expected_num_properties) ||
       !ReadVarint<uint32_t>().To(&expected_length) ||
       num_properties != expected_num_properties || length != expected_length) {
     return MaybeHandle<JSArray>();
   }
 
   DCHECK(HasObjectWithID(id));
   return scope.CloseAndEscape(array);
 }
 
+MaybeHandle<JSDate> ValueDeserializer::ReadJSDate() {
+  double value;
+  if (!ReadDouble().To(&value)) return MaybeHandle<JSDate>();
+  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;
+}
+
 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