Blink-compatible serialization of RegExp 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 61 matching lines @@
   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',
+  // Regular expression, UTF-8 encoding. byteLength:uint32_t, raw data,
+  // flags:uint32_t.
+  kRegExp = 'R',
 };
 
 ValueSerializer::ValueSerializer(Isolate* isolate)
     : isolate_(isolate),
       zone_(isolate->allocator()),
       id_map_(isolate->heap(), &zone_) {}
 
 ValueSerializer::~ValueSerializer() {}
 
 void ValueSerializer::WriteHeader() {
@@ skipping 184 matching lines @@
     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));
+    case JS_REGEXP_TYPE:
+      WriteJSRegExp(JSRegExp::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 97 matching lines @@
     api_string->WriteUtf8(reinterpret_cast<char*>(ReserveRawBytes(utf8_length)),
                           utf8_length, nullptr,
                           v8::String::NO_NULL_TERMINATION);
   } else {
     DCHECK(inner_value->IsSymbol());
     return Nothing<bool>();
   }
   return Just(true);
 }
 
+void ValueSerializer::WriteJSRegExp(JSRegExp* regexp) {
+  WriteTag(SerializationTag::kRegExp);
+  v8::Local<v8::String> api_string =
+      Utils::ToLocal(handle(regexp->Pattern(), 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);
+  WriteVarint(static_cast<uint32_t>(regexp->GetFlags()));
+}
+
 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 167 matching lines @@
       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);
+    case SerializationTag::kRegExp:
+      return ReadJSRegExp();
     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 160 matching lines @@
       break;
     }
     default:
       UNREACHABLE();
       return MaybeHandle<JSValue>();
   }
   AddObjectWithID(id, value);
   return value;
 }
 
+MaybeHandle<JSRegExp> ValueDeserializer::ReadJSRegExp() {
+  uint32_t id = next_id_++;
+  Handle<String> pattern;
+  uint32_t raw_flags;
+  Handle<JSRegExp> regexp;
+  if (!ReadUtf8String().ToHandle(&pattern) ||
+      !ReadVarint<uint32_t>().To(&raw_flags) ||
+      !JSRegExp::New(pattern, static_cast<JSRegExp::Flags>(raw_flags))
+           .ToHandle(&regexp)) {
+    return MaybeHandle<JSRegExp>();
+  }
+  AddObjectWithID(id, regexp);
+  return regexp;
+}
+
 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