Support structured clone atop v8::ValueSerializer behind a RuntimeEnabledFeature.

third_party/WebKit/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 "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/Transferables.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
@@ skipping 717 matching lines @@
         CustomCountHistogram domWrapperCount{"Blink.ScriptValueSerializer.DOMWrapperCount", 0, 100000, 50};
     };
     DEFINE_THREAD_SAFE_STATIC_LOCAL(ObjectCountHistograms, histograms, new ObjectCountHistograms);
     histograms.primitiveCount.count(primitiveCount);
     histograms.jsObjectCount.count(jsObjectCount);
     histograms.domWrapperCount.count(domWrapperCount);
 }
 
 PassRefPtr<SerializedScriptValue> ScriptValueSerializer::serialize(v8::Local<v8::Value> value, Transferables* transferables, ExceptionState& exceptionState)
 {
+    if (RuntimeEnabledFeatures::v8BasedStructuredCloneEnabled()) {
+        v8::HandleScope scope(isolate());
+        v8::ValueSerializer serializer(isolate());
+        serializer.WriteHeader();
+        if (!serializer.WriteValue(context(), value).FromMaybe(false)) {

[haraken, 2016/08/29 14:12:14]

Use To instead.

[jbroman, 2016/08/29 14:29:37]

Can do, though doing so is more verbose in this case:

bool success;
if (!serializer.WriteValue(context(), value).To(&success) && success) {
}

Although Just(false) isn't used; like other V8 APIs only Just(true) and
Nothing<bool>() can actually be returned.

May I ask why To is preferred for this case?

[haraken, 2016/08/29 16:25:01]

V8 APIs around Maybe/MaybeLocal are really confusing, and we've decided to unify
them into To/ToLocal.

https://groups.google.com/a/chromium.org/d/topic/platform-architecture-dev/vG...

[jbroman, 2016/08/29 17:07:41]

Done.

+            if (m_tryCatch.HasCaught()) {
+                exceptionState.rethrowV8Exception(m_tryCatch.Exception());
+            } else {

[haraken, 2016/08/29 14:12:14]

This shouldn't happen. To returns false if and only if there is an exception.

[jbroman, 2016/08/29 14:29:37]

Technically, Maybe::To returns false if and only if the value was constructed
with Nothing<T>.

At the moment, this does not necessarily indicate a pending exception, because
there is not yet agreement about how to handle DataCloneError in this interface.
Options include:
- not throwing an exception, and expecting the client to throw one in that event
(there are other V8 APIs that return a failure without a thrown exception, like
v8::Object::GetRealNamedPropertyInPrototypeChain).
- throwing a specially marked exception, which Blink catches and rethrows as a
DataCloneError DOMException
- having V8 call into Blink to throw the kind of exception it expects

+                exceptionState.throwDOMException(DataCloneError, "An object could not be cloned.");
+            }
+            return nullptr;
+        }
+        std::vector<uint8_t> buffer = serializer.ReleaseBuffer();
+        // TODO(jbroman): Remove this old conversion to WTF::String.
+        if (buffer.size() % 2)
+            buffer.push_back(0);
+        return SerializedScriptValue::create(String(reinterpret_cast<const UChar*>(&buffer[0]), buffer.size() / 2));
+    }
+
     m_primitiveCount = m_jsObjectCount = m_domWrapperCount = 0;
 
     DCHECK(!m_blobDataHandles);
 
     RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::create();
 
     m_blobDataHandles = &serializedValue->blobDataHandles();
     if (transferables)
         copyTransferables(*transferables);
 
@@ skipping 1372 matching lines @@
     if (it != m_blobDataHandles.end()) {
         // make assertions about type and size?
         return it->value;
     }
     return BlobDataHandle::create(uuid, type, size);
 }
 
 v8::Local<v8::Value> ScriptValueDeserializer::deserialize()
 {
     v8::Isolate* isolate = m_reader.getScriptState()->isolate();
+
+    if (RuntimeEnabledFeatures::v8BasedStructuredCloneEnabled()) {
+        v8::EscapableHandleScope scope(isolate);
+        v8::TryCatch tryCatch(isolate);
+        v8::ValueDeserializer deserializer(isolate, m_reader.buffer(), m_reader.length());
+        deserializer.SetSupportsLegacyWireFormat(true);
+        if (!deserializer.ReadHeader().FromMaybe(false))

[haraken, 2016/08/29 14:12:14]

Use To instead.

+            return v8::Null(isolate);
+        v8::Local<v8::Context> context = m_reader.getScriptState()->context();
+        v8::Local<v8::Value> value;
+        if (!deserializer.ReadValue(context).ToLocal(&value))
+            return v8::Null(isolate);
+        return scope.Escape(value);
+    }
+
     if (!m_reader.readVersion(m_version) || m_version > SerializedScriptValue::wireFormatVersion)
         return v8::Null(isolate);
     m_reader.setVersion(m_version);
     v8::EscapableHandleScope scope(isolate);
     while (!m_reader.isEof()) {
         if (!doDeserialize())
             return v8::Null(isolate);
     }
     if (stackDepth() != 1 || m_openCompositeReferenceStack.size())
         return v8::Null(isolate);
@@ skipping 307 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