static v8::Handle<v8::Value> webkitStartActivityCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Navigator* imp = V8Navigator::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Intent*, intent, V8Intent::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Intent::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
RefPtr<IntentResultCallback> successCallback;
if (args.Length() > 1 && !args[1]->IsNull() && !args[1]->IsUndefined()) {
if (!args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
successCallback = V8IntentResultCallback::create(args[1], getScriptExecutionContext());
}
RefPtr<IntentResultCallback> failureCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
failureCallback = V8IntentResultCallback::create(args[2], getScriptExecutionContext());
}
NavigatorIntents::webkitStartActivity(imp, intent, successCallback, failureCallback, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> changeVersionCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
Database* imp = V8Database::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, oldVersion, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, newVersion, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
RefPtr<SQLTransactionCallback> callback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
callback = V8SQLTransactionCallback::create(args[2], getScriptExecutionContext());
}
RefPtr<SQLTransactionErrorCallback> errorCallback;
if (args.Length() > 3 && !args[3]->IsNull() && !args[3]->IsUndefined()) {
if (!args[3]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8SQLTransactionErrorCallback::create(args[3], getScriptExecutionContext());
}
RefPtr<VoidCallback> successCallback;
if (args.Length() > 4 && !args[4]->IsNull() && !args[4]->IsUndefined()) {
if (!args[4]->IsFunction())
return throwTypeError(0, args.GetIsolate());
successCallback = V8VoidCallback::create(args[4], getScriptExecutionContext());
}
imp->changeVersion(oldVersion, newVersion, callback, errorCallback, successCallback);
return v8Undefined();
}
static v8::Handle<v8::Value> readAsTextCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
FileReaderSync* imp = V8FileReaderSync::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
if (args.Length() <= 1) {
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
String result = imp->readAsText(scriptContext, blob, ec);
if (UNLIKELY(ec))
goto fail;
return v8String(result, args.GetIsolate());
}
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, encoding, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
String result = imp->readAsText(scriptContext, blob, encoding, ec);
if (UNLIKELY(ec))
goto fail;
return v8String(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8TestInterface::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestInterface.Constructor");
if (!args.IsConstructCall())
return throwError("DOM object constructor cannot be called as a function.", V8Proxy::TypeError);
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::TypeError);
ExceptionCode ec = 0;
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str1, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str2, MAYBE_MISSING_PARAMETER(args, 1, MissingIsUndefined));
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return throwError("TestInterface constructor's associated context is not available", V8Proxy::ReferenceError);
RefPtr<TestInterface> obj = TestInterface::create(context, str1, str2, ec);
if (ec)
goto fail;
V8DOMWrapper::setDOMWrapper(args.Holder(), &info, obj.get());
obj->ref();
V8DOMWrapper::setJSWrapperForActiveDOMObject(obj.get(), v8::Persistent<v8::Object>::New(args.Holder()));
return args.Holder();
fail:
return throwError(ec);
}
v8::Handle<v8::Value> V8WebKitMutationObserver::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.WebKitMutationObserver.Constructor");
if (!args.IsConstructCall())
return V8Proxy::throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
if (args.Length() < 1)
return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
v8::Local<v8::Value> arg = args[0];
if (!arg->IsObject())
return throwError(TYPE_MISMATCH_ERR, args.GetIsolate());
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return V8Proxy::throwError(V8Proxy::ReferenceError, "WebKitMutationObserver constructor's associated frame unavailable", args.GetIsolate());
RefPtr<MutationCallback> callback = V8MutationCallback::create(arg, context);
RefPtr<WebKitMutationObserver> observer = WebKitMutationObserver::create(callback.release());
V8DOMWrapper::setDOMWrapper(args.Holder(), &info, observer.get());
V8DOMWrapper::setJSWrapperForDOMObject(observer.release(), v8::Persistent<v8::Object>::New(args.Holder()));
return args.Holder();
}
ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions)
{
ScriptScope scope(m_scriptState, reportExceptions);
v8::Handle<v8::Object> thisObject = m_thisObject.v8Object();
v8::Local<v8::Value> value = thisObject->Get(v8String(m_name, m_scriptState->isolate()));
if (!scope.success()) {
hadException = true;
return ScriptValue();
}
ASSERT(value->IsFunction());
v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(value);
OwnArrayPtr<v8::Handle<v8::Value> > args = adoptArrayPtr(new v8::Handle<v8::Value>[m_arguments.size()]);
for (size_t i = 0; i < m_arguments.size(); ++i) {
args[i] = m_arguments[i].v8Value();
ASSERT(!args[i].IsEmpty());
}
v8::Local<v8::Value> result = V8ScriptRunner::callFunction(function, getScriptExecutionContext(), thisObject, m_arguments.size(), args.get());
if (!scope.success()) {
hadException = true;
return ScriptValue();
}
return ScriptValue(result);
}
static v8::Handle<v8::Value> webkitGetUserMediaCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
Navigator* imp = V8Navigator::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Dictionary, options, Dictionary(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined), args.GetIsolate()));
if (!options.isUndefinedOrNull() && !options.isObject())
return throwTypeError("Not an object.", args.GetIsolate());
if (args.Length() <= 1 || !args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
RefPtr<NavigatorUserMediaSuccessCallback> successCallback = V8NavigatorUserMediaSuccessCallback::create(args[1], getScriptExecutionContext());
RefPtr<NavigatorUserMediaErrorCallback> errorCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8NavigatorUserMediaErrorCallback::create(args[2], getScriptExecutionContext());
}
NavigatorMediaStream::webkitGetUserMedia(imp, options, successCallback, errorCallback, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
void reportException(ScriptState* scriptState, v8::TryCatch& exceptionCatcher)
{
String errorMessage;
int lineNumber = 0;
String sourceURL;
// There can be a situation that an exception is thrown without setting a message.
v8::Local<v8::Message> message = exceptionCatcher.Message();
if (message.IsEmpty()) {
v8::Local<v8::String> exceptionString = exceptionCatcher.Exception()->ToString();
// Conversion of the exception object to string can fail if an
// exception is thrown during conversion.
if (!exceptionString.IsEmpty())
errorMessage = toWebCoreString(exceptionString);
} else {
errorMessage = toWebCoreString(message->Get());
lineNumber = message->GetLineNumber();
sourceURL = toWebCoreString(message->GetScriptResourceName());
}
// Do not report the exception if the current execution context is Document because we do not want to lead to duplicate error messages in the console.
// FIXME (31171): need better design to solve the duplicate error message reporting problem.
ScriptExecutionContext* context = getScriptExecutionContext(scriptState);
// During the frame teardown, there may not be a valid context.
if (context && !context->isDocument())
context->reportException(errorMessage, lineNumber, sourceURL);
exceptionCatcher.Reset();
}
String V8CustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
v8::Handle<v8::Function> lookupNamespaceURIFunc;
v8::Handle<v8::String> lookupNamespaceURIName = v8::String::New("lookupNamespaceURI");
// Check if the resolver has a function property named lookupNamespaceURI.
if (m_resolver->Has(lookupNamespaceURIName)) {
v8::Handle<v8::Value> lookupNamespaceURI = m_resolver->Get(lookupNamespaceURIName);
if (lookupNamespaceURI->IsFunction())
lookupNamespaceURIFunc = v8::Handle<v8::Function>::Cast(lookupNamespaceURI);
}
if (lookupNamespaceURIFunc.IsEmpty() && !m_resolver->IsFunction()) {
if (ScriptExecutionContext* context = getScriptExecutionContext())
context->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.", 0, String(), 0);
return String();
}
// Catch exceptions from calling the namespace resolver.
v8::TryCatch try_catch;
try_catch.SetVerbose(true); // Print exceptions to console.
const int argc = 1;
v8::Handle<v8::Value> argv[argc] = { v8String(prefix) };
v8::Handle<v8::Function> function = lookupNamespaceURIFunc.IsEmpty() ? v8::Handle<v8::Function>::Cast(m_resolver) : lookupNamespaceURIFunc;
v8::Handle<v8::Value> retval = V8Proxy::instrumentedCallFunction(0 /* page */, function, m_resolver, argc, argv);
// Eat exceptions from namespace resolver and return an empty string. This will most likely cause NAMESPACE_ERR.
if (try_catch.HasCaught())
return String();
return toWebCoreStringWithNullCheck(retval);
}
static void messageHandlerInWorker(v8::Handle<v8::Message> message, v8::Handle<v8::Value> data)
{
static bool isReportingException = false;
// Exceptions that occur in error handler should be ignored since in that case
// WorkerGlobalScope::reportException will send the exception to the worker object.
if (isReportingException)
return;
isReportingException = true;
// During the frame teardown, there may not be a valid context.
if (ScriptExecutionContext* context = getScriptExecutionContext()) {
String errorMessage = toWebCoreString(message->Get());
String sourceURL = toWebCoreString(message->GetScriptResourceName());
RefPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, sourceURL, message->GetLineNumber(), message->GetStartColumn());
v8::Local<v8::Value> wrappedEvent = toV8(event.get(), v8::Handle<v8::Object>(), v8::Isolate::GetCurrent());
if (!wrappedEvent.IsEmpty()) {
ASSERT(wrappedEvent->IsObject());
v8::Local<v8::Object>::Cast(wrappedEvent)->SetHiddenValue(V8HiddenPropertyName::error(), data);
}
AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
context->reportException(event.release(), 0, corsStatus);
}
isReportingException = false;
}
static v8::Handle<v8::Value> openDatabaseSyncCallback(const v8::Arguments& args)
{
INC_STATS("DOM.WorkerContext.openDatabaseSync");
if (args.Length() < 4)
return throwError("Not enough arguments", V8Proxy::SyntaxError);
WorkerContext* imp = V8WorkerContext::toNative(args.Holder());
ExceptionCode ec = 0;
{
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, name, args[0]);
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, version, args[1]);
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, displayName, args[2]);
EXCEPTION_BLOCK(unsigned, estimatedSize, toUInt32(args[3]));
RefPtr<DatabaseCallback> creationCallback;
if (args.Length() > 4 && !args[4]->IsNull() && !args[4]->IsUndefined()) {
if (!args[4]->IsObject())
return throwError(TYPE_MISMATCH_ERR);
creationCallback = V8DatabaseCallback::create(args[4], getScriptExecutionContext());
}
RefPtr<DatabaseSync> result = imp->openDatabaseSync(name, version, displayName, estimatedSize, creationCallback, ec);
if (UNLIKELY(ec))
goto fail;
return toV8(result.release());
}
fail:
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
v8::Handle<v8::Value> V8XMLHttpRequest::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.XMLHttpRequest.Constructor");
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
// Expect no parameters.
// Allocate a XMLHttpRequest object as its internal field.
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return throwError(ReferenceError, "XMLHttpRequest constructor's associated context is not available", args.GetIsolate());
RefPtr<SecurityOrigin> securityOrigin;
if (V8IsolatedContext* isolatedContext = V8IsolatedContext::getEntered())
securityOrigin = isolatedContext->securityOrigin();
RefPtr<XMLHttpRequest> xmlHttpRequest = XMLHttpRequest::create(context, securityOrigin);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::setDOMWrapper(wrapper, &info, xmlHttpRequest.get());
V8DOMWrapper::setJSWrapperForActiveDOMObject(xmlHttpRequest.release(), wrapper);
return wrapper;
}
v8::Handle<v8::Value> V8MutationObserver::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.MutationObserver.Constructor");
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
v8::Local<v8::Value> arg = args[0];
if (!arg->IsObject())
return setDOMException(TYPE_MISMATCH_ERR, args.GetIsolate());
ScriptExecutionContext* context = getScriptExecutionContext();
RefPtr<MutationCallback> callback = V8MutationCallback::create(arg, context);
RefPtr<MutationObserver> observer = MutationObserver::create(callback.release());
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::setDOMWrapper(wrapper, &info, observer.get());
V8DOMWrapper::setJSWrapperForDOMObject(observer.release(), wrapper);
return wrapper;
}
ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions)
{
ScriptScope scope(m_scriptState, reportExceptions);
v8::Local<v8::Object> thisObject = m_thisObject.v8Object();
v8::Local<v8::Value> value = thisObject->Get(v8String(m_name));
if (!scope.success()) {
hadException = true;
return ScriptValue();
}
ASSERT(value->IsFunction());
v8::Local<v8::Function> function(v8::Function::Cast(*value));
OwnArrayPtr<v8::Handle<v8::Value> > args = adoptArrayPtr(new v8::Handle<v8::Value>[m_arguments.size()]);
for (size_t i = 0; i < m_arguments.size(); ++i)
args[i] = m_arguments[i].v8Value();
v8::Local<v8::Value> result;
{
V8RecursionScope innerScope(getScriptExecutionContext());
result = function->Call(thisObject, m_arguments.size(), args.get());
}
if (!scope.success()) {
hadException = true;
return ScriptValue();
}
return ScriptValue(result);
}
v8::Handle<v8::Value> V8MessageChannel::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.MessageChannel.Constructor");
// FIXME: The logic here is almost exact duplicate of V8::constructDOMObject.
// Consider refactoring to reduce duplication.
if (!args.IsConstructCall())
return throwError("DOM object constructor cannot be called as a function.");
// Get the ScriptExecutionContext (WorkerContext or Document)
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return v8::Undefined();
// Note: it's OK to let this RefPtr go out of scope because we also call
// SetDOMWrapper(), which effectively holds a reference to obj.
RefPtr<MessageChannel> obj = MessageChannel::create(context);
v8::Local<v8::Object> messageChannel = args.Holder();
// Create references from the MessageChannel wrapper to the two
// MessagePort wrappers to make sure that the MessagePort wrappers
// stay alive as long as the MessageChannel wrapper is around.
// CAPPFIX_WEB_WEBWORKERS_START
V8DOMWrapper::setNamedHiddenReference(messageChannel, "port1", toV8(obj->port1()));
V8DOMWrapper::setNamedHiddenReference(messageChannel, "port2", toV8(obj->port2()));
// CAPPFIX_WEB_WEBWORKERS_END
// Setup the standard wrapper object internal fields.
V8DOMWrapper::setDOMWrapper(messageChannel, &info, obj.get());
return toV8(obj.release(), messageChannel);
}
static v8::Handle<v8::Value> fileCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
FileEntry* imp = V8FileEntry::toNative(args.Holder());
if (args.Length() <= 0 || !args[0]->IsFunction())
return throwTypeError(0, args.GetIsolate());
RefPtr<FileCallback> successCallback = V8FileCallback::create(args[0], getScriptExecutionContext());
RefPtr<ErrorCallback> errorCallback;
if (args.Length() > 1 && !args[1]->IsNull() && !args[1]->IsUndefined()) {
if (!args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8ErrorCallback::create(args[1], getScriptExecutionContext());
}
imp->file(successCallback, errorCallback);
return v8Undefined();
}
void injectInternalsObject(v8::Local<v8::Context> context)
{
v8::Context::Scope contextScope(context);
v8::HandleScope scope;
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
if (scriptContext->isDocument())
context->Global()->Set(v8::String::New(Internals::internalsId), toV8(Internals::create(static_cast<Document*>(scriptContext))));
}
PassRefPtr<ScriptCallStack> createScriptCallStackForConsole(size_t maxStackSize)
{
size_t stackSize = 1;
if (InspectorInstrumentation::hasFrontends()) {
ScriptExecutionContext* scriptExecutionContext = getScriptExecutionContext();
if (InspectorInstrumentation::consoleAgentEnabled(scriptExecutionContext))
stackSize = maxStackSize;
}
return createScriptCallStack(stackSize);
}
bool Dictionary::get(const String& key, RefPtr<VoidCallback>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
if (!v8Value->IsFunction())
return false;
value = V8VoidCallback::create(v8Value, getScriptExecutionContext());
return true;
}
static v8::Handle<v8::Value> queryUsageAndQuotaCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
StorageInfo* imp = V8StorageInfo::toNative(args.Holder());
V8TRYCATCH(int, storageType, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
RefPtr<StorageInfoUsageCallback> usageCallback;
if (args.Length() > 1 && !args[1]->IsNull() && !args[1]->IsUndefined()) {
if (!args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
usageCallback = V8StorageInfoUsageCallback::create(args[1], getScriptExecutionContext());
}
RefPtr<StorageInfoErrorCallback> errorCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8StorageInfoErrorCallback::create(args[2], getScriptExecutionContext());
}
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
imp->queryUsageAndQuota(scriptContext, storageType, usageCallback, errorCallback);
return v8Undefined();
}
v8::Handle<v8::Value> V8Notification::requestPermissionCallback(const v8::Arguments& args)
{
INC_STATS(L"DOM.Notification.requestPermission");
bool succeeded = false;
RefPtr<V8NotificationPermissionCallback> callback = createFunctionOnlyCallback<V8NotificationPermissionCallback>(args[0], succeeded, args.GetIsolate());
if (!succeeded)
return v8::Undefined();
ASSERT(callback);
Notification::requestPermission(getScriptExecutionContext(), callback.release());
return v8::Undefined();
}
static v8::Handle<v8::Value> transactionCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Database* imp = V8Database::toNative(args.Holder());
if (args.Length() <= 0 || !args[0]->IsFunction())
return throwTypeError(0, args.GetIsolate());
RefPtr<SQLTransactionCallback> callback = V8SQLTransactionCallback::create(args[0], getScriptExecutionContext());
RefPtr<SQLTransactionErrorCallback> errorCallback;
if (args.Length() > 1 && !args[1]->IsNull() && !args[1]->IsUndefined()) {
if (!args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8SQLTransactionErrorCallback::create(args[1], getScriptExecutionContext());
}
RefPtr<VoidCallback> successCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
successCallback = V8VoidCallback::create(args[2], getScriptExecutionContext());
}
imp->transaction(callback, errorCallback, successCallback);
return v8Undefined();
}
static v8::Handle<v8::Value> requestQuotaCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
StorageInfo* imp = V8StorageInfo::toNative(args.Holder());
V8TRYCATCH(int, storageType, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
V8TRYCATCH(unsigned long long, newQuotaInBytes, toInt64(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
RefPtr<StorageInfoQuotaCallback> quotaCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
quotaCallback = V8StorageInfoQuotaCallback::create(args[2], getScriptExecutionContext());
}
RefPtr<StorageInfoErrorCallback> errorCallback;
if (args.Length() > 3 && !args[3]->IsNull() && !args[3]->IsUndefined()) {
if (!args[3]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8StorageInfoErrorCallback::create(args[3], getScriptExecutionContext());
}
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
imp->requestQuota(scriptContext, storageType, newQuotaInBytes, quotaCallback, errorCallback);
return v8Undefined();
}
void resetInternalsObject(v8::Local<v8::Context> context)
{
// This can happen if JavaScript is disabled in the main frame.
if (context.IsEmpty())
return;
v8::Context::Scope contextScope(context);
v8::HandleScope scope;
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
ASSERT(scriptContext->isDocument());
Page* page = static_cast<Document*>(scriptContext)->frame()->page();
Internals::resetToConsistentState(page);
InternalSettings::from(page)->resetToConsistentState();
}
v8::Handle<v8::Value> V8XMLHttpRequest::constructorCustom(const v8::Arguments& args)
{
ScriptExecutionContext* context = getScriptExecutionContext();
RefPtr<SecurityOrigin> securityOrigin;
if (context->isDocument()) {
if (DOMWrapperWorld* world = isolatedWorldForEnteredContext())
securityOrigin = world->isolatedWorldSecurityOrigin();
}
RefPtr<XMLHttpRequest> xmlHttpRequest = XMLHttpRequest::create(context, securityOrigin);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(xmlHttpRequest.release(), &info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
static v8::Handle<v8::Value> readAsArrayBufferCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
FileReaderSync* imp = V8FileReaderSync::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
RefPtr<ArrayBuffer> result = imp->readAsArrayBuffer(scriptContext, blob, ec);
if (UNLIKELY(ec))
goto fail;
return toV8(result.release(), args.Holder(), args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8MessageChannel::constructorCustom(const v8::Arguments& args)
{
ScriptExecutionContext* context = getScriptExecutionContext();
RefPtr<MessageChannel> obj = MessageChannel::create(context);
v8::Local<v8::Object> wrapper = args.Holder();
// Create references from the MessageChannel wrapper to the two
// MessagePort wrappers to make sure that the MessagePort wrappers
// stay alive as long as the MessageChannel wrapper is around.
V8HiddenPropertyName::setNamedHiddenReference(wrapper, "port1", toV8(obj->port1(), args.Holder(), args.GetIsolate()));
V8HiddenPropertyName::setNamedHiddenReference(wrapper, "port2", toV8(obj->port2(), args.Holder(), args.GetIsolate()));
V8DOMWrapper::associateObjectWithWrapper(obj.release(), &info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
v8::Handle<v8::Value> V8XMLHttpRequest::openCallback(const v8::Arguments& args)
{
INC_STATS("DOM.XMLHttpRequest.open()");
// Four cases:
// open(method, url)
// open(method, url, async)
// open(method, url, async, user)
// open(method, url, async, user, passwd)
if (args.Length() < 2)
return throwError("Not enough arguments", V8Proxy::SyntaxError);
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(args.Holder());
String method = toWebCoreString(args[0]);
String urlstring = toWebCoreString(args[1]);
ScriptExecutionContext* context = getScriptExecutionContext();
if (!context)
return v8::Undefined();
KURL url = context->completeURL(urlstring);
ExceptionCode ec = 0;
if (args.Length() >= 3) {
bool async = args[2]->BooleanValue();
if (args.Length() >= 4 && !args[3]->IsUndefined()) {
String user = toWebCoreStringWithNullCheck(args[3]);
if (args.Length() >= 5 && !args[4]->IsUndefined()) {
String passwd = toWebCoreStringWithNullCheck(args[4]);
xmlHttpRequest->open(method, url, async, user, passwd, ec);
} else
xmlHttpRequest->open(method, url, async, user, ec);
} else
xmlHttpRequest->open(method, url, async, ec);
} else
xmlHttpRequest->open(method, url, ec);
if (ec)
return throwError(ec);
return v8::Undefined();
}
v8::Handle<v8::Value> V8MutationObserver::constructorCallbackCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
v8::Local<v8::Value> arg = args[0];
if (!arg->IsObject())
return setDOMException(TYPE_MISMATCH_ERR, args.GetIsolate());
ScriptExecutionContext* context = getScriptExecutionContext();
v8::Handle<v8::Object> wrapper = args.Holder();
RefPtr<MutationCallback> callback = V8MutationCallback::create(arg, context, wrapper, args.GetIsolate());
RefPtr<MutationObserver> observer = MutationObserver::create(callback.release());
V8DOMWrapper::associateObjectWithWrapper(observer.release(), &info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
static v8::Handle<v8::Value> supplementalMethod2Callback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestInterface* imp = V8TestInterface::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
RefPtr<TestObj> result = TestSupplemental::supplementalMethod2(scriptContext, imp, strArg, objArg, ec);
if (UNLIKELY(ec))
goto fail;
return toV8(result.release(), args.Holder(), args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}