Encapsulate optional SerializedScriptValue serialize/deserialize parameters.

third_party/WebKit/Source/bindings/core/v8/serialization/V8ScriptValueSerializerTest.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/ExceptionState.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 54 matching lines @@
   // Extract message ports and disentangle them.
   MessagePortChannelArray channels;
   if (transferables) {
     channels = MessagePort::disentanglePorts(scope.getExecutionContext(),
                                              transferables->messagePorts,
                                              exceptionState);
     if (exceptionState.hadException())
       return v8::Local<v8::Value>();
   }
 
-  V8ScriptValueSerializer serializer(scriptState);
-  serializer.setBlobInfoArray(blobInfo);
+  V8ScriptValueSerializer::Options serializeOptions;
+  serializeOptions.transferables = transferables;
+  serializeOptions.blobInfo = blobInfo;
+  V8ScriptValueSerializer serializer(scriptState, serializeOptions);
   RefPtr<SerializedScriptValue> serializedScriptValue =
-      serializer.serialize(value, transferables, exceptionState);
+      serializer.serialize(value, exceptionState);
   DCHECK_EQ(!serializedScriptValue, exceptionState.hadException());
   if (!serializedScriptValue)
     return v8::Local<v8::Value>();
 
   // If there are message ports, make new ones and entangle them.
   MessagePortArray* transferredMessagePorts = MessagePort::entanglePorts(
       *scope.getExecutionContext(), std::move(channels));
 
-  V8ScriptValueDeserializer deserializer(scriptState, serializedScriptValue);
-  deserializer.setTransferredMessagePorts(transferredMessagePorts);
-  deserializer.setBlobInfoArray(blobInfo);
+  V8ScriptValueDeserializer::Options deserializeOptions;
+  deserializeOptions.messagePorts = transferredMessagePorts;
+  deserializeOptions.blobInfo = blobInfo;
+  V8ScriptValueDeserializer deserializer(scriptState, serializedScriptValue,
+                                         deserializeOptions);
   return deserializer.deserialize();
 }
 
 v8::Local<v8::Value> eval(const String& source, V8TestingScope& scope) {
   return scope.frame().script().executeScriptInMainWorldAndReturnValue(source);
 }
 
 String toJSON(v8::Local<v8::Object> object, const V8TestingScope& scope) {
   return v8StringToWebCoreString<String>(
       v8::JSON::Stringify(scope.context(), object).ToLocalChecked(),
@@ skipping 34 matching lines @@
   // are encountered in V8 (for example, cloning a symbol). It should be an
   // instance of DOMException, and it should have a proper descriptive
   // message.
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
   ExceptionState exceptionState(scope.isolate(),
                                 ExceptionState::ExecutionContext, "Window",
                                 "postMessage");
   v8::Local<v8::Value> symbol = eval("Symbol()", scope);
   DCHECK(symbol->IsSymbol());
-  ASSERT_FALSE(V8ScriptValueSerializer(scriptState)
-                   .serialize(symbol, nullptr, exceptionState));
+  ASSERT_FALSE(
+      V8ScriptValueSerializer(scriptState).serialize(symbol, exceptionState));
   ASSERT_TRUE(hadDOMException("DataCloneError", scriptState, exceptionState));
   DOMException* domException =
       V8DOMException::toImpl(exceptionState.getException().As<v8::Object>());
   EXPECT_TRUE(domException->toString().contains("postMessage"));
 }
 
 TEST(V8ScriptValueSerializerTest, RethrowsScriptError) {
   // Ensure that other exceptions, like those thrown by script, are properly
   // rethrown.
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
   ExceptionState exceptionState(scope.isolate(),
                                 ExceptionState::ExecutionContext, "Window",
                                 "postMessage");
   v8::Local<v8::Value> exception = eval("myException=new Error()", scope);
   v8::Local<v8::Value> object =
       eval("({ get a() { throw myException; }})", scope);
   DCHECK(object->IsObject());
-  ASSERT_FALSE(V8ScriptValueSerializer(scriptState)
-                   .serialize(object, nullptr, exceptionState));
+  ASSERT_FALSE(
+      V8ScriptValueSerializer(scriptState).serialize(object, exceptionState));
   ASSERT_TRUE(exceptionState.hadException());
   EXPECT_EQ(exception, exceptionState.getException());
 }
 
 TEST(V8ScriptValueSerializerTest, DeserializationErrorReturnsNull) {
   // If there's a problem during deserialization, it results in null, but no
   // exception.
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
   RefPtr<SerializedScriptValue> invalid =
@@ skipping 156 matching lines @@
   ScriptState* scriptState = scope.getScriptState();
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x4d, 0x01});
   MessagePort* port1 = makeMessagePort(scope.getExecutionContext());
   MessagePort* port2 = makeMessagePort(scope.getExecutionContext());
   {
     V8ScriptValueDeserializer deserializer(scriptState, input);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
   {
-    V8ScriptValueDeserializer deserializer(scriptState, input);
-    deserializer.setTransferredMessagePorts(new MessagePortArray);
+    V8ScriptValueDeserializer::Options options;
+    options.messagePorts = new MessagePortArray;
+    V8ScriptValueDeserializer deserializer(scriptState, input, options);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
   {
-    MessagePortArray* ports = new MessagePortArray;
-    ports->push_back(port1);
-    V8ScriptValueDeserializer deserializer(scriptState, input);
-    deserializer.setTransferredMessagePorts(ports);
+    V8ScriptValueDeserializer::Options options;
+    options.messagePorts = new MessagePortArray;
+    options.messagePorts->push_back(port1);
+    V8ScriptValueDeserializer deserializer(scriptState, input, options);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
   {
-    MessagePortArray* ports = new MessagePortArray;
-    ports->push_back(port1);
-    ports->push_back(port2);
-    V8ScriptValueDeserializer deserializer(scriptState, input);
-    deserializer.setTransferredMessagePorts(ports);
+    V8ScriptValueDeserializer::Options options;
+    options.messagePorts = new MessagePortArray;
+    options.messagePorts->push_back(port1);
+    options.messagePorts->push_back(port2);
+    V8ScriptValueDeserializer deserializer(scriptState, input, options);
     v8::Local<v8::Value> result = deserializer.deserialize();
     ASSERT_TRUE(V8MessagePort::hasInstance(result, scope.isolate()));
     EXPECT_EQ(port2, V8MessagePort::toImpl(result.As<v8::Object>()));
   }
 }
 
 // Decode tests for backward compatibility are not required for message ports
 // because they cannot be persisted to disk.
 
 // A more exhaustive set of ImageBitmap cases are covered by LayoutTests.
@@ skipping 209 matching lines @@
   EXPECT_EQ(sizeof(kHelloWorld), static_cast<size_t>(info.size()));
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeBlobIndex) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x69, 0x00});
   WebBlobInfoArray blobInfoArray;
   blobInfoArray.emplace_back("d875dfc2-4505-461b-98fe-0cf6cc5eaf44",
                              "text/plain", 12);
