Support structured cloning of ES'15 Map and Set

Source/bindings/core/v8/ScriptValueSerializer.cpp

 // Copyright 2014 The Chromium 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 "config.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
@@ skipping 360 matching lines @@
     append(GenerateFreshSparseArrayTag);
     doWriteUint32(length);
 }
 
 void SerializedScriptValueWriter::writeGenerateFreshDenseArray(uint32_t length)
 {
     append(GenerateFreshDenseArrayTag);
     doWriteUint32(length);
 }
 
+void SerializedScriptValueWriter::writeGenerateFreshMap()
+{
+    append(GenerateFreshMapTag);
+}
+
+void SerializedScriptValueWriter::writeGenerateFreshSet()
+{
+    append(GenerateFreshSetTag);
+}
+
+void SerializedScriptValueWriter::writeMap(uint32_t length)
+{
+    append(MapTag);
+    doWriteUint32(length);
+}
+
+void SerializedScriptValueWriter::writeSet(uint32_t length)
+{
+    append(SetTag);
+    doWriteUint32(length);
+}
+
 void SerializedScriptValueWriter::doWriteFile(const File& file)
 {
     doWriteWebCoreString(file.hasBackingFile() ? file.path() : "");
     doWriteWebCoreString(file.name());
     doWriteWebCoreString(file.webkitRelativePath());
     doWriteWebCoreString(file.uuid());
     doWriteWebCoreString(file.type());
 
     // FIXME don't use 1 byte to encode a flag.
     if (file.hasValidSnapshotMetadata()) {
@@ skipping 180 matching lines @@
 ScriptValueSerializer::StateBase* ScriptValueSerializer::SparseArrayState::advance(ScriptValueSerializer& serializer)
 {
     return serializeProperties(false, serializer);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::SparseArrayState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
 {
     return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
 }
 
+template <typename T>
+ScriptValueSerializer::StateBase* ScriptValueSerializer::CollectionState<T>::advance(ScriptValueSerializer& serializer)
+{
+    while (m_index < m_length) {
+        v8::Local<v8::Value> value;
+        if (!m_entries->Get(serializer.context(), m_index).ToLocal(&value))
+            return serializer.handleError(JSException, "Failed to get an element while cloning a collection.", this);
+        m_index++;
+        if (StateBase* newState = serializer.checkException(this))
+            return newState;
+        if (StateBase* newState = serializer.doSerialize(value, this))
+            return newState;
+    }
+    return serializer.writeCollection<T>(m_length, this);
+}
+
 static v8::Local<v8::Object> toV8Object(MessagePort* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Local<v8::Object>();
     v8::Local<v8::Value> wrapper = toV8(impl, creationContext, isolate);
     if (wrapper.IsEmpty())
         return v8::Local<v8::Object>();
     ASSERT(wrapper->IsObject());
     return wrapper.As<v8::Object>();
 }
@@ skipping 112 matching lines @@
         if (value->IsDate()) {
             m_writer.writeDate(value.As<v8::Date>()->ValueOf());
         } else if (value->IsStringObject()) {
             writeStringObject(value);
         } else if (value->IsNumberObject()) {
             writeNumberObject(value);
         } else if (value->IsBooleanObject()) {
             writeBooleanObject(value);
         } else if (value->IsArray()) {
             return startArrayState(value.As<v8::Array>(), next);
+        } else if (value->IsMap()) {
+            return startMapState(value.As<v8::Map>(), next);
+        } else if (value->IsSet()) {
+            return startSetState(value.As<v8::Set>(), next);
         } else if (V8File::hasInstance(value, isolate())) {
             return writeFile(value, next);
         } else if (V8Blob::hasInstance(value, isolate())) {
             return writeBlob(value, next);
         } else if (V8FileList::hasInstance(value, isolate())) {
             return writeFileList(value, next);
         } else if (V8ImageData::hasInstance(value, isolate())) {
             writeImageData(value);
         } else if (value->IsRegExp()) {
             writeRegExp(value);
@@ skipping 33 matching lines @@
     m_writer.writeSparseArray(numProperties, length);
     return pop(state);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeDenseArray(uint32_t numProperties, uint32_t length, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeDenseArray(numProperties, length);
     return pop(state);
 }
 
+template <>
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeCollection<v8::Map>(uint32_t length, ScriptValueSerializer::StateBase* state)
+{
+    m_writer.writeMap(length);
+    return pop(state);
+}
+
+template <>
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeCollection<v8::Set>(uint32_t length, ScriptValueSerializer::StateBase* state)
+{
+    m_writer.writeSet(length);
+    return pop(state);
+}
+
 ScriptValueSerializer::StateBase* ScriptValueSerializer::handleError(ScriptValueSerializer::Status errorStatus, const String& message, ScriptValueSerializer::StateBase* state)
 {
     ASSERT(errorStatus != Success);
     m_status = errorStatus;
     m_errorMessage = message;
     while (state) {
         StateBase* tmp = state->nextState();
         delete state;
         state = tmp;
     }
@@ skipping 199 matching lines @@
 
     if (shouldSerializeDensely(length, propertyNames->Length())) {
         m_writer.writeGenerateFreshDenseArray(length);
         return push(new DenseArrayState(array, propertyNames, next, isolate()));
     }
 
     m_writer.writeGenerateFreshSparseArray(length);
     return push(new SparseArrayState(array, propertyNames, next, isolate()));
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializer::startMapState(v8::Local<v8::Map> map, ScriptValueSerializer::StateBase* next)
+{
+    m_writer.writeGenerateFreshMap();
+    return push(new MapState(map, next));
+}
+
+ScriptValueSerializer::StateBase* ScriptValueSerializer::startSetState(v8::Local<v8::Set> set, ScriptValueSerializer::StateBase* next)
+{
+    m_writer.writeGenerateFreshSet();
+    return push(new SetState(set, next));
+}
+
 ScriptValueSerializer::StateBase* ScriptValueSerializer::startObjectState(v8::Local<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     m_writer.writeGenerateFreshObject();
     // FIXME: check not a wrapper
     return push(new ObjectState(object, next));
 }
 
 // Marks object as having been visited by the serializer and assigns it a unique object reference ID.
 // An object may only be greyed once.
 void ScriptValueSerializer::greyObject(const v8::Local<v8::Object>& object)
@@ skipping 168 matching lines @@
         uint32_t numProperties;
         uint32_t length;
         if (!doReadUint32(&numProperties))
             return false;
         if (!doReadUint32(&length))
             return false;
         if (!creator.completeDenseArray(numProperties, length, value))
             return false;
         break;
     }
+    case MapTag: {
+        uint32_t length;
+        if (!doReadUint32(&length))
+            return false;
+        if (!creator.completeMap(length, value))
+            return false;
+        break;
+    }
+    case SetTag: {
+        uint32_t length;
+        if (!doReadUint32(&length))
+            return false;
+        if (!creator.completeSet(length, value))
+            return false;
+        break;
+    }
     case ArrayBufferViewTag: {
         if (!m_version)
             return false;
         if (!readArrayBufferView(value, creator))
             return false;
         creator.pushObjectReference(*value);
         break;
     }
     case ArrayBufferTag: {
         if (!m_version)
@@ skipping 23 matching lines @@
     case GenerateFreshDenseArrayTag: {
         if (!m_version)
             return false;
         uint32_t length;
         if (!doReadUint32(&length))
             return false;
         if (!creator.newDenseArray(length))
             return false;
         return true;
     }
+    case GenerateFreshMapTag: {
+        if (!m_version)
+            return false;
+        if (!creator.newMap())
+            return false;
+        return true;
+    }
+    case GenerateFreshSetTag: {
+        if (!m_version)
+            return false;
+        if (!creator.newSet())
+            return false;
+        return true;
+    }
     case MessagePortTag: {
         if (!m_version)
             return false;
         uint32_t index;
         if (!doReadUint32(&index))
             return false;
         if (!creator.tryGetTransferredMessagePort(index, value))
             return false;
         break;
     }
@@ skipping 527 matching lines @@
     return true;
 }
 
 bool ScriptValueDeserializer::newDenseArray(uint32_t length)
 {
     v8::Local<v8::Array> array = v8::Array::New(m_reader.scriptState()->isolate(), length);
     openComposite(array);
     return true;
 }
 
+bool ScriptValueDeserializer::newMap()
+{
+    v8::Local<v8::Map> map = v8::Map::New(m_reader.scriptState()->isolate());
+    openComposite(map);
+    return true;
+}
+
+bool ScriptValueDeserializer::newSet()
+{
+    v8::Local<v8::Set> set = v8::Set::New(m_reader.scriptState()->isolate());
+    openComposite(set);
+    return true;
+}
+
 bool ScriptValueDeserializer::consumeTopOfStack(v8::Local<v8::Value>* object)
 {
     if (stackDepth() < 1)
         return false;
     *object = element(stackDepth() - 1);
     pop(1);
     return true;
 }
 
 bool ScriptValueDeserializer::newObject()
@@ skipping 57 matching lines @@
         v8::Local<v8::Value> elem = element(stackPos);
         if (!elem->IsUndefined()) {
             if (!v8CallBoolean(array->CreateDataProperty(context, i, elem)))
                 return false;
         }
     }
     pop(length);
     return true;
 }
 
+bool ScriptValueDeserializer::completeMap(uint32_t length, v8::Local<v8::Value>* value)
+{
+    ASSERT(m_version > 0);
+    v8::Local<v8::Value> composite;
+    if (!closeComposite(&composite))
+        return false;
+    v8::Local<v8::Map> map = composite.As<v8::Map>();
+    if (map.IsEmpty())
+        return false;
+    v8::Local<v8::Context> context = m_reader.scriptState()->context();
+    ASSERT(length % 2 == 0);
+    for (unsigned i = stackDepth() - length; i + 1 < stackDepth(); i += 2) {
+        v8::Local<v8::Value> key = element(i);
+        v8::Local<v8::Value> val = element(i + 1);
+        if (map->Set(context, key, val).IsEmpty())
+            return false;
+    }
+    pop(length);
+    *value = map;
+    return true;
+}
+
+bool ScriptValueDeserializer::completeSet(uint32_t length, v8::Local<v8::Value>* value)
+{
+    ASSERT(m_version > 0);
+    v8::Local<v8::Value> composite;
+    if (!closeComposite(&composite))
+        return false;
+    v8::Local<v8::Set> set = composite.As<v8::Set>();
+    if (set.IsEmpty())
+        return false;
+    v8::Local<v8::Context> context = m_reader.scriptState()->context();
+    for (unsigned i = stackDepth() - length; i < stackDepth(); i++) {
+        v8::Local<v8::Value> key = element(i);
+        if (set->Add(context, key).IsEmpty())
+            return false;
+    }
+    pop(length);
+    *value = set;
+    return true;
+}
+
 void ScriptValueDeserializer::pushObjectReference(const v8::Local<v8::Value>& object)
 {
     m_objectPool.append(object);
 }
 
 bool ScriptValueDeserializer::tryGetTransferredMessagePort(uint32_t index, v8::Local<v8::Value>* object)
 {
     if (!m_transferredMessagePorts)
         return false;
     if (index >= m_transferredMessagePorts->size())
@@ skipping 94 matching lines @@
         return false;
     uint32_t objectReference = m_openCompositeReferenceStack[m_openCompositeReferenceStack.size() - 1];
     m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() - 1);
     if (objectReference >= m_objectPool.size())
         return false;
     *object = m_objectPool[objectReference];
     return true;
 }
 
 } // namespace blink