Support Blob on the V8-based structured clone path.

third_party/WebKit/Source/bindings/core/v8/serialization/V8ScriptValueSerializer.cpp

 // Copyright 2016 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/serialization/V8ScriptValueSerializer.h"
 
 #include "bindings/core/v8/ToV8.h"
+#include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8ImageBitmap.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
 #include "bindings/core/v8/V8OffscreenCanvas.h"
 #include "core/dom/DOMArrayBufferBase.h"
 #include "core/html/ImageData.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "public/platform/WebBlobInfo.h"
 #include "wtf/AutoReset.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 
 namespace blink {
 
 V8ScriptValueSerializer::V8ScriptValueSerializer(RefPtr<ScriptState> scriptState)
     : m_scriptState(std::move(scriptState))
     , m_serializedScriptValue(SerializedScriptValue::create())
     , m_serializer(m_scriptState->isolate(), this)
 {
@@ skipping 91 matching lines @@
     // StringUTF8Adaptor trick doesn't yet work with StringView.
     StringUTF8Adaptor utf8(string);
     DCHECK_LT(utf8.length(), std::numeric_limits<uint32_t>::max());
     writeUint32(utf8.length());
     writeRawBytes(utf8.data(), utf8.length());
 }
 
 bool V8ScriptValueSerializer::writeDOMObject(ScriptWrappable* wrappable, ExceptionState& exceptionState)
 {
     const WrapperTypeInfo* wrapperTypeInfo = wrappable->wrapperTypeInfo();
+    if (wrapperTypeInfo == &V8Blob::wrapperTypeInfo) {
+        Blob* blob = wrappable->toImpl<Blob>();
+        if (blob->isClosed()) {
+            exceptionState.throwDOMException(DataCloneError,
+                "A Blob object has been closed, and could therefore not be cloned.");
+            return false;
+        }
+        m_serializedScriptValue->blobDataHandles().set(blob->uuid(), blob->blobDataHandle());
+        if (m_blobInfoArray) {
+            size_t index = m_blobInfoArray->size();
+            DCHECK_LE(index, std::numeric_limits<uint32_t>::max());
+            m_blobInfoArray->emplaceAppend(blob->uuid(), blob->type(), blob->size());
+            writeTag(BlobIndexTag);
+            writeUint32(static_cast<uint32_t>(index));
+        } else {
+            writeTag(BlobTag);
+            writeUTF8String(blob->uuid());
+            writeUTF8String(blob->type());
+            writeUint64(blob->size());
+        }
+        return true;
+    }
     if (wrapperTypeInfo == &V8ImageBitmap::wrapperTypeInfo) {
         ImageBitmap* imageBitmap = wrappable->toImpl<ImageBitmap>();
         if (imageBitmap->isNeutered()) {
             exceptionState.throwDOMException(DataCloneError,
                 "An ImageBitmap is detached and could not be cloned.");
             return false;
         }
 
         // If this ImageBitmap was transferred, it can be serialized by index.
         size_t index = kNotFound;
@@ skipping 103 matching lines @@
         return v8::Just(true);
     }
     if (!exceptionState.hadException()) {
         String interface = wrappable->wrapperTypeInfo()->interfaceName;
         exceptionState.throwDOMException(DataCloneError, interface + " object could not be cloned.");
     }
     return v8::Nothing<bool>();
 }
 
 } // namespace blink