v8::Handle<v8::Value> V8TestSerializedScriptValueInterface::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestSerializedScriptValueInterface.Constructor");
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.");
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, hello, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
MessagePortArray messagePortArrayTransferList;
ArrayBufferArray arrayBufferArrayTransferList;
if (args.Length() > 2) {
if (!extractTransferables(args[2], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))
return throwTypeError("Could not extract transferables");
}
bool dataDidThrow = false;
RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[1], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow, args.GetIsolate());
if (dataDidThrow)
return v8Undefined();
RefPtr<TestSerializedScriptValueInterface> impl = TestSerializedScriptValueInterface::create(hello, data, messagePortArrayTransferList);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::setDOMWrapper(wrapper, &info, impl.get());
V8DOMWrapper::setJSWrapperForDOMObject(impl.release(), wrapper, args.GetIsolate());
return wrapper;
}
static v8::Handle<v8::Value> multiTransferListCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestSerializedScriptValueInterface.multiTransferList");
TestSerializedScriptValueInterface* imp = V8TestSerializedScriptValueInterface::toNative(args.Holder());
if (args.Length() <= 0) {
imp->multiTransferList();
return v8Undefined();
}
MessagePortArray messagePortArrayTx;
ArrayBufferArray arrayBufferArrayTx;
if (args.Length() > 1) {
if (!extractTransferables(args[1], messagePortArrayTx, arrayBufferArrayTx, args.GetIsolate()))
return throwTypeError("Could not extract transferables");
}
bool firstDidThrow = false;
RefPtr<SerializedScriptValue> first = SerializedScriptValue::create(args[0], &messagePortArrayTx, &arrayBufferArrayTx, firstDidThrow, args.GetIsolate());
if (firstDidThrow)
return v8Undefined();
if (args.Length() <= 1) {
imp->multiTransferList(first);
return v8Undefined();
}
if (args.Length() <= 2) {
imp->multiTransferList(first, messagePortArrayTx);
return v8Undefined();
}
MessagePortArray messagePortArrayTxx;
ArrayBufferArray arrayBufferArrayTxx;
if (args.Length() > 3) {
if (!extractTransferables(args[3], messagePortArrayTxx, arrayBufferArrayTxx, args.GetIsolate()))
return throwTypeError("Could not extract transferables");
}
bool secondDidThrow = false;
RefPtr<SerializedScriptValue> second = SerializedScriptValue::create(args[2], &messagePortArrayTxx, &arrayBufferArrayTxx, secondDidThrow, args.GetIsolate());
if (secondDidThrow)
return v8Undefined();
if (args.Length() <= 3) {
imp->multiTransferList(first, messagePortArrayTx, second);
return v8Undefined();
}
imp->multiTransferList(first, messagePortArrayTx, second, messagePortArrayTxx);
return v8Undefined();
}
bool getMessagePortArray(v8::Local<v8::Value> value, MessagePortArray& ports)
{
ArrayBufferArray arrayBuffers;
bool result = extractTransferables(value, ports, arrayBuffers);
if (!result)
return false;
if (arrayBuffers.size() > 0) {
throwError("MessagePortArray argument must contain only MessagePorts");
return false;
}
return true;
}
void V8Window::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
// None of these need to be RefPtr because info and context are guaranteed
// to hold on to them.
DOMWindow* window = V8Window::toNative(info.Holder());
DOMWindow* source = activeDOMWindow();
// If called directly by WebCore we don't have a calling context.
if (!source) {
throwUninformativeAndGenericTypeError(info.GetIsolate());
return;
}
// This function has variable arguments and can be:
// Per current spec:
// postMessage(message, targetOrigin)
// postMessage(message, targetOrigin, {sequence of transferrables})
// Legacy non-standard implementations in webkit allowed:
// postMessage(message, {sequence of transferrables}, targetOrigin);
MessagePortArray portArray;
ArrayBufferArray arrayBufferArray;
int targetOriginArgIndex = 1;
if (info.Length() > 2) {
int transferablesArgIndex = 2;
if (isLegacyTargetOriginDesignation(info[2])) {
targetOriginArgIndex = 2;
transferablesArgIndex = 1;
}
bool notASequence = false;
if (!extractTransferables(info[transferablesArgIndex], portArray, arrayBufferArray, notASequence, info.GetIsolate())) {
if (notASequence)
throwTypeError(ExceptionMessages::failedToExecute("postMessage", "Window", ExceptionMessages::notAnArrayTypeArgumentOrValue(transferablesArgIndex + 1)), info.GetIsolate());
return;
}
}
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, targetOrigin, info[targetOriginArgIndex]);
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(info[0], &portArray, &arrayBufferArray, didThrow, info.GetIsolate());
if (didThrow)
return;
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "Window", info.Holder(), info.GetIsolate());
window->postMessage(message.release(), &portArray, targetOrigin, source, exceptionState);
exceptionState.throwIfNeeded();
}
v8::Handle<v8::Value> V8MessagePort::postMessageCallback(const v8::Arguments& args)
{
INC_STATS("DOM.MessagePort.postMessage");
MessagePort* messagePort = V8MessagePort::toNative(args.Holder());
MessagePortArray portArray;
ArrayBufferArray arrayBufferArray;
if (args.Length() > 1) {
if (!extractTransferables(args[1], portArray, arrayBufferArray))
return v8::Undefined();
}
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(args[0],
&portArray,
didThrow);
if (didThrow)
return v8::Undefined();
ExceptionCode ec = 0;
messagePort->postMessage(message.release(), &portArray, ec);
return throwError(ec);
}
v8::Handle<v8::Value> V8Intent::constructorCallbackCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
if (args.Length() == 1) {
// Use the dictionary constructor. This block will return if the
// argument isn't a valid Dictionary.
V8TRYCATCH(Dictionary, options, Dictionary(args[0], args.GetIsolate()));
ExceptionCode ec = 0;
RefPtr<Intent> impl = Intent::create(ScriptState::current(), options, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &info, wrapper, args.GetIsolate());
return wrapper;
}
ExceptionCode ec = 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, action, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
MessagePortArray messagePortArrayTransferList;
ArrayBufferArray arrayBufferArrayTransferList;
if (args.Length() > 3) {
if (!extractTransferables(args[3], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool dataDidThrow = false;
RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[2], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow);
if (dataDidThrow)
return setDOMException(DATA_CLONE_ERR, args.GetIsolate());
RefPtr<Intent> impl = Intent::create(action, type, data, messagePortArrayTransferList, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &info, wrapper, args.GetIsolate());
return wrapper;
}
void V8Worker::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
Worker* worker = V8Worker::toNative(args.Holder());
MessagePortArray ports;
ArrayBufferArray arrayBuffers;
if (args.Length() > 1) {
if (!extractTransferables(args[1], ports, arrayBuffers, args.GetIsolate()))
return;
}
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(args[0],
&ports,
&arrayBuffers,
didThrow,
args.GetIsolate());
if (didThrow)
return;
ExceptionCode ec = 0;
worker->postMessage(message.release(), &ports, ec);
setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, hello, args[0]);
MessagePortArray messagePortArrayTransferList;
ArrayBufferArray arrayBufferArrayTransferList;
if (args.Length() > 2) {
if (!extractTransferables(args[2], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool dataDidThrow = false;
RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[1], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow, args.GetIsolate());
if (dataDidThrow)
return v8Undefined();
RefPtr<TestSerializedScriptValueInterface> impl = TestSerializedScriptValueInterface::create(hello, data, messagePortArrayTransferList);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8TestSerializedScriptValueInterface::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
static v8::Handle<v8::Value> acceptTransferListMethod(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestSerializedScriptValueInterface* imp = V8TestSerializedScriptValueInterface::toNative(args.Holder());
MessagePortArray messagePortArrayTransferList;
ArrayBufferArray arrayBufferArrayTransferList;
if (args.Length() > 1) {
if (!extractTransferables(args[1], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool dataDidThrow = false;
RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[0], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow, args.GetIsolate());
if (dataDidThrow)
return v8Undefined();
if (args.Length() <= 1) {
imp->acceptTransferList(data);
return v8Undefined();
}
imp->acceptTransferList(data, messagePortArrayTransferList);
return v8Undefined();
}
static JSValue handlePostMessage(DOMWindow& impl, ExecState& state)
{
VM& vm = state.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (UNLIKELY(state.argumentCount() < 2))
return throwException(&state, scope, createNotEnoughArgumentsError(&state));
Vector<RefPtr<MessagePort>> messagePorts;
Vector<RefPtr<JSC::ArrayBuffer>> arrayBuffers;
// This function has variable arguments and can be:
// Per current spec:
// postMessage(message, targetOrigin)
// postMessage(message, targetOrigin, {sequence of transferrables})
// Legacy non-standard implementations in webkit allowed:
// postMessage(message, {sequence of transferrables}, targetOrigin);
int targetOriginArgIndex = 1;
if (state.argumentCount() > 2) {
int transferablesArgIndex = 2;
if (state.uncheckedArgument(2).isString()) {
targetOriginArgIndex = 2;
transferablesArgIndex = 1;
}
extractTransferables(state, state.argument(transferablesArgIndex), messagePorts, arrayBuffers);
}
RETURN_IF_EXCEPTION(scope, JSValue());
auto message = SerializedScriptValue::create(state, state.uncheckedArgument(0), messagePorts, WTFMove(arrayBuffers));
RETURN_IF_EXCEPTION(scope, JSValue());
String targetOrigin = convert<IDLNullable<IDLUSVString>>(state, state.uncheckedArgument(targetOriginArgIndex));
RETURN_IF_EXCEPTION(scope, JSValue());
propagateException(state, scope, impl.postMessage(message.releaseNonNull(), WTFMove(messagePorts), targetOrigin, callerDOMWindow(&state)));
return jsUndefined();
}
static v8::Handle<v8::Value> handlePostMessageCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Worker.postMessage");
Worker* worker = V8Worker::toNative(args.Holder());
MessagePortArray ports;
ArrayBufferArray arrayBuffers;
if (args.Length() > 1) {
if (!extractTransferables(args[1], ports, arrayBuffers, args.GetIsolate()))
return v8::Undefined();
}
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(args[0],
&ports,
&arrayBuffers,
didThrow,
args.GetIsolate());
if (didThrow)
return v8::Undefined();
ExceptionCode ec = 0;
worker->postMessage(message.release(), &ports, ec);
return setDOMException(ec, args.GetIsolate());
}