Encapsulate optional SerializedScriptValue serialize/deserialize parameters.

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/V8CompositorProxy.h"
 #include "bindings/core/v8/V8File.h"
@@ skipping 25 matching lines @@
 // for both parts was always equal.
 //
 // See also V8ScriptValueDeserializer.cpp.
 //
 // This version number must be incremented whenever any incompatible changes are
 // made to how Blink writes data. Purely V8-side changes do not require an
 // adjustment to this value.
 static const uint32_t kLatestVersion = 16;
 
 V8ScriptValueSerializer::V8ScriptValueSerializer(
-    RefPtr<ScriptState> scriptState)
+    RefPtr<ScriptState> scriptState,
+    const Options& options)
     : m_scriptState(std::move(scriptState)),
       m_serializedScriptValue(SerializedScriptValue::create()),
-      m_serializer(m_scriptState->isolate(), this) {
-}
+      m_serializer(m_scriptState->isolate(), this),
+      m_transferables(options.transferables),
+      m_blobInfoArray(options.blobInfo) {}
 
 RefPtr<SerializedScriptValue> V8ScriptValueSerializer::serialize(
     v8::Local<v8::Value> value,
-    Transferables* transferables,
     ExceptionState& exceptionState) {
 #if DCHECK_IS_ON()
   DCHECK(!m_serializeInvoked);
   m_serializeInvoked = true;
 #endif
   DCHECK(m_serializedScriptValue);
   AutoReset<const ExceptionState*> reset(&m_exceptionState, &exceptionState);
 
   // Prepare to transfer the provided transferables.
-  prepareTransfer(transferables, exceptionState);
+  prepareTransfer(exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
   // Write out the file header.
   writeTag(VersionTag);
   writeUint32(kLatestVersion);
   m_serializer.WriteHeader();
 
   // Serialize the value and handle errors.
   v8::TryCatch tryCatch(m_scriptState->isolate());
@@ skipping 11 matching lines @@
   if (exceptionState.hadException())
     return nullptr;
 
   // Finalize the results.
   std::pair<uint8_t*, size_t> buffer = m_serializer.Release();
   m_serializedScriptValue->setData(
       SerializedScriptValue::DataBufferPtr(buffer.first), buffer.second);
   return std::move(m_serializedScriptValue);
 }
 
-void V8ScriptValueSerializer::prepareTransfer(Transferables* transferables,
-                                              ExceptionState& exceptionState) {
-  if (!transferables)
+void V8ScriptValueSerializer::prepareTransfer(ExceptionState& exceptionState) {
+  if (!m_transferables)
     return;
-  m_transferables = transferables;
 
   // Transfer array buffers.
-  for (uint32_t i = 0; i < transferables->arrayBuffers.size(); i++) {
-    DOMArrayBufferBase* arrayBuffer = transferables->arrayBuffers[i].get();
+  for (uint32_t i = 0; i < m_transferables->arrayBuffers.size(); i++) {
+    DOMArrayBufferBase* arrayBuffer = m_transferables->arrayBuffers[i].get();
     if (!arrayBuffer->isShared()) {
       v8::Local<v8::Value> wrapper = ToV8(arrayBuffer, m_scriptState.get());
       m_serializer.TransferArrayBuffer(
           i, v8::Local<v8::ArrayBuffer>::Cast(wrapper));
     } else {
       exceptionState.throwDOMException(
           DataCloneError, "SharedArrayBuffer can not be in transfer list.");
       return;
     }
   }
@@ skipping 312 matching lines @@
   *actualSize = WTF::Partitions::bufferActualSize(size);
   return WTF::Partitions::bufferRealloc(oldBuffer, *actualSize,
                                         "SerializedScriptValue buffer");
 }
 
 void V8ScriptValueSerializer::FreeBufferMemory(void* buffer) {
   return WTF::Partitions::bufferFree(buffer);
 }
 
 }  // namespace blink