-  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-  deserializer.setBlobInfoArray(&blobInfoArray);
+  V8ScriptValueDeserializer::Options options;
+  options.blobInfo = &blobInfoArray;
+  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                         options);
   v8::Local<v8::Value> result = deserializer.deserialize();
   ASSERT_TRUE(V8Blob::hasInstance(result, scope.isolate()));
   Blob* newBlob = V8Blob::toImpl(result.As<v8::Object>());
   EXPECT_EQ("d875dfc2-4505-461b-98fe-0cf6cc5eaf44", newBlob->uuid());
   EXPECT_EQ("text/plain", newBlob->type());
   EXPECT_EQ(12u, newBlob->size());
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeBlobIndexOutOfRange) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x69, 0x01});
   {
     V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
   {
     WebBlobInfoArray blobInfoArray;
     blobInfoArray.emplace_back("d875dfc2-4505-461b-98fe-0cf6cc5eaf44",
                                "text/plain", 12);
-    V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-    deserializer.setBlobInfoArray(&blobInfoArray);
+    V8ScriptValueDeserializer::Options options;
+    options.blobInfo = &blobInfoArray;
+    V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                           options);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
 }
 
 TEST(V8ScriptValueSerializerTest, RoundTripFileNative) {
   V8TestingScope scope;
   File* file = File::create("/native/path");
   v8::Local<v8::Value> wrapper = ToV8(file, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8File::hasInstance(result, scope.isolate()));
@@ skipping 211 matching lines @@
   EXPECT_EQ(file->uuid(), String(info.uuid()));
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeFileIndex) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x65, 0x00});
   WebBlobInfoArray blobInfoArray;
   blobInfoArray.emplace_back("d875dfc2-4505-461b-98fe-0cf6cc5eaf44",
                              "/native/path", "path", "text/plain");
