ScriptPromise ScriptPromise::then(v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected)
{
if (m_promise.isEmpty())
return ScriptPromise();
v8::Local<v8::Object> promise = m_promise.v8Value().As<v8::Object>();
ASSERT(promise->IsPromise());
// Return this Promise if no handlers are given.
// In fact it is not the exact bahavior of Promise.prototype.then
// but that is not a problem in this case.
v8::Local<v8::Promise> resultPromise = promise.As<v8::Promise>();
if (!onFulfilled.IsEmpty()) {
resultPromise = resultPromise->Then(onFulfilled);
if (resultPromise.IsEmpty()) {
// v8::Promise::Then may return an empty value, for example when
// the stack is exhausted.
return ScriptPromise();
}
}
if (!onRejected.IsEmpty())
resultPromise = resultPromise->Catch(onRejected);
return ScriptPromise(m_scriptState.get(), resultPromise);
}
// Add a tuple (|derivedPromise|, |onFulfilled|, |onRejected|) to
// |internal|'s derived array.
// |internal| must be a Promise internal object.
// |derivedPromise| must be a Promise instance.
// |onFulfilled| and |onRejected| can be an empty value respectively.
void addToDerived(v8::Handle<v8::Object> internal, v8::Handle<v8::Object> derivedPromise, v8::Handle<v8::Function> onFulfilled, v8::Handle<v8::Function> onRejected, v8::Isolate* isolate)
{
v8::Local<v8::Array> fulfillCallbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
v8::Local<v8::Array> rejectCallbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
v8::Local<v8::Array> derivedPromises = internal->GetInternalField(V8PromiseCustom::InternalDerivedPromiseIndex).As<v8::Array>();
if (onFulfilled.IsEmpty()) {
fulfillCallbacks->Set(fulfillCallbacks->Length(), v8::Undefined(isolate));
} else {
fulfillCallbacks->Set(fulfillCallbacks->Length(), onFulfilled);
}
if (onRejected.IsEmpty()) {
rejectCallbacks->Set(rejectCallbacks->Length(), v8::Undefined(isolate));
} else {
rejectCallbacks->Set(rejectCallbacks->Length(), onRejected);
}
ASSERT(!derivedPromise.IsEmpty());
derivedPromises->Set(derivedPromises->Length(), derivedPromise);
// Since they are treated as a tuple,
// we need to guaranteed that the length of these arrays are same.
ASSERT(fulfillCallbacks->Length() == rejectCallbacks->Length() && rejectCallbacks->Length() == derivedPromises->Length());
}
v8::Local<v8::Value> WorkerContextExecutionProxy::runScript(v8::Handle<v8::Script> script)
{
if (script.IsEmpty())
return v8::Local<v8::Value>();
// Compute the source string and prevent against infinite recursion.
if (m_recursion >= kMaxRecursionDepth) {
v8::Local<v8::String> code = v8ExternalString("throw RangeError('Recursion too deep')");
script = V8Proxy::compileScript(code, "", 0);
}
if (V8Proxy::handleOutOfMemory())
ASSERT(script.IsEmpty());
if (script.IsEmpty())
return v8::Local<v8::Value>();
// Run the script and keep track of the current recursion depth.
v8::Local<v8::Value> result;
{
m_recursion++;
result = script->Run();
m_recursion--;
}
// Handle V8 internal error situation (Out-of-memory).
if (result.IsEmpty())
return v8::Local<v8::Value>();
return result;
}
v8::Local<v8::Value> V8Proxy::runScriptInternal(v8::Handle<v8::Script> script, bool isInlineCode)
#endif
{
if (script.IsEmpty())
return notHandledByInterceptor();
V8GCController::checkMemoryUsage();
// Compute the source string and prevent against infinite recursion.
if (m_recursion >= kMaxRecursionDepth) {
v8::Local<v8::String> code = v8ExternalString("throw RangeError('Recursion too deep')");
// FIXME: Ideally, we should be able to re-use the origin of the
// script passed to us as the argument instead of using an empty string
// and 0 baseLine.
script = compileScript(code, "", 0);
}
if (handleOutOfMemory())
ASSERT(script.IsEmpty());
if (script.IsEmpty())
return notHandledByInterceptor();
// Save the previous value of the inlineCode flag and update the flag for
// the duration of the script invocation.
bool previousInlineCode = inlineCode();
setInlineCode(isInlineCode);
// Run the script and keep track of the current recursion depth.
v8::Local<v8::Value> result;
{
V8ConsoleMessage::Scope scope;
// See comment in V8Proxy::callFunction.
m_frame->keepAlive();
m_recursion++;
result = script->Run();
m_recursion--;
}
// Release the storage mutex if applicable.
releaseStorageMutex();
if (handleOutOfMemory())
ASSERT(result.IsEmpty());
// Handle V8 internal error situation (Out-of-memory).
if (result.IsEmpty())
return notHandledByInterceptor();
// Restore inlineCode flag.
setInlineCode(previousInlineCode);
if (v8::V8::IsDead())
handleFatalErrorInV8();
return result;
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame)
{
m_dialogContext = V8Proxy::context(dialogFrame->frame());
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8::String::New("dialogArguments"), m_dialogArguments);
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame)
{
m_dialogContext = dialogFrame->frame() ? dialogFrame->frame()->script()->currentWorldContext() : v8::Local<v8::Context>();
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8::String::NewSymbol("dialogArguments"), m_dialogArguments);
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame, v8::Isolate* isolate)
{
// FIXME: It's wrong to use the current world. Instead we should use the world
// from which the modal dialog was requested.
m_dialogContext = dialogFrame->frame() ? toV8Context(isolate, dialogFrame->frame(), DOMWrapperWorld::current(isolate)) : v8::Local<v8::Context>();
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8AtomicString(isolate, "dialogArguments"), m_dialogArguments);
}
String DebuggerAgentImpl::executeUtilityFunction(
v8::Handle<v8::Context> context,
int callId,
const char* object,
const String &functionName,
const String& jsonArgs,
bool async,
String* exception)
{
v8::HandleScope scope;
ASSERT(!context.IsEmpty());
if (context.IsEmpty()) {
*exception = "No window context.";
return "";
}
v8::Context::Scope contextScope(context);
DebuggerAgentManager::UtilityContextScope utilityScope;
v8::Handle<v8::Object> dispatchObject = v8::Handle<v8::Object>::Cast(
context->Global()->Get(v8::String::New(object)));
v8::Handle<v8::Value> dispatchFunction = dispatchObject->Get(v8::String::New("dispatch"));
ASSERT(dispatchFunction->IsFunction());
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
v8::Handle<v8::String> functionNameWrapper = v8::Handle<v8::String>(
v8::String::New(functionName.utf8().data()));
v8::Handle<v8::String> jsonArgsWrapper = v8::Handle<v8::String>(
v8::String::New(jsonArgs.utf8().data()));
v8::Handle<v8::Number> callIdWrapper = v8::Handle<v8::Number>(
v8::Number::New(async ? callId : 0));
v8::Handle<v8::Value> args[] = {
functionNameWrapper,
jsonArgsWrapper,
callIdWrapper
};
v8::TryCatch tryCatch;
v8::Handle<v8::Value> resObj = function->Call(context->Global(), 3, args);
if (tryCatch.HasCaught()) {
v8::Local<v8::Message> message = tryCatch.Message();
if (message.IsEmpty())
*exception = "Unknown exception";
else
*exception = WebCore::toWebCoreString(message->Get());
return "";
}
return WebCore::toWebCoreStringWithNullCheck(resObj);
}
v8::Local<v8::Value> ScriptRunner::runCompiledScript(v8::Handle<v8::Script> script, ScriptExecutionContext* context)
{
if (script.IsEmpty())
return v8::Local<v8::Value>();
V8GCController::checkMemoryUsage();
if (V8RecursionScope::recursionLevel() >= kMaxRecursionDepth)
return handleMaxRecursionDepthExceeded();
if (handleOutOfMemory())
return v8::Local<v8::Value>();
// Run the script and keep track of the current recursion depth.
v8::Local<v8::Value> result;
{
V8RecursionScope recursionScope(context);
result = script->Run();
}
if (handleOutOfMemory())
ASSERT(result.IsEmpty());
if (result.IsEmpty())
return v8::Local<v8::Value>();
crashIfV8IsDead();
return result;
}
v8::Handle<v8::Object> CustomElementWrapper<ElementType, WrapperType>::wrap(PassRefPtrWillBeRawPtr<ElementType> element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate, v8::Handle<v8::Object> (*createSpecificWrapper)(ElementType* element, v8::Handle<v8::Object> creationContext, v8::Isolate*))
{
ASSERT(DOMDataStore::getWrapper<V8Element>(element.get(), isolate).IsEmpty());
// FIXME: creationContext.IsEmpty() should never happen. Remove
// this when callers (like InspectorController::inspect) are fixed
// to never pass an empty creation context.
v8::Handle<v8::Context> context = creationContext.IsEmpty() ? isolate->GetCurrentContext() : creationContext->CreationContext();
if (!element->isUpgradedCustomElement() || DOMWrapperWorld::world(context).isIsolatedWorld())
return createUpgradeCandidateWrapper(element.get(), creationContext, isolate, createSpecificWrapper);
V8PerContextData* perContextData = V8PerContextData::from(context);
if (!perContextData)
return v8::Handle<v8::Object>();
CustomElementBinding* binding = perContextData->customElementBinding(element->customElementDefinition());
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, binding->wrapperType(), element.get(), isolate);
if (wrapper.IsEmpty())
return v8::Handle<v8::Object>();
wrapper->SetPrototype(binding->prototype());
V8DOMWrapper::associateObjectWithWrapper<WrapperType>(element, binding->wrapperType(), wrapper, isolate, WrapperConfiguration::Dependent);
return wrapper;
}
static CustomElementLifecycleCallbacks::CallbackType flagSet(v8::Handle<v8::Function> attached, v8::Handle<v8::Function> detached, v8::Handle<v8::Function> attributeChanged)
{
// V8 Custom Elements always run created to swizzle prototypes.
int flags = CustomElementLifecycleCallbacks::Created;
if (!attached.IsEmpty())
flags |= CustomElementLifecycleCallbacks::Attached;
if (!detached.IsEmpty())
flags |= CustomElementLifecycleCallbacks::Detached;
if (!attributeChanged.IsEmpty())
flags |= CustomElementLifecycleCallbacks::AttributeChanged;
return CustomElementLifecycleCallbacks::CallbackType(flags);
}
v8::Local<v8::Value> V8ScriptRunner::runCompiledScript(v8::Handle<v8::Script> script, ExecutionContext* context, v8::Isolate* isolate)
{
TRACE_EVENT0("v8", "v8.run");
TRACE_EVENT_SCOPED_SAMPLING_STATE("V8", "V8Execution");
if (script.IsEmpty())
return v8::Local<v8::Value>();
if (V8RecursionScope::recursionLevel(isolate) >= kMaxRecursionDepth)
return handleMaxRecursionDepthExceeded(isolate);
RELEASE_ASSERT(!context->isIteratingOverObservers());
// Run the script and keep track of the current recursion depth.
v8::Local<v8::Value> result;
{
V8RecursionScope recursionScope(isolate, context);
result = script->Run();
}
if (result.IsEmpty())
return v8::Local<v8::Value>();
crashIfV8IsDead();
return result;
}
static CustomElementLifecycleCallbacks::CallbackType flagSet(v8::Handle<v8::Function> enteredView, v8::Handle<v8::Function> leftView, v8::Handle<v8::Function> attributeChanged)
{
// V8 Custom Elements always run created to swizzle prototypes.
int flags = CustomElementLifecycleCallbacks::Created;
if (!enteredView.IsEmpty())
flags |= CustomElementLifecycleCallbacks::EnteredView;
if (!leftView.IsEmpty())
flags |= CustomElementLifecycleCallbacks::LeftView;
if (!attributeChanged.IsEmpty())
flags |= CustomElementLifecycleCallbacks::AttributeChanged;
return CustomElementLifecycleCallbacks::CallbackType(flags);
}
void JS_SetPrivate(IJS_Runtime* pJSRuntime, v8::Handle<v8::Object> pObj, void* p)
{
if(pObj.IsEmpty() || !pObj->InternalFieldCount()) return;
CJS_PrivateData* pPrivateData = (CJS_PrivateData*)pObj->GetAlignedPointerFromInternalField(0);
if(!pPrivateData) return;
pPrivateData->pPrivate = p;
}
v8::Local<v8::Signature> V8DOMConfiguration::installDOMClassTemplate(v8::Handle<v8::FunctionTemplate> functionDescriptor, const char* interfaceName, v8::Handle<v8::FunctionTemplate> parentClass, size_t fieldCount,
const AttributeConfiguration* attributes, size_t attributeCount,
const AccessorConfiguration* accessors, size_t accessorCount,
const MethodConfiguration* callbacks, size_t callbackCount,
v8::Isolate* isolate)
{
functionDescriptor->SetClassName(v8AtomicString(isolate, interfaceName));
v8::Local<v8::ObjectTemplate> instanceTemplate = functionDescriptor->InstanceTemplate();
instanceTemplate->SetInternalFieldCount(fieldCount);
if (!parentClass.IsEmpty()) {
functionDescriptor->Inherit(parentClass);
// Marks the prototype object as one of native-backed objects.
// This is needed since bug 110436 asks WebKit to tell native-initiated prototypes from pure-JS ones.
// This doesn't mark kinds "root" classes like Node, where setting this changes prototype chain structure.
v8::Local<v8::ObjectTemplate> prototype = functionDescriptor->PrototypeTemplate();
prototype->SetInternalFieldCount(v8PrototypeInternalFieldcount);
}
v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, functionDescriptor);
if (attributeCount)
installAttributes(instanceTemplate, functionDescriptor->PrototypeTemplate(), attributes, attributeCount, isolate);
if (accessorCount)
installAccessors(functionDescriptor->PrototypeTemplate(), defaultSignature, accessors, accessorCount, isolate);
if (callbackCount)
installCallbacks(functionDescriptor->PrototypeTemplate(), defaultSignature, static_cast<v8::PropertyAttribute>(v8::DontDelete), callbacks, callbackCount, isolate);
return defaultSignature;
}
void CCKeypadDispatcher::removeDelegate(v8::Handle<v8::Object> pDelegate)
{
if (pDelegate.IsEmpty() || pDelegate->IsNull())
{
return;
}
if (! m_bLocked)
{
forceRemoveDelegate(pDelegate);
}
else
{
CCKeypadHandler* pHandler = NULL;
CCObject* pObj = NULL;
void* delegateKey = this->getJSCCallFunc()->getHash(pDelegate);
CCARRAY_FOREACH(m_pDelegates, pObj)
{
pHandler = (CCKeypadHandler*)pObj;
JSKeypadDelegate *keypadDelegate = dynamic_cast<JSKeypadDelegate*>(pHandler);
if (keypadDelegate && this->getJSCCallFunc()->getHash(keypadDelegate->mJSDelegate) == delegateKey)
{
ccCArrayAppendValue(m_pHandlersToRemove, pHandler);
break;
}
}
m_bToRemove = true;
}
v8::Local<v8::Object> V8ObjectConstructor::newInstance(v8::Isolate* isolate, v8::Handle<v8::Function> function, int argc, v8::Handle<v8::Value> argv[])
{
if (function.IsEmpty())
return v8::Local<v8::Object>();
ConstructorMode constructorMode(isolate);
return V8ScriptRunner::instantiateObject(isolate, function, argc, argv);
}
v8::Handle<v8::Object> V8TestNamedConstructor::wrapSlow(PassRefPtr<TestNamedConstructor> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
v8::Handle<v8::Object> wrapper;
Document* document = 0;
UNUSED_PARAM(document);
v8::Handle<v8::Context> context;
if (!creationContext.IsEmpty() && creationContext->CreationContext() != v8::Context::GetCurrent()) {
// For performance, we enter the context only if the currently running context
// is different from the context that we are about to enter.
context = v8::Local<v8::Context>::New(creationContext->CreationContext());
ASSERT(!context.IsEmpty());
context->Enter();
}
wrapper = V8DOMWrapper::instantiateV8Object(document, &info, impl.get());
if (!context.IsEmpty())
context->Exit();
if (UNLIKELY(wrapper.IsEmpty()))
return wrapper;
v8::Persistent<v8::Object> wrapperHandle = V8DOMWrapper::setJSWrapperForActiveDOMObject(impl, wrapper, isolate);
if (!hasDependentLifetime)
wrapperHandle.MarkIndependent();
return wrapper;
}
void QV8Include::callback(QV8Engine *engine, v8::Handle<v8::Function> callback, v8::Handle<v8::Object> status)
{
if (!callback.IsEmpty()) {
v8::Handle<v8::Value> args[] = { status };
v8::TryCatch tc;
callback->Call(engine->global(), 1, args);
}
}
int JS_GetObjDefnID(v8::Handle<v8::Object> pObj)
{
if(pObj.IsEmpty() || !pObj->InternalFieldCount()) return -1;
CJS_PrivateData* pPrivateData = (CJS_PrivateData*)pObj->GetAlignedPointerFromInternalField(0);
if(pPrivateData)
return pPrivateData->ObjDefID;
return -1;
}
ScriptPromise ScriptPromise::reject(ScriptState* scriptState, v8::Handle<v8::Value> value)
{
if (value.IsEmpty())
return ScriptPromise();
InternalResolver resolver(scriptState);
ScriptPromise promise = resolver.promise();
resolver.reject(value);
return promise;
}
ScriptPromise ScriptPromise::reject(ScriptState* scriptState, v8::Handle<v8::Value> value)
{
if (value.IsEmpty())
return ScriptPromise();
RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
resolver->reject(value);
return promise;
}
v8::Local<v8::Promise> ScriptPromise::rejectRaw(v8::Isolate* isolate, v8::Handle<v8::Value> value)
{
if (value.IsEmpty())
return v8::Local<v8::Promise>();
v8::Local<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(isolate);
v8::Local<v8::Promise> promise = resolver->GetPromise();
resolver->Reject(value);
return promise;
}
v8::Local<v8::Object> V8ObjectConstructor::newInstance(v8::Handle<v8::Function> function, int argc, v8::Handle<v8::Value> argv[])
{
if (function.IsEmpty())
return v8::Local<v8::Object>();
ConstructorMode constructorMode;
V8RecursionScope::MicrotaskSuppression scope;
v8::Local<v8::Object> result = function->NewInstance(argc, argv);
crashIfV8IsDead();
return result;
}
v8::Local<v8::Object> V8ObjectConstructor::newInstance(v8::Handle<v8::ObjectTemplate> objectTemplate)
{
if (objectTemplate.IsEmpty())
return v8::Local<v8::Object>();
ConstructorMode constructorMode;
V8RecursionScope::MicrotaskSuppression scope;
v8::Local<v8::Object> result = objectTemplate->NewInstance();
crashIfV8IsDead();
return result;
}
inline v8::Handle<v8::Value> DialogHandler::returnValue(v8::Isolate* isolate) const
{
if (m_dialogContext.IsEmpty())
return v8::Undefined(isolate);
v8::Context::Scope scope(m_dialogContext);
v8::Handle<v8::Value> returnValue = m_dialogContext->Global()->Get(v8AtomicString(isolate, "returnValue"));
if (returnValue.IsEmpty())
return v8::Undefined(isolate);
return returnValue;
}
inline v8::Handle<v8::Value> DialogHandler::returnValue() const
{
if (m_dialogContext.IsEmpty())
return v8::Undefined();
v8::Context::Scope scope(m_dialogContext);
v8::Handle<v8::Value> returnValue = m_dialogContext->Global()->Get(v8::String::NewSymbol("returnValue"));
if (returnValue.IsEmpty())
return v8::Undefined();
return returnValue;
}
v8::Handle<v8::Object> V8PerIsolateData::findInstanceInPrototypeChain(const WrapperTypeInfo* info, v8::Handle<v8::Value> value, DOMTemplateMap& domTemplateMap)
{
if (value.IsEmpty() || !value->IsObject())
return v8::Handle<v8::Object>();
DOMTemplateMap::iterator result = domTemplateMap.find(info);
if (result == domTemplateMap.end())
return v8::Handle<v8::Object>();
v8::Handle<v8::FunctionTemplate> templ = result->value.Get(m_isolate);
return v8::Handle<v8::Object>::Cast(value)->FindInstanceInPrototypeChain(templ);
}
void ExceptionState::setException(v8::Handle<v8::Value> exception)
{
// FIXME: Assert that exception is not empty?
if (exception.IsEmpty()) {
clearException();
return;
}
m_exception.set(m_isolate, exception);
}
v8::Handle<v8::Value> JS_GetListValue(v8::Handle<v8::Value> pList, int index)
{
if(!pList.IsEmpty() && pList->IsObject())
{
v8::Local<v8::Object> obj = pList->ToObject();
return obj->Get(index);
}
return v8::Handle<v8::Value>();
}