void V8Window::openMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
LocalDOMWindow* impl = V8Window::toNative(info.Holder());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "open", "Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), impl->frame(), exceptionState)) {
exceptionState.throwIfNeeded();
return;
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, urlString, info[0]);
AtomicString frameName;
if (info[1]->IsUndefined() || info[1]->IsNull()) {
frameName = "_blank";
} else {
TOSTRING_VOID(V8StringResource<>, frameNameResource, info[1]);
frameName = frameNameResource;
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, windowFeaturesString, info[2]);
RefPtrWillBeRawPtr<LocalDOMWindow> openedWindow = impl->open(urlString, frameName, windowFeaturesString, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()));
if (!openedWindow)
return;
v8SetReturnValueFast(info, openedWindow.release(), impl);
}
void V8MessageEvent::initMessageEventMethodCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(ExceptionState::ExecutionContext,
"initMessageEvent", "MessageEvent",
info.Holder(), info.GetIsolate());
MessageEvent* event = V8MessageEvent::toImpl(info.Holder());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
bool canBubbleArg = false;
bool cancelableArg = false;
if (!v8Call(info[1]->BooleanValue(info.GetIsolate()->GetCurrentContext()),
canBubbleArg) ||
!v8Call(info[2]->BooleanValue(info.GetIsolate()->GetCurrentContext()),
cancelableArg))
return;
v8::Local<v8::Value> dataArg = info[3];
TOSTRING_VOID(V8StringResource<>, originArg, info[4]);
TOSTRING_VOID(V8StringResource<>, lastEventIdArg, info[5]);
DOMWindow* sourceArg = toDOMWindow(info.GetIsolate(), info[6]);
MessagePortArray* portArray = nullptr;
const int portArrayIndex = 7;
if (!isUndefinedOrNull(info[portArrayIndex])) {
portArray = new MessagePortArray;
*portArray = toMemberNativeArray<MessagePort>(
info[portArrayIndex], portArrayIndex + 1, info.GetIsolate(),
exceptionState);
if (exceptionState.hadException())
return;
}
event->initMessageEvent(
typeArg, canBubbleArg, cancelableArg,
ScriptValue(ScriptState::current(info.GetIsolate()), dataArg), originArg,
lastEventIdArg, sourceArg, portArray);
}
void V8MessageEvent::initMessageEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
TONATIVE_VOID(bool, canBubbleArg, info[1]->BooleanValue());
TONATIVE_VOID(bool, cancelableArg, info[2]->BooleanValue());
v8::Handle<v8::Value> dataArg = info[3];
TOSTRING_VOID(V8StringResource<>, originArg, info[4]);
TOSTRING_VOID(V8StringResource<>, lastEventIdArg, info[5]);
LocalDOMWindow* sourceArg = toDOMWindow(info[6], info.GetIsolate());
OwnPtr<MessagePortArray> portArray;
const int portArrayIndex = 7;
if (!isUndefinedOrNull(info[portArrayIndex])) {
portArray = adoptPtr(new MessagePortArray);
bool success = false;
*portArray = toRefPtrNativeArray<MessagePort, V8MessagePort>(info[portArrayIndex], portArrayIndex + 1, info.GetIsolate(), &success);
if (!success)
return;
}
event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, originArg, lastEventIdArg, sourceArg, portArray.release());
if (!dataArg.IsEmpty()) {
V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::data(info.GetIsolate()), dataArg);
if (DOMWrapperWorld::current(info.GetIsolate()).isIsolatedWorld())
event->setSerializedData(SerializedScriptValue::createAndSwallowExceptions(dataArg, info.GetIsolate()));
}
}
static void constructCustomElement(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
if (!info.IsConstructCall()) {
V8ThrowException::throwTypeError(isolate, "DOM object constructor cannot be called as a function.");
return;
}
if (info.Length() > 0) {
V8ThrowException::throwTypeError(isolate, "This constructor should be called without arguments.");
return;
}
ScriptState* scriptState = ScriptState::current(isolate);
v8::Local<v8::Object> data = v8::Local<v8::Object>::Cast(info.Data());
Document* document = V8Document::toImpl(V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementDocument(isolate)).As<v8::Object>());
TOSTRING_VOID(V8StringResource<>, namespaceURI, V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementNamespaceURI(isolate)));
TOSTRING_VOID(V8StringResource<>, tagName, V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementTagName(isolate)));
v8::Local<v8::Value> maybeType = V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementType(isolate));
TOSTRING_VOID(V8StringResource<>, type, maybeType);
ExceptionState exceptionState(ExceptionState::ConstructionContext, "CustomElement", info.Holder(), info.GetIsolate());
V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
Element* element = document->createElementNS(namespaceURI, tagName, maybeType->IsNull() ? nullAtom : type, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValueFast(info, element, document);
}
void V8Window::openMethodCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
DOMWindow* impl = V8Window::toImpl(info.Holder());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "open",
"Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()),
impl, exceptionState)) {
return;
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, urlString,
info[0]);
AtomicString frameName;
if (info[1]->IsUndefined() || info[1]->IsNull()) {
frameName = "_blank";
} else {
TOSTRING_VOID(V8StringResource<>, frameNameResource, info[1]);
frameName = frameNameResource;
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>,
windowFeaturesString, info[2]);
// |impl| has to be a LocalDOMWindow, since RemoteDOMWindows wouldn't have
// passed the BindingSecurity check above.
DOMWindow* openedWindow = toLocalDOMWindow(impl)->open(
urlString, frameName, windowFeaturesString,
currentDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()));
if (!openedWindow) {
v8SetReturnValueNull(info);
return;
}
v8SetReturnValueFast(info, openedWindow, impl);
}
static void constructCustomElement(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
if (!info.IsConstructCall()) {
throwTypeError("DOM object constructor cannot be called as a function.", isolate);
return;
}
if (info.Length() > 0) {
throwTypeError("This constructor should be called without arguments.", isolate);
return;
}
Document* document = V8Document::toNative(V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Callee(), V8HiddenValue::customElementDocument(isolate)).As<v8::Object>());
TOSTRING_VOID(V8StringResource<>, namespaceURI, V8HiddenValue::getHiddenValue(isolate, info.Callee(), V8HiddenValue::customElementNamespaceURI(isolate)));
TOSTRING_VOID(V8StringResource<>, tagName, V8HiddenValue::getHiddenValue(isolate, info.Callee(), V8HiddenValue::customElementTagName(isolate)));
v8::Handle<v8::Value> maybeType = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Callee(), V8HiddenValue::customElementType(isolate));
TOSTRING_VOID(V8StringResource<>, type, maybeType);
ExceptionState exceptionState(ExceptionState::ConstructionContext, "CustomElement", info.Holder(), info.GetIsolate());
CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
RefPtrWillBeRawPtr<Element> element = document->createElementNS(namespaceURI, tagName, maybeType->IsNull() ? nullAtom : type, exceptionState);
if (exceptionState.throwIfNeeded())
return;
#if ENABLE(OILPAN)
// FIXME: Oilpan: We don't have RawPtr<Eement> version of
// v8SetReturnValueFast until Node.idl has WillBeGarbageCollected.
v8SetReturnValueFast(info, element.get(), document);
#else
v8SetReturnValueFast(info, element.release(), document);
#endif
}
void V8XSLTProcessor::removeParameterMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (isUndefinedOrNull(info[1]))
return;
TOSTRING_VOID(V8StringResource<>, namespaceURI, info[0]);
TOSTRING_VOID(V8StringResource<>, localName, info[1]);
XSLTProcessor* impl = V8XSLTProcessor::toNative(info.Holder());
impl->removeParameter(namespaceURI, localName);
}
void V8History::replaceStateMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "replaceState", "History", info.Holder(), info.GetIsolate());
RefPtr<SerializedScriptValue> historyState = SerializedScriptValue::create(info[0], 0, 0, exceptionState, info.GetIsolate());
if (exceptionState.throwIfNeeded())
return;
TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, title, info[1]);
TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, url, argumentOrNull(info, 2));
History* history = V8History::toNative(info.Holder());
history->stateObjectAdded(historyState.release(), title, url, FrameLoadTypeRedirectWithLockedBackForwardList, exceptionState);
V8HiddenValue::deleteHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate()));
exceptionState.throwIfNeeded();
}
void V8XSLTProcessor::getParameterMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (isUndefinedOrNull(info[1]))
return;
TOSTRING_VOID(V8StringResource<>, namespaceURI, info[0]);
TOSTRING_VOID(V8StringResource<>, localName, info[1]);
XSLTProcessor* impl = V8XSLTProcessor::toNative(info.Holder());
String result = impl->getParameter(namespaceURI, localName);
if (result.isNull())
return;
v8SetReturnValueString(info, result, info.GetIsolate());
}
static void hrefAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
TestNode* impl = V8TestNode::toImpl(holder);
TOSTRING_VOID(V8StringResource<>, cppValue, v8Value);
impl->setHref(cppValue);
}
void V8HTMLAllCollection::legacyCallCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() < 1)
return;
HTMLAllCollection* impl = V8HTMLAllCollection::toImpl(info.Holder());
Node& ownerNode = impl->ownerNode();
UseCounter::countIfNotPrivateScript(info.GetIsolate(), ownerNode.document(), UseCounter::DocumentAllLegacyCall);
if (info.Length() == 1) {
v8SetReturnValue(info, getItem(impl, info[0], info));
return;
}
// If there is a second argument it is the index of the item we want.
TOSTRING_VOID(V8StringResource<>, name, info[0]);
v8::Local<v8::Uint32> index;
if (!info[1]->ToArrayIndex(info.GetIsolate()->GetCurrentContext()).ToLocal(&index))
return;
if (Node* node = impl->namedItemWithIndex(name, index->Value())) {
v8SetReturnValueFast(info, node, impl);
return;
}
}
static void hrefCallWithAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
TestNode* impl = V8TestNode::toImpl(holder);
TOSTRING_VOID(V8StringResource<>, cppValue, v8Value);
ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
impl->setHrefCallWith(executionContext, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), cppValue);
}
void V8Window::showModalDialogMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
LocalDOMWindow* impl = V8Window::toNative(info.Holder());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "showModalDialog", "Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), impl->frame(), exceptionState)) {
exceptionState.throwIfNeeded();
return;
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, urlString, info[0]);
DialogHandler handler(info[1], ScriptState::current(info.GetIsolate()));
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, dialogFeaturesString, info[2]);
impl->showModalDialog(urlString, dialogFeaturesString, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), setUpDialog, &handler);
v8SetReturnValue(info, handler.returnValue());
}
static void typeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
SVGTestInterface* impl = V8SVGTestInterface::toImpl(holder);
TOSTRING_VOID(V8StringResource<>, cppValue, v8Value);
CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
impl->setAttribute(SVGNames::typeAttr, cppValue);
}
void V8Window::postMessageMethodCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage",
"Window", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 2)) {
exceptionState.throwTypeError(
ExceptionMessages::notEnoughArguments(2, info.Length()));
return;
}
// None of these need to be RefPtr because info and context are guaranteed
// to hold on to them.
DOMWindow* window = V8Window::toImpl(info.Holder());
// TODO(yukishiino): The HTML spec specifies that we should use the
// Incumbent Realm instead of the Current Realm, but currently we don't have
// a way to retrieve the Incumbent Realm. See also:
// https://html.spec.whatwg.org/multipage/comms.html#dom-window-postmessage
LocalDOMWindow* source = currentDOMWindow(info.GetIsolate());
ASSERT(window);
UseCounter::countIfNotPrivateScript(info.GetIsolate(), window->frame(),
UseCounter::WindowPostMessage);
// If called directly by WebCore we don't have a calling context.
if (!source) {
exceptionState.throwTypeError("No active calling context exists.");
return;
}
// This function has variable arguments and can be:
// postMessage(message, targetOrigin)
// postMessage(message, targetOrigin, {sequence of transferrables})
// TODO(foolip): Type checking of the arguments should happen in order, so
// that e.g. postMessage({}, { toString: () => { throw Error(); } }, 0)
// throws the Error from toString, not the TypeError for argument 3.
Transferables transferables;
const int targetOriginArgIndex = 1;
if (info.Length() > 2) {
const int transferablesArgIndex = 2;
if (!SerializedScriptValue::extractTransferables(
info.GetIsolate(), info[transferablesArgIndex],
transferablesArgIndex, transferables, exceptionState)) {
return;
}
}
// TODO(foolip): targetOrigin should be a USVString in IDL and treated as
// such here, without TreatNullAndUndefinedAsNullString.
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>,
targetOrigin, info[targetOriginArgIndex]);
RefPtr<SerializedScriptValue> message = SerializedScriptValue::serialize(
info.GetIsolate(), info[0], &transferables, nullptr, exceptionState);
if (exceptionState.hadException())
return;
window->postMessage(message.release(), transferables.messagePorts,
targetOrigin, source, exceptionState);
}
void V8XMLHttpRequest::openMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
// Four cases:
// open(method, url)
// open(method, url, async)
// open(method, url, async, user)
// open(method, url, async, user, passwd)
ExceptionState exceptionState(ExceptionState::ExecutionContext, "open", "XMLHttpRequest", info.Holder(), info.GetIsolate());
if (info.Length() < 2) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
exceptionState.throwIfNeeded();
return;
}
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, method, info[0]);
TOSTRING_VOID(V8StringResource<>, urlstring, info[1]);
ExecutionContext* context = currentExecutionContext(info.GetIsolate());
KURL url = context->completeURL(urlstring);
if (info.Length() >= 3) {
bool async = info[2]->BooleanValue();
if (info.Length() >= 4 && !info[3]->IsUndefined()) {
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, user, info[3]);
if (info.Length() >= 5 && !info[4]->IsUndefined()) {
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, password, info[4]);
xmlHttpRequest->open(method, url, async, user, password, exceptionState);
} else {
xmlHttpRequest->open(method, url, async, user, exceptionState);
}
} else {
xmlHttpRequest->open(method, url, async, exceptionState);
}
} else {
xmlHttpRequest->open(method, url, exceptionState);
}
exceptionState.throwIfNeeded();
}
void V8HTMLCanvasElement::getContextMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
v8::Isolate* isolate = info.GetIsolate();
HTMLCanvasElement* impl = V8HTMLCanvasElement::toNative(holder);
TOSTRING_VOID(V8StringResource<>, contextIdResource, info[0]);
String contextId = contextIdResource;
RefPtr<CanvasContextAttributes> attributes = nullptr;
if (contextId == "webgl" || contextId == "experimental-webgl") {
RefPtr<WebGLContextAttributes> webGLAttributes = WebGLContextAttributes::create();
if (info.Length() > 1 && info[1]->IsObject()) {
v8::Handle<v8::Object> jsAttributes = info[1]->ToObject();
v8::Handle<v8::String> alpha = v8AtomicString(isolate, "alpha");
if (jsAttributes->Has(alpha) && !isUndefinedOrNull(jsAttributes->Get(alpha)))
webGLAttributes->setAlpha(jsAttributes->Get(alpha)->BooleanValue());
v8::Handle<v8::String> depth = v8AtomicString(isolate, "depth");
if (jsAttributes->Has(depth) && !isUndefinedOrNull(jsAttributes->Get(depth)))
webGLAttributes->setDepth(jsAttributes->Get(depth)->BooleanValue());
v8::Handle<v8::String> stencil = v8AtomicString(isolate, "stencil");
if (jsAttributes->Has(stencil) && !isUndefinedOrNull(jsAttributes->Get(stencil)))
webGLAttributes->setStencil(jsAttributes->Get(stencil)->BooleanValue());
v8::Handle<v8::String> antialias = v8AtomicString(isolate, "antialias");
if (jsAttributes->Has(antialias) && !isUndefinedOrNull(jsAttributes->Get(antialias)))
webGLAttributes->setAntialias(jsAttributes->Get(antialias)->BooleanValue());
v8::Handle<v8::String> premultipliedAlpha = v8AtomicString(isolate, "premultipliedAlpha");
if (jsAttributes->Has(premultipliedAlpha) && !isUndefinedOrNull(jsAttributes->Get(premultipliedAlpha)))
webGLAttributes->setPremultipliedAlpha(jsAttributes->Get(premultipliedAlpha)->BooleanValue());
v8::Handle<v8::String> preserveDrawingBuffer = v8AtomicString(isolate, "preserveDrawingBuffer");
if (jsAttributes->Has(preserveDrawingBuffer) && !isUndefinedOrNull(jsAttributes->Get(preserveDrawingBuffer)))
webGLAttributes->setPreserveDrawingBuffer(jsAttributes->Get(preserveDrawingBuffer)->BooleanValue());
v8::Handle<v8::String> failIfMajorPerformanceCaveat = v8AtomicString(isolate, "failIfMajorPerformanceCaveat");
if (jsAttributes->Has(failIfMajorPerformanceCaveat) && !isUndefinedOrNull(jsAttributes->Get(failIfMajorPerformanceCaveat)))
webGLAttributes->setFailIfMajorPerformanceCaveat(jsAttributes->Get(failIfMajorPerformanceCaveat)->BooleanValue());
}
attributes = webGLAttributes;
} else {
RefPtr<Canvas2DContextAttributes> canvas2DAttributes = Canvas2DContextAttributes::create();
attributes = canvas2DAttributes;
}
CanvasRenderingContext* result = impl->getContext(contextId, attributes.get());
if (!result) {
v8SetReturnValueNull(info);
return;
}
if (result->is2d()) {
v8::Handle<v8::Value> v8Result = toV8(toCanvasRenderingContext2D(result), info.Holder(), info.GetIsolate());
v8SetReturnValue(info, v8Result);
return;
}
if (result->is3d()) {
v8::Handle<v8::Value> v8Result = toV8(toWebGLRenderingContext(result), info.Holder(), info.GetIsolate());
v8SetReturnValue(info, v8Result);
return;
}
ASSERT_NOT_REACHED();
v8SetReturnValueNull(info);
}
static void hrefThrowsAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
ExceptionState exceptionState(ExceptionState::SetterContext, "hrefThrows", "TestNode", holder, info.GetIsolate());
TestNode* impl = V8TestNode::toImpl(holder);
TOSTRING_VOID(V8StringResource<>, cppValue, v8Value);
impl->setHrefThrows(cppValue, exceptionState);
exceptionState.throwIfNeeded();
}
void V8File::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "File", info.Holder(), info.GetIsolate());
if (!RuntimeEnabledFeatures::fileConstructorEnabled()) {
exceptionState.throwTypeError("Illegal constructor");
exceptionState.throwIfNeeded();
return;
}
if (info.Length() < 2) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
exceptionState.throwIfNeeded();
return;
}
uint32_t length = 0;
if (info[0]->IsArray()) {
length = v8::Local<v8::Array>::Cast(info[0])->Length();
} else {
const int sequenceArgumentIndex = 0;
if (toV8Sequence(info[sequenceArgumentIndex], length, info.GetIsolate()).IsEmpty()) {
exceptionState.throwTypeError(ExceptionMessages::notAnArrayTypeArgumentOrValue(sequenceArgumentIndex + 1));
exceptionState.throwIfNeeded();
return;
}
}
TOSTRING_VOID(V8StringResource<>, fileName, info[1]);
V8BlobCustomHelpers::ParsedProperties properties(true);
if (info.Length() > 2) {
if (!info[2]->IsObject()) {
exceptionState.throwTypeError("The 3rd argument is not of type Object.");
exceptionState.throwIfNeeded();
return;
}
if (!properties.parseBlobPropertyBag(info[2], "File", exceptionState, info.GetIsolate())) {
exceptionState.throwIfNeeded();
return;
}
} else {
properties.setDefaultLastModified();
}
OwnPtr<BlobData> blobData = BlobData::create();
blobData->setContentType(properties.contentType());
v8::Local<v8::Object> blobParts = v8::Local<v8::Object>::Cast(info[0]);
if (!V8BlobCustomHelpers::processBlobParts(blobParts, length, properties.normalizeLineEndingsToNative(), *blobData, info.GetIsolate()))
return;
long long fileSize = blobData->length();
RefPtrWillBeRawPtr<File> file = File::create(fileName, properties.lastModified(), BlobDataHandle::create(blobData.release(), fileSize));
v8SetReturnValue(info, file.release());
}
static void namedPropertySetter(v8::Local<v8::String> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
TestSpecialOperations* impl = V8TestSpecialOperations::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, propertyName, name);
TONATIVE_VOID(Node*, propertyValue, V8Node::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
bool result = impl->anonymousNamedSetter(propertyName, propertyValue);
if (!result)
return;
v8SetReturnValue(info, v8Value);
}
void V8CanvasRenderingContext2D::fillStyleAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
CanvasRenderingContext2D* impl = V8CanvasRenderingContext2D::toNative(info.Holder());
if (RefPtr<CanvasStyle> canvasStyle = toCanvasStyle(value, info.GetIsolate())) {
impl->setFillStyle(canvasStyle);
} else {
TOSTRING_VOID(V8StringResource<>, colorString, value);
impl->setFillColor(colorString);
}
}
void V8Window::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "Window", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 2)) {
setMinimumArityTypeError(exceptionState, 2, info.Length());
exceptionState.throwIfNeeded();
return;
}
// None of these need to be RefPtr because info and context are guaranteed
// to hold on to them.
DOMWindow* window = V8Window::toImpl(info.Holder());
LocalDOMWindow* source = callingDOMWindow(info.GetIsolate());
ASSERT(window);
UseCounter::countIfNotPrivateScript(info.GetIsolate(), window->frame(), UseCounter::WindowPostMessage);
// If called directly by WebCore we don't have a calling context.
if (!source) {
exceptionState.throwTypeError("No active calling context exists.");
exceptionState.throwIfNeeded();
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);
OwnPtrWillBeRawPtr<MessagePortArray> portArray = adoptPtrWillBeNoop(new MessagePortArray);
ArrayBufferArray arrayBufferArray;
int targetOriginArgIndex = 1;
if (info.Length() > 2) {
int transferablesArgIndex = 2;
if (isLegacyTargetOriginDesignation(info[2])) {
UseCounter::countIfNotPrivateScript(info.GetIsolate(), window->frame(), UseCounter::WindowPostMessageWithLegacyTargetOriginArgument);
targetOriginArgIndex = 2;
transferablesArgIndex = 1;
}
if (!SerializedScriptValue::extractTransferables(info.GetIsolate(), info[transferablesArgIndex], transferablesArgIndex, *portArray, arrayBufferArray, exceptionState)) {
exceptionState.throwIfNeeded();
return;
}
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, targetOrigin, info[targetOriginArgIndex]);
RefPtr<SerializedScriptValue> message = SerializedScriptValueFactory::instance().create(info.GetIsolate(), info[0], portArray.get(), &arrayBufferArray, exceptionState);
if (exceptionState.throwIfNeeded())
return;
window->postMessage(message.release(), portArray.get(), targetOrigin, source, exceptionState);
exceptionState.throwIfNeeded();
}
void V8AbstractEventListener::invokeEventHandler(Event* event, v8::Local<v8::Value> jsEvent)
{
// If jsEvent is empty, attempt to set it as a hidden value would crash v8.
if (jsEvent.IsEmpty())
return;
ASSERT(!scriptState()->contextIsEmpty());
v8::Local<v8::Value> returnValue;
{
// Catch exceptions thrown in the event handler so they do not propagate to javascript code that caused the event to fire.
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
// Save the old 'event' property so we can restore it later.
v8::Local<v8::Value> savedEvent = V8HiddenValue::getHiddenValue(isolate(), scriptState()->context()->Global(), V8HiddenValue::event(isolate()));
tryCatch.Reset();
// Make the event available in the global object, so LocalDOMWindow can expose it.
V8HiddenValue::setHiddenValue(isolate(), scriptState()->context()->Global(), V8HiddenValue::event(isolate()), jsEvent);
tryCatch.Reset();
returnValue = callListenerFunction(jsEvent, event);
if (tryCatch.HasCaught())
event->target()->uncaughtExceptionInEventHandler();
if (!tryCatch.CanContinue()) { // Result of TerminateExecution().
if (scriptState()->executionContext()->isWorkerGlobalScope())
toWorkerGlobalScope(scriptState()->executionContext())->script()->forbidExecution();
return;
}
tryCatch.Reset();
// Restore the old event. This must be done for all exit paths through this method.
if (savedEvent.IsEmpty())
V8HiddenValue::setHiddenValue(isolate(), scriptState()->context()->Global(), V8HiddenValue::event(isolate()), v8::Undefined(isolate()));
else
V8HiddenValue::setHiddenValue(isolate(), scriptState()->context()->Global(), V8HiddenValue::event(isolate()), savedEvent);
tryCatch.Reset();
}
if (returnValue.IsEmpty())
return;
if (m_isAttribute && !returnValue->IsNull() && !returnValue->IsUndefined() && event->isBeforeUnloadEvent()) {
TOSTRING_VOID(V8StringResource<>, stringReturnValue, returnValue);
toBeforeUnloadEvent(event)->setReturnValue(stringReturnValue);
}
if (m_isAttribute && shouldPreventDefault(returnValue))
event->preventDefault();
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
if (UNLIKELY(info.Length() < 1)) {
throwArityTypeErrorForConstructor("TestInterfaceConstructor3", 1, info.Length(), info.GetIsolate());
return;
}
TOSTRING_VOID(V8StringResource<>, stringArg, info[0]);
RefPtr<TestInterfaceConstructor3> impl = TestInterfaceConstructor3::create(stringArg);
v8::Handle<v8::Object> wrapper = info.Holder();
V8DOMWrapper::associateObjectWithWrapper<V8TestInterfaceConstructor3>(impl.release(), &V8TestInterfaceConstructor3::wrapperTypeInfo, wrapper, isolate, WrapperConfiguration::Independent);
v8SetReturnValue(info, wrapper);
}
void V8CustomEvent::initCustomEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
CustomEvent* event = V8CustomEvent::toImpl(info.Holder());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
bool canBubbleArg;
bool cancelableArg;
if (!v8Call(info[1]->BooleanValue(info.GetIsolate()->GetCurrentContext()), canBubbleArg)
|| !v8Call(info[2]->BooleanValue(info.GetIsolate()->GetCurrentContext()), cancelableArg))
return;
v8::Local<v8::Value> detailsArg = info[3];
event->initEvent(typeArg, canBubbleArg, cancelableArg);
event->setDetail(ScriptValue(ScriptState::current(info.GetIsolate()), detailsArg));
}
void V8XMLHttpRequest::sendMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(info.Holder());
InspectorInstrumentation::willSendXMLHttpRequest(xmlHttpRequest->executionContext(), xmlHttpRequest->url());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "send", "XMLHttpRequest", info.Holder(), info.GetIsolate());
if (info.Length() < 1) {
xmlHttpRequest->send(exceptionState);
} else {
v8::Handle<v8::Value> arg = info[0];
if (isUndefinedOrNull(arg)) {
xmlHttpRequest->send(exceptionState);
} else if (isDocumentType(arg, info.GetIsolate())) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
Document* document = V8Document::toNative(object);
ASSERT(document);
xmlHttpRequest->send(document, exceptionState);
} else if (V8Blob::hasInstance(arg, info.GetIsolate())) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
Blob* blob = V8Blob::toNative(object);
ASSERT(blob);
xmlHttpRequest->send(blob, exceptionState);
} else if (V8FormData::hasInstance(arg, info.GetIsolate())) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
DOMFormData* domFormData = V8FormData::toNative(object);
ASSERT(domFormData);
xmlHttpRequest->send(domFormData, exceptionState);
} else if (V8ArrayBuffer::hasInstance(arg, info.GetIsolate())) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(object);
ASSERT(arrayBuffer);
xmlHttpRequest->send(arrayBuffer, exceptionState);
} else if (V8ArrayBufferView::hasInstance(arg, info.GetIsolate())) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(object);
ASSERT(arrayBufferView);
xmlHttpRequest->send(arrayBufferView, exceptionState);
} else {
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, argString, arg);
xmlHttpRequest->send(argString, exceptionState);
}
}
exceptionState.throwIfNeeded();
}
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.
LocalDOMWindow* window = V8Window::toNative(info.Holder());
LocalDOMWindow* source = callingDOMWindow(info.GetIsolate());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "Window", info.Holder(), info.GetIsolate());
// If called directly by WebCore we don't have a calling context.
if (!source) {
exceptionState.throwTypeError("No active calling context exists.");
exceptionState.throwIfNeeded();
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;
}
if (!SerializedScriptValue::extractTransferables(info[transferablesArgIndex], transferablesArgIndex, portArray, arrayBufferArray, exceptionState, info.GetIsolate())) {
exceptionState.throwIfNeeded();
return;
}
}
TOSTRING_VOID(V8StringResource<TreatNullAndUndefinedAsNullString>, targetOrigin, info[targetOriginArgIndex]);
RefPtr<SerializedScriptValue> message = SerializedScriptValue::create(info[0], &portArray, &arrayBufferArray, exceptionState, info.GetIsolate());
if (exceptionState.throwIfNeeded())
return;
window->postMessage(message.release(), &portArray, targetOrigin, source, exceptionState);
exceptionState.throwIfNeeded();
}
void V8HTMLCanvasElement::toDataURLMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
ExceptionState exceptionState(ExceptionState::ExecutionContext, "toDataURL", "HTMLCanvasElement", info.Holder(), info.GetIsolate());
TOSTRING_VOID(V8StringResource<>, type, info[0]);
double quality;
double* qualityPtr = 0;
if (info.Length() > 1 && info[1]->IsNumber()) {
quality = info[1]->NumberValue();
qualityPtr = &quality;
}
String result = canvas->toDataURL(type, qualityPtr, exceptionState);
exceptionState.throwIfNeeded();
v8SetReturnValueStringOrUndefined(info, result, info.GetIsolate());
}
void V8CustomEvent::initCustomEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
CustomEvent* event = V8CustomEvent::toNative(info.Holder());
ASSERT(!event->serializedDetail());
TOSTRING_VOID(V8StringResource<>, typeArg, info[0]);
TONATIVE_VOID(bool, canBubbleArg, info[1]->BooleanValue());
TONATIVE_VOID(bool, cancelableArg, info[2]->BooleanValue());
v8::Handle<v8::Value> detailsArg = info[3];
event->initEvent(typeArg, canBubbleArg, cancelableArg);
if (!detailsArg.IsEmpty()) {
V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::detail(info.GetIsolate()), detailsArg);
if (DOMWrapperWorld::current(info.GetIsolate()).isIsolatedWorld())
event->setSerializedDetail(SerializedScriptValue::createAndSwallowExceptions(detailsArg, info.GetIsolate()));
}
}
void V8DeviceOrientationEvent::initDeviceOrientationEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
DeviceOrientationEvent* impl = V8DeviceOrientationEvent::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, type, info[0]);
bool bubbles = info[1]->BooleanValue();
bool cancelable = info[2]->BooleanValue();
// If alpha, beta, gamma or absolute are null or undefined, mark them as not provided.
// Otherwise, use the standard JavaScript conversion.
bool alphaProvided = !isUndefinedOrNull(info[3]);
double alpha = info[3]->NumberValue();
bool betaProvided = !isUndefinedOrNull(info[4]);
double beta = info[4]->NumberValue();
bool gammaProvided = !isUndefinedOrNull(info[5]);
double gamma = info[5]->NumberValue();
bool absoluteProvided = !isUndefinedOrNull(info[6]);
bool absolute = info[6]->BooleanValue();
RefPtrWillBeRawPtr<DeviceOrientationData> orientation = DeviceOrientationData::create(alphaProvided, alpha, betaProvided, beta, gammaProvided, gamma, absoluteProvided, absolute);
impl->initDeviceOrientationEvent(type, bubbles, cancelable, orientation.get());
}