-  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-  deserializer.setBlobInfoArray(&blobInfoArray);
+  V8ScriptValueDeserializer::Options options;
+  options.blobInfo = &blobInfoArray;
+  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                         options);
   v8::Local<v8::Value> result = deserializer.deserialize();
   ASSERT_TRUE(V8File::hasInstance(result, scope.isolate()));
   File* newFile = V8File::toImpl(result.As<v8::Object>());
   EXPECT_EQ("d875dfc2-4505-461b-98fe-0cf6cc5eaf44", newFile->uuid());
   EXPECT_EQ("text/plain", newFile->type());
   EXPECT_EQ("/native/path", newFile->path());
   EXPECT_EQ("path", newFile->name());
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeFileIndexOutOfRange) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x65, 0x01});
   {
     V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
   {
     WebBlobInfoArray blobInfoArray;
     blobInfoArray.emplace_back("d875dfc2-4505-461b-98fe-0cf6cc5eaf44",
                                "/native/path", "path", "text/plain");
-    V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-    deserializer.setBlobInfoArray(&blobInfoArray);
+    V8ScriptValueDeserializer::Options options;
+    options.blobInfo = &blobInfoArray;
+    V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                           options);
     ASSERT_TRUE(deserializer.deserialize()->IsNull());
   }
 }
 
 // Most of the logic for FileList is shared with File, so the tests here are
 // fairly basic.
 
 TEST(V8ScriptValueSerializerTest, RoundTripFileList) {
   V8TestingScope scope;
   FileList* fileList = FileList::create();
@@ skipping 78 matching lines @@
   EXPECT_EQ("/native/path", blobInfoArray[0].filePath());
   EXPECT_TRUE(blobInfoArray[1].isFile());
   EXPECT_EQ("/native/path2", blobInfoArray[1].filePath());
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeEmptyFileListIndex) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x4c, 0x00});
   WebBlobInfoArray blobInfoArray;
-  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-  deserializer.setBlobInfoArray(&blobInfoArray);
+  V8ScriptValueDeserializer::Options options;
+  options.blobInfo = &blobInfoArray;
+  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                         options);
   v8::Local<v8::Value> result = deserializer.deserialize();
   ASSERT_TRUE(V8FileList::hasInstance(result, scope.isolate()));
   FileList* newFileList = V8FileList::toImpl(result.As<v8::Object>());
   EXPECT_EQ(0u, newFileList->length());
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeFileListIndexWithInvalidLength) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x4c, 0x02});
   WebBlobInfoArray blobInfoArray;
-  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-  deserializer.setBlobInfoArray(&blobInfoArray);
+  V8ScriptValueDeserializer::Options options;
+  options.blobInfo = &blobInfoArray;
+  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                         options);
   v8::Local<v8::Value> result = deserializer.deserialize();
   EXPECT_TRUE(result->IsNull());
 }
 
 TEST(V8ScriptValueSerializerTest, DecodeFileListIndex) {
   V8TestingScope scope;
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x09, 0x3f, 0x00, 0x4c, 0x01, 0x00, 0x00});
   WebBlobInfoArray blobInfoArray;
   blobInfoArray.emplace_back("d875dfc2-4505-461b-98fe-0cf6cc5eaf44",
                              "/native/path", "name", "text/plain");
-  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input);
-  deserializer.setBlobInfoArray(&blobInfoArray);
+  V8ScriptValueDeserializer::Options options;
+  options.blobInfo = &blobInfoArray;
+  V8ScriptValueDeserializer deserializer(scope.getScriptState(), input,
+                                         options);
   v8::Local<v8::Value> result = deserializer.deserialize();
   FileList* newFileList = V8FileList::toImpl(result.As<v8::Object>());
   EXPECT_EQ(1u, newFileList->length());
   File* newFile = newFileList->item(0);
   EXPECT_EQ("/native/path", newFile->path());
   EXPECT_EQ("name", newFile->name());
   EXPECT_EQ("d875dfc2-4505-461b-98fe-0cf6cc5eaf44", newFile->uuid());
   EXPECT_EQ("text/plain", newFile->type());
 }
 
@@ skipping 67 matching lines @@
   RefPtr<SerializedScriptValue> input =
       serializedValue({0xff, 0x80, 0x09, 0xff, 0x09, 0x54});
   EXPECT_TRUE(
       V8ScriptValueDeserializer(scope.getScriptState(), std::move(input))
           .deserialize()
           ->IsTrue());
 }
 
 }  // namespace
 }  // namespace blink