static JSC::JSValue handleInitMessageEvent(JSMessageEvent* jsEvent, JSC::ExecState* exec)
{
const String& typeArg = exec->argument(0).toString(exec)->value(exec);
bool canBubbleArg = exec->argument(1).toBoolean(exec);
bool cancelableArg = exec->argument(2).toBoolean(exec);
const String originArg = exec->argument(4).toString(exec)->value(exec);
const String lastEventIdArg = exec->argument(5).toString(exec)->value(exec);
DOMWindow* sourceArg = toDOMWindow(exec->argument(6));
std::unique_ptr<MessagePortArray> messagePorts;
OwnPtr<ArrayBufferArray> arrayBuffers;
if (!exec->argument(7).isUndefinedOrNull()) {
messagePorts = std::make_unique<MessagePortArray>();
arrayBuffers = adoptPtr(new ArrayBufferArray);
fillMessagePortArray(exec, exec->argument(7), *messagePorts, *arrayBuffers);
if (exec->hadException())
return jsUndefined();
}
Deprecated::ScriptValue dataArg = Deprecated::ScriptValue(exec->vm(), exec->argument(3));
if (exec->hadException())
return jsUndefined();
MessageEvent& event = jsEvent->impl();
event.initMessageEvent(typeArg, canBubbleArg, cancelableArg, dataArg, originArg, lastEventIdArg, sourceArg, WTF::move(messagePorts));
jsEvent->m_data.set(exec->vm(), jsEvent, dataArg.jsValue());
return jsUndefined();
}
void V8PerformanceObserver::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (UNLIKELY(info.Length() < 1)) {
V8ThrowException::throwException(createMinimumArityTypeErrorForMethod(info.GetIsolate(), "createPerformanceObserver", "Performance", 1, info.Length()), info.GetIsolate());
return;
}
v8::Local<v8::Object> wrapper = info.Holder();
Performance* performance = nullptr;
DOMWindow* window = toDOMWindow(wrapper->CreationContext());
if (!window) {
V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("createPerformanceObserver", "Performance", "No \"window\" in current context."));
return;
}
performance = DOMWindowPerformance::performance(*window);
ASSERT(performance);
PerformanceObserverCallback* callback;
{
if (info.Length() <= 0 || !info[0]->IsFunction()) {
V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("createPerformanceObserver", "Performance", "The callback provided as parameter 1 is not a function."));
return;
}
callback = V8PerformanceObserverCallback::create(v8::Local<v8::Function>::Cast(info[0]), wrapper, ScriptState::current(info.GetIsolate()));
}
PerformanceObserver* observer = PerformanceObserver::create(performance, callback);
v8SetReturnValue(info, V8DOMWrapper::associateObjectWithWrapper(info.GetIsolate(), observer, &wrapperTypeInfo, wrapper));
}
void V8Document::createTouchMethodPrologueCustom(
const v8::FunctionCallbackInfo<v8::Value>& info,
Document*) {
v8::Local<v8::Value> v8Window = info[0];
if (isUndefinedOrNull(v8Window)) {
UseCounter::countIfNotPrivateScript(
info.GetIsolate(), currentExecutionContext(info.GetIsolate()),
UseCounter::DocumentCreateTouchWindowNull);
} else if (!toDOMWindow(info.GetIsolate(), v8Window)) {
UseCounter::countIfNotPrivateScript(
info.GetIsolate(), currentExecutionContext(info.GetIsolate()),
UseCounter::DocumentCreateTouchWindowWrongType);
}
v8::Local<v8::Value> v8Target = info[1];
if (isUndefinedOrNull(v8Target)) {
UseCounter::countIfNotPrivateScript(
info.GetIsolate(), currentExecutionContext(info.GetIsolate()),
UseCounter::DocumentCreateTouchTargetNull);
} else if (!toEventTarget(info.GetIsolate(), v8Target)) {
UseCounter::countIfNotPrivateScript(
info.GetIsolate(), currentExecutionContext(info.GetIsolate()),
UseCounter::DocumentCreateTouchTargetWrongType);
}
if (info.Length() < 7) {
UseCounter::countIfNotPrivateScript(
info.GetIsolate(), currentExecutionContext(info.GetIsolate()),
UseCounter::DocumentCreateTouchLessThanSevenArguments);
}
}
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()));
}
}
EncodedJSValue JSC_HOST_CALL jsTextEventPrototypeFunctionInitTextEvent(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSTextEvent::s_info))
return throwVMTypeError(exec);
JSTextEvent* castedThis = static_cast<JSTextEvent*>(asObject(thisValue));
ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTextEvent::s_info);
TextEvent* imp = static_cast<TextEvent*>(castedThis->impl());
const String& typeArg(ustringToString(exec->argument(0).toString(exec)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool canBubbleArg(exec->argument(1).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool cancelableArg(exec->argument(2).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
DOMWindow* viewArg(toDOMWindow(exec->argument(3)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
const String& dataArg(ustringToString(exec->argument(4).toString(exec)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
imp->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, dataArg);
return JSValue::encode(jsUndefined());
}
JSC::JSValue JSMessageEvent::initMessageEvent(JSC::ExecState* exec)
{
const UString& typeArg = exec->argument(0).toString(exec);
bool canBubbleArg = exec->argument(1).toBoolean(exec);
bool cancelableArg = exec->argument(2).toBoolean(exec);
RefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(exec, exec->argument(3));
if (exec->hadException())
return jsUndefined();
const UString& originArg = exec->argument(4).toString(exec);
const UString& lastEventIdArg = exec->argument(5).toString(exec);
DOMWindow* sourceArg = toDOMWindow(exec->argument(6));
OwnPtr<MessagePortArray> messagePorts;
if (!exec->argument(7).isUndefinedOrNull()) {
messagePorts = adoptPtr(new MessagePortArray);
fillMessagePortArray(exec, exec->argument(7), *messagePorts);
if (exec->hadException())
return jsUndefined();
}
MessageEvent* event = static_cast<MessageEvent*>(this->impl());
event->initMessageEvent(ustringToAtomicString(typeArg), canBubbleArg, cancelableArg, dataArg.release(), ustringToString(originArg), ustringToString(lastEventIdArg), sourceArg, messagePorts.release());
JSValue result;
if (SerializedScriptValue* serializedValue = event->dataAsSerializedScriptValue())
result = serializedValue->deserialize(exec, globalObject(), NonThrowing);
else
result = jsNull();
m_data.set(exec->globalData(), this, result);
return jsUndefined();
}
void convertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject* owner, NPVariant* result, v8::Isolate* isolate)
{
VOID_TO_NPVARIANT(*result);
// It is really the caller's responsibility to deal with the empty handle case because there could be different actions to
// take in different contexts.
ASSERT(!object.IsEmpty());
if (object.IsEmpty())
return;
if (object->IsNumber())
DOUBLE_TO_NPVARIANT(object->NumberValue(), *result);
else if (object->IsBoolean())
BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result);
else if (object->IsNull())
NULL_TO_NPVARIANT(*result);
else if (object->IsUndefined())
VOID_TO_NPVARIANT(*result);
else if (object->IsString()) {
v8::Handle<v8::String> str = object.As<v8::String>();
int length = str->Utf8Length() + 1;
char* utf8Chars = reinterpret_cast<char*>(malloc(length));
str->WriteUtf8(utf8Chars, length, 0, v8::String::HINT_MANY_WRITES_EXPECTED);
STRINGN_TO_NPVARIANT(utf8Chars, length-1, *result);
} else if (object->IsObject()) {
DOMWindow* window = toDOMWindow(isolate->GetCurrentContext());
NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window, isolate);
if (npobject)
_NPN_RegisterObject(npobject, owner);
OBJECT_TO_NPVARIANT(npobject, *result);
}
}
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);
}
bool ScriptController::shouldBypassMainWorldContentSecurityPolicy()
{
v8::Handle<v8::Context> context = m_isolate->GetCurrentContext();
if (context.IsEmpty() || !toDOMWindow(context))
return false;
DOMWrapperWorld* world = DOMWrapperWorld::current(m_isolate);
return world->isIsolatedWorld() ? world->isolatedWorldHasContentSecurityPolicy() : false;
}
bool ScriptController::shouldBypassMainWorldCSP()
{
v8::HandleScope handleScope(isolate());
v8::Local<v8::Context> context = isolate()->GetCurrentContext();
if (context.IsEmpty() || !toDOMWindow(context))
return false;
DOMWrapperWorld& world = DOMWrapperWorld::current(isolate());
return world.isIsolatedWorld() ? world.isolatedWorldHasContentSecurityPolicy() : false;
}
JSValue* JSMouseEventPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
{
if (!thisObj->inherits(&JSMouseEvent::info))
return throwError(exec, TypeError);
MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(thisObj)->impl());
switch (id) {
case JSMouseEvent::InitMouseEventFuncNum: {
AtomicString type = args[0]->toString(exec);
bool canBubble = args[1]->toBoolean(exec);
bool cancelable = args[2]->toBoolean(exec);
DOMWindow* view = toDOMWindow(args[3]);
bool detailOk;
int detail = args[4]->toInt32(exec, detailOk);
if (!detailOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
bool screenXOk;
int screenX = args[5]->toInt32(exec, screenXOk);
if (!screenXOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
bool screenYOk;
int screenY = args[6]->toInt32(exec, screenYOk);
if (!screenYOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
bool clientXOk;
int clientX = args[7]->toInt32(exec, clientXOk);
if (!clientXOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
bool clientYOk;
int clientY = args[8]->toInt32(exec, clientYOk);
if (!clientYOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
bool ctrlKey = args[9]->toBoolean(exec);
bool altKey = args[10]->toBoolean(exec);
bool shiftKey = args[11]->toBoolean(exec);
bool metaKey = args[12]->toBoolean(exec);
unsigned short button = args[13]->toInt32(exec);
EventTargetNode* relatedTarget = toEventTargetNode(args[14]);
imp->initMouseEvent(type, canBubble, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget);
return jsUndefined();
}
}
return 0;
}
Frame* toFrameIfNotDetached(v8::Handle<v8::Context> context)
{
DOMWindow* window = toDOMWindow(context);
if (window->isCurrentlyDisplayedInFrame())
return window->frame();
// We return 0 here because |context| is detached from the Frame. If we
// did return |frame| we could get in trouble because the frame could be
// navigated to another security origin.
return 0;
}
void V8WrapperInstantiationScope::convertException()
{
v8::Isolate* isolate = m_context->GetIsolate();
// TODO(jochen): Currently, Location is the only object for which we can reach this code path. Should be generalized.
ExceptionState exceptionState(ExceptionState::ConstructionContext, "Location", isolate->GetCurrentContext()->Global(), isolate);
LocalDOMWindow* callingWindow = callingDOMWindow(isolate);
DOMWindow* targetWindow = toDOMWindow(m_context);
exceptionState.throwSecurityError(targetWindow->sanitizedCrossDomainAccessErrorMessage(callingWindow), targetWindow->crossDomainAccessErrorMessage(callingWindow));
exceptionState.throwIfNeeded();
}
static NPObject* makeStringArrayImpl(const WebVector<WebString>& data)
{
v8::HandleScope handleScope;
v8::Handle<v8::Array> result = v8::Array::New(data.size());
for (size_t i = 0; i < data.size(); ++i)
result->Set(i, data[i].data() ? v8::String::New(reinterpret_cast<const uint16_t*>((data[i].data())), data[i].length()) : v8::String::New(""));
DOMWindow* window = toDOMWindow(v8::Context::GetCurrent());
return npCreateV8ScriptObject(0, result, window);
}
static NPObject* makeIntArrayImpl(const WebVector<int>& data)
{
v8::HandleScope handleScope;
v8::Handle<v8::Array> result = v8::Array::New(data.size());
for (size_t i = 0; i < data.size(); ++i)
result->Set(i, v8::Number::New(data[i]));
DOMWindow* window = toDOMWindow(v8::Context::GetCurrent());
return npCreateV8ScriptObject(0, result, window);
}
DOMWindow* activeDOMWindow()
{
v8::Handle<v8::Context> context = v8::Isolate::GetCurrent()->GetCallingContext();
if (context.IsEmpty()) {
// Unfortunately, when processing script from a plug-in, we might not
// have a calling context. In those cases, we fall back to the
// entered context.
context = v8::Isolate::GetCurrent()->GetEnteredContext();
}
return toDOMWindow(context);
}
bool Dictionary::get(const String& key, RefPtr<DOMWindow>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
// We need to handle a DOMWindow specially, because a DOMWindow wrapper
// exists on a prototype chain of v8Value.
value = toDOMWindow(v8Value, m_isolate);
return true;
}
bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, RefPtrWillBeMember<LocalDOMWindow>& value)
{
v8::Local<v8::Value> v8Value;
if (!dictionary.get(key, v8Value))
return false;
// We need to handle a DOMWindow specially, because a DOMWindow wrapper
// exists on a prototype chain of v8Value.
value = toDOMWindow(v8Value, dictionary.isolate());
return true;
}
PassRefPtrWillBeRawPtr<EventListener> V8EventListenerList::getEventListener(ScriptState* scriptState, v8::Local<v8::Value> value, bool isAttribute, ListenerLookupType lookup)
{
if (lookup == ListenerFindOnly) {
// Used by EventTarget::removeEventListener, specifically
// EventTargetV8Internal::removeEventListenerMethod
ASSERT(!isAttribute);
return V8EventListenerList::findWrapper(value, scriptState);
}
if (toDOMWindow(scriptState->context()))
return V8EventListenerList::findOrCreateWrapper<V8EventListener>(value, isAttribute, scriptState);
return V8EventListenerList::findOrCreateWrapper<V8WorkerGlobalScopeEventListener>(value, isAttribute, scriptState);
}
bool ScriptController::shouldBypassMainWorldCSP()
{
v8::HandleScope handleScope(isolate());
v8::Handle<v8::Context> context = isolate()->GetCurrentContext();
if (context == node::g_context) {
if (frame()->document()->securityOrigin()->hasUniversalAccess())
return true;
}
if (context.IsEmpty() || !toDOMWindow(context))
return false;
DOMWrapperWorld& world = DOMWrapperWorld::current(isolate());
return world.isIsolatedWorld() ? world.isolatedWorldHasContentSecurityPolicy() : false;
}
void V8PerformanceObserver::constructorCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
if (UNLIKELY(info.Length() < 1)) {
V8ThrowException::throwTypeError(
info.GetIsolate(),
ExceptionMessages::failedToConstruct(
"PerformanceObserver",
ExceptionMessages::notEnoughArguments(1, info.Length())));
return;
}
v8::Local<v8::Object> wrapper = info.Holder();
Performance* performance = nullptr;
DOMWindow* window = toDOMWindow(wrapper->CreationContext());
if (!window) {
V8ThrowException::throwTypeError(
info.GetIsolate(),
ExceptionMessages::failedToConstruct(
"PerformanceObserver", "No 'window' in current context."));
return;
}
performance = DOMWindowPerformance::performance(*window);
ASSERT(performance);
if (info.Length() <= 0 || !info[0]->IsFunction()) {
V8ThrowException::throwTypeError(
info.GetIsolate(),
ExceptionMessages::failedToConstruct(
"PerformanceObserver",
"The callback provided as parameter 1 is not a function."));
return;
}
ScriptState* scriptState = ScriptState::forReceiverObject(info);
v8::Local<v8::Function> v8Callback = v8::Local<v8::Function>::Cast(info[0]);
PerformanceObserverCallback* callback =
PerformanceObserverCallback::create(scriptState, v8Callback);
PerformanceObserver* observer =
PerformanceObserver::create(scriptState, performance, callback);
// TODO(bashi): Don't set private property (and remove this custom
// constructor) when we can call setWrapperReference() correctly.
// crbug.com/468240.
V8PrivateProperty::getPerformanceObserverCallback(info.GetIsolate())
.set(info.GetIsolate()->GetCurrentContext(), wrapper, v8Callback);
v8SetReturnValue(info,
V8DOMWrapper::associateObjectWithWrapper(
info.GetIsolate(), observer, &wrapperTypeInfo, wrapper));
}
JSValue* jsTextEventPrototypeFunctionInitTextEvent(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSTextEvent::s_info))
return throwError(exec, TypeError);
JSTextEvent* castedThisObj = static_cast<JSTextEvent*>(thisValue);
TextEvent* imp = static_cast<TextEvent*>(castedThisObj->impl());
const UString& typeArg = args[0]->toString(exec);
bool canBubbleArg = args[1]->toBoolean(exec);
bool cancelableArg = args[2]->toBoolean(exec);
DOMWindow* viewArg = toDOMWindow(args[3]);
const UString& dataArg = args[4]->toString(exec);
imp->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, dataArg);
return jsUndefined();
}
V8DOMActivityLogger* V8DOMActivityLogger::currentActivityLogger() {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
if (!isolate->InContext())
return 0;
v8::HandleScope handleScope(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
if (context.IsEmpty() || !toDOMWindow(context))
return 0;
V8PerContextData* contextData = ScriptState::from(context)->perContextData();
if (!contextData)
return 0;
return contextData->activityLogger();
}
AtomicString V8CustomXPathNSResolver::lookupNamespaceURI(const String& prefix) {
v8::Isolate* isolate = m_scriptState->isolate();
v8::Local<v8::Function> lookupNamespaceURIFunc;
v8::Local<v8::String> lookupNamespaceURIName =
v8AtomicString(isolate, "lookupNamespaceURI");
// Check if the resolver has a function property named lookupNamespaceURI.
v8::Local<v8::Value> lookupNamespaceURI;
if (m_resolver->Get(m_scriptState->context(), lookupNamespaceURIName)
.ToLocal(&lookupNamespaceURI) &&
lookupNamespaceURI->IsFunction())
lookupNamespaceURIFunc = v8::Local<v8::Function>::Cast(lookupNamespaceURI);
if (lookupNamespaceURIFunc.IsEmpty() && !m_resolver->IsFunction()) {
LocalFrame* frame =
toLocalDOMWindow(toDOMWindow(m_scriptState->context()))->frame();
if (frame && frame->host())
frame->console().addMessage(ConsoleMessage::create(
JSMessageSource, ErrorMessageLevel,
"XPathNSResolver does not have a lookupNamespaceURI method."));
return nullAtom;
}
// Catch exceptions from calling the namespace resolver.
v8::TryCatch tryCatch(isolate);
tryCatch.SetVerbose(true); // Print exceptions to console.
const int argc = 1;
v8::Local<v8::Value> argv[argc] = {v8String(isolate, prefix)};
v8::Local<v8::Function> function =
lookupNamespaceURIFunc.IsEmpty()
? v8::Local<v8::Function>::Cast(m_resolver)
: lookupNamespaceURIFunc;
v8::Local<v8::Value> retval;
// Eat exceptions from namespace resolver and return an empty string. This
// will most likely cause NamespaceError.
if (!V8ScriptRunner::callFunction(
function, toExecutionContext(m_scriptState->context()), m_resolver,
argc, argv, isolate)
.ToLocal(&retval))
return nullAtom;
TOSTRING_DEFAULT(V8StringResource<TreatNullAsNullString>, returnString,
retval, nullAtom);
return returnString;
}
EncodedJSValue JSC_HOST_CALL jsKeyboardEventPrototypeFunctionInitKeyboardEvent(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
JSKeyboardEvent* castedThis = jsDynamicCast<JSKeyboardEvent*>(thisValue);
if (!castedThis)
return throwVMTypeError(exec);
ASSERT_GC_OBJECT_INHERITS(castedThis, JSKeyboardEvent::info());
KeyboardEvent& impl = castedThis->impl();
const String& type(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool canBubble(exec->argument(1).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool cancelable(exec->argument(2).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
DOMWindow* view(toDOMWindow(exec->argument(3)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
const String& keyIdentifier(exec->argument(4).isEmpty() ? String() : exec->argument(4).toString(exec)->value(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
unsigned location(toUInt32(exec, exec->argument(5), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool ctrlKey(exec->argument(6).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool altKey(exec->argument(7).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool shiftKey(exec->argument(8).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool metaKey(exec->argument(9).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool altGraphKey(exec->argument(10).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
impl.initKeyboardEvent(type, canBubble, cancelable, view, keyIdentifier, location, ctrlKey, altKey, shiftKey, metaKey, altGraphKey);
return JSValue::encode(jsUndefined());
}
EncodedJSValue JSC_HOST_CALL jsWheelEventPrototypeFunctionInitWebKitWheelEvent(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
JSWheelEvent* castedThis = jsDynamicCast<JSWheelEvent*>(thisValue);
if (!castedThis)
return throwVMTypeError(exec);
ASSERT_GC_OBJECT_INHERITS(castedThis, JSWheelEvent::info());
WheelEvent& impl = castedThis->impl();
int wheelDeltaX(toInt32(exec, exec->argument(0), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
int wheelDeltaY(toInt32(exec, exec->argument(1), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
DOMWindow* view(toDOMWindow(exec->argument(2)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
int screenX(toInt32(exec, exec->argument(3), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
int screenY(toInt32(exec, exec->argument(4), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
int clientX(toInt32(exec, exec->argument(5), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
int clientY(toInt32(exec, exec->argument(6), NormalConversion));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool ctrlKey(exec->argument(7).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool altKey(exec->argument(8).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool shiftKey(exec->argument(9).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
bool metaKey(exec->argument(10).toBoolean(exec));
if (exec->hadException())
return JSValue::encode(jsUndefined());
impl.initWebKitWheelEvent(wheelDeltaX, wheelDeltaY, view, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey);
return JSValue::encode(jsUndefined());
}
JSC::JSValue JSMessageEvent::initMessageEvent(JSC::ExecState* exec, const JSC::ArgList& args)
{
const UString& typeArg = args.at(0).toString(exec);
bool canBubbleArg = args.at(1).toBoolean(exec);
bool cancelableArg = args.at(2).toBoolean(exec);
PassRefPtr<SerializedScriptValue> dataArg = SerializedScriptValue::create(exec, args.at(3));
const UString& originArg = args.at(4).toString(exec);
const UString& lastEventIdArg = args.at(5).toString(exec);
DOMWindow* sourceArg = toDOMWindow(args.at(6));
OwnPtr<MessagePortArray> messagePorts;
if (!args.at(7).isUndefinedOrNull()) {
messagePorts = new MessagePortArray();
fillMessagePortArray(exec, args.at(7), *messagePorts);
if (exec->hadException())
return jsUndefined();
}
MessageEvent* event = static_cast<MessageEvent*>(this->impl());
event->initMessageEvent(ustringToAtomicString(typeArg), canBubbleArg, cancelableArg, dataArg, ustringToString(originArg), ustringToString(lastEventIdArg), sourceArg, messagePorts.release());
return jsUndefined();
}
JSValue* JSTextEventPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
{
if (!thisObj->inherits(&JSTextEvent::info))
return throwError(exec, TypeError);
TextEvent* imp = static_cast<TextEvent*>(static_cast<JSTextEvent*>(thisObj)->impl());
switch (id) {
case JSTextEvent::InitTextEventFuncNum: {
String typeArg = args[0]->toString(exec);
bool canBubbleArg = args[1]->toBoolean(exec);
bool cancelableArg = args[2]->toBoolean(exec);
DOMWindow* viewArg = toDOMWindow(args[3]);
String dataArg = args[4]->toString(exec);
imp->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, dataArg);
return jsUndefined();
}
}
return 0;
}
JSValue* jsKeyboardEventPrototypeFunctionInitKeyboardEvent(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSKeyboardEvent::s_info))
return throwError(exec, TypeError);
JSKeyboardEvent* castedThisObj = static_cast<JSKeyboardEvent*>(thisValue);
KeyboardEvent* imp = static_cast<KeyboardEvent*>(castedThisObj->impl());
const UString& type = args[0]->toString(exec);
bool canBubble = args[1]->toBoolean(exec);
bool cancelable = args[2]->toBoolean(exec);
DOMWindow* view = toDOMWindow(args[3]);
const UString& keyIdentifier = args[4]->toString(exec);
unsigned keyLocation = args[5]->toInt32(exec);
bool ctrlKey = args[6]->toBoolean(exec);
bool altKey = args[7]->toBoolean(exec);
bool shiftKey = args[8]->toBoolean(exec);
bool metaKey = args[9]->toBoolean(exec);
bool altGraphKey = args[10]->toBoolean(exec);
imp->initKeyboardEvent(type, canBubble, cancelable, view, keyIdentifier, keyLocation, ctrlKey, altKey, shiftKey, metaKey, altGraphKey);
return jsUndefined();
}
static JSC::JSValue handleInitMessageEvent(JSMessageEvent* jsEvent, JSC::ExecState* exec)
{
const UString& typeArg = exec->argument(0).toString(exec);
bool canBubbleArg = exec->argument(1).toBoolean(exec);
bool cancelableArg = exec->argument(2).toBoolean(exec);
const UString& originArg = exec->argument(4).toString(exec);
const UString& lastEventIdArg = exec->argument(5).toString(exec);
DOMWindow* sourceArg = toDOMWindow(exec->argument(6));
OwnPtr<MessagePortArray> messagePorts;
if (!exec->argument(7).isUndefinedOrNull()) {
messagePorts = adoptPtr(new MessagePortArray);
fillMessagePortArray(exec, exec->argument(7), *messagePorts);
if (exec->hadException())
return jsUndefined();
}
ScriptValue dataArg = ScriptValue(exec->globalData(), exec->argument(3));
if (exec->hadException())
return jsUndefined();
MessageEvent* event = static_cast<MessageEvent*>(jsEvent->impl());
event->initMessageEvent(ustringToAtomicString(typeArg), canBubbleArg, cancelableArg, dataArg, ustringToString(originArg), ustringToString(lastEventIdArg), sourceArg, messagePorts.release());
jsEvent->m_data.set(exec->globalData(), jsEvent, dataArg.jsValue());
return jsUndefined();
}
