void RespondWithObserver::responseWasFulfilled(const ScriptValue& value)
{
ASSERT(executionContext());
if (!V8Response::hasInstance(value.v8Value(), toIsolate(executionContext()))) {
responseWasRejected();
return;
}
Response* response = V8Response::toImplWithTypeCheck(toIsolate(executionContext()), value.v8Value());
// "If either |response|'s type is |opaque| and |request|'s mode is not
// |no CORS| or |response|'s type is |error|, return a network error."
const FetchResponseData::Type responseType = response->response()->type();
if ((responseType == FetchResponseData::OpaqueType && m_requestMode != WebURLRequest::FetchRequestModeNoCORS) || responseType == FetchResponseData::ErrorType) {
responseWasRejected();
return;
}
// Treat the opaque response as a network error for frame loading.
if (responseType == FetchResponseData::OpaqueType && m_frameType != WebURLRequest::FrameTypeNone) {
responseWasRejected();
return;
}
WebServiceWorkerResponse webResponse;
response->populateWebServiceWorkerResponse(webResponse);
ServiceWorkerGlobalScopeClient::from(executionContext())->didHandleFetchEvent(m_eventID, webResponse);
m_state = Done;
}
void IDBCursor::continuePrimaryKey(ExecutionContext* context, const ScriptValue& keyValue, const ScriptValue& primaryKeyValue, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::continuePrimaryKey");
RefPtrWillBeRawPtr<IDBKey> key = scriptValueToIDBKey(toIsolate(context), keyValue);
RefPtrWillBeRawPtr<IDBKey> primaryKey = scriptValueToIDBKey(toIsolate(context), primaryKeyValue);
if (!key->isValid() || !primaryKey->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return;
}
continueFunction(key.release(), primaryKey.release(), exceptionState);
}
ScriptPromiseResolver::ScriptPromiseResolver(ExecutionContext* context)
: m_isolate(toIsolate(context))
{
ASSERT(context);
v8::Isolate* isolate = toIsolate(context);
ASSERT(isolate->InContext());
if (RuntimeEnabledFeatures::scriptPromiseOnV8PromiseEnabled()) {
m_resolver = ScriptValue(v8::Promise::Resolver::New(isolate), isolate);
} else {
v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current(isolate));
v8::Handle<v8::Object> creationContext = v8Context.IsEmpty() ? v8::Object::New(isolate) : v8Context->Global();
m_promise = ScriptPromise(V8PromiseCustom::createPromise(creationContext, isolate), isolate);
}
}
void V8CustomElementLifecycleCallbacks::attributeChanged(Element* element, const AtomicString& name, const AtomicString& oldValue, const AtomicString& newValue)
{
if (!canInvokeCallback())
return;
v8::Isolate* isolate = toIsolate(scriptExecutionContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Context> context = toV8Context(scriptExecutionContext(), m_world.get());
if (context.IsEmpty())
return;
v8::Context::Scope scope(context);
v8::Handle<v8::Object> receiver = toV8(element, context->Global(), isolate).As<v8::Object>();
ASSERT(!receiver.IsEmpty());
v8::Handle<v8::Function> callback = m_attributeChanged.newLocal(isolate);
if (callback.IsEmpty())
return;
v8::Handle<v8::Value> argv[] = {
v8String(name, isolate),
oldValue.isNull() ? v8::Handle<v8::Value>(v8::Null(isolate)) : v8::Handle<v8::Value>(v8String(oldValue, isolate)),
newValue.isNull() ? v8::Handle<v8::Value>(v8::Null(isolate)) : v8::Handle<v8::Value>(v8String(newValue, isolate))
};
v8::TryCatch exceptionCatcher;
exceptionCatcher.SetVerbose(true);
ScriptController::callFunctionWithInstrumentation(scriptExecutionContext(), callback, receiver, WTF_ARRAY_LENGTH(argv), argv, isolate);
}
ScriptPromisePropertyBase::ScriptPromisePropertyBase(ExecutionContext* executionContext, Name name)
: ContextLifecycleObserver(executionContext)
, m_isolate(toIsolate(executionContext))
, m_name(name)
, m_state(Pending)
{
}
V8TestCallbackInterface::V8TestCallbackInterface(v8::Handle<v8::Function> callback, ExecutionContext* context)
: ActiveDOMCallback(context)
{
v8::Isolate* isolate = toIsolate(context);
m_callback.set(isolate, callback);
m_scriptState = ScriptState::current(isolate);
}
String InspectorOverlay::evaluateInOverlayForTest(const String& script)
{
ScriptForbiddenScope::AllowUserAgentScript allowScript;
v8::HandleScope handleScope(toIsolate(overlayMainFrame()));
v8::Local<v8::Value> string = toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(script), ScriptController::ExecuteScriptWhenScriptsDisabled);
return toCoreStringWithUndefinedOrNullCheck(string);
}
v8::Local<v8::Value> V8WorkerGlobalScopeEventListener::callListenerFunction(ExecutionContext* context, v8::Handle<v8::Value> jsEvent, Event* event)
{
v8::Local<v8::Function> handlerFunction = getListenerFunction(context);
v8::Local<v8::Object> receiver = getReceiverObject(context, event);
if (handlerFunction.IsEmpty() || receiver.IsEmpty())
return v8::Local<v8::Value>();
InspectorInstrumentationCookie cookie;
if (InspectorInstrumentation::timelineAgentEnabled(context)) {
String resourceName("undefined");
int lineNumber = 1;
v8::Handle<v8::Function> originalFunction = getBoundFunction(handlerFunction);
v8::ScriptOrigin origin = originalFunction->GetScriptOrigin();
if (!origin.ResourceName().IsEmpty()) {
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringResourceName, origin.ResourceName(), v8::Local<v8::Value>());
resourceName = stringResourceName;
lineNumber = originalFunction->GetScriptLineNumber() + 1;
}
cookie = InspectorInstrumentation::willCallFunction(context, resourceName, lineNumber);
}
v8::Isolate* isolate = toIsolate(context);
v8::Handle<v8::Value> parameters[1] = { jsEvent };
v8::Local<v8::Value> result = V8ScriptRunner::callFunction(handlerFunction, context, receiver, WTF_ARRAY_LENGTH(parameters), parameters, isolate);
InspectorInstrumentation::didCallFunction(cookie);
return result;
}
void V8WorkerGlobalScopeEventListener::handleEvent(ExecutionContext* context, Event* event)
{
if (!context)
return;
// The callback function on XMLHttpRequest can clear the event listener and destroys 'this' object. Keep a local reference to it.
// See issue 889829.
RefPtr<V8AbstractEventListener> protect(this);
v8::Isolate* isolate = toIsolate(context);
v8::HandleScope handleScope(isolate);
WorkerScriptController* script = toWorkerGlobalScope(context)->script();
if (!script)
return;
v8::Handle<v8::Context> v8Context = script->context();
if (v8Context.IsEmpty())
return;
// Enter the V8 context in which to perform the event handling.
v8::Context::Scope scope(v8Context);
// Get the V8 wrapper for the event object.
v8::Handle<v8::Value> jsEvent = toV8(event, v8::Handle<v8::Object>(), isolate);
invokeEventHandler(context, event, v8::Local<v8::Value>::New(isolate, jsEvent));
}
V8TestCallbackInterface::V8TestCallbackInterface(v8::Handle<v8::Function> callback, ExecutionContext* context)
: ActiveDOMCallback(context)
, m_isolate(toIsolate(context))
, m_callback(m_isolate, callback)
, m_world(DOMWrapperWorld::current(m_isolate))
{
}
bool eventListenerHandlerLocation(Document* document, EventListener* listener, String& sourceName, String& scriptId, int& lineNumber)
{
if (listener->type() != EventListener::JSEventListenerType)
return false;
v8::HandleScope scope(toIsolate(document));
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::Handle<v8::Context> context = toV8Context(document, v8Listener->world());
v8::Context::Scope contextScope(context);
v8::Local<v8::Object> object = v8Listener->getListenerObject(document);
if (object.IsEmpty())
return false;
v8::Handle<v8::Function> function = eventListenerEffectiveFunction(scope.GetIsolate(), object);
if (function.IsEmpty())
return false;
v8::Handle<v8::Function> originalFunction = getBoundFunction(function);
int scriptIdValue = originalFunction->ScriptId();
scriptId = String::number(scriptIdValue);
v8::ScriptOrigin origin = originalFunction->GetScriptOrigin();
if (!origin.ResourceName().IsEmpty() && origin.ResourceName()->IsString())
sourceName = toCoreString(origin.ResourceName().As<v8::String>());
else
sourceName = "";
lineNumber = originalFunction->GetScriptLineNumber();
return true;
}
ScriptState* ScriptState::forWorld(LocalFrame* frame, DOMWrapperWorld& world)
{
ASSERT(frame);
v8::Isolate* isolate = toIsolate(frame);
v8::HandleScope handleScope(isolate);
return ScriptState::from(toV8ContextEvenIfDetached(frame, world));
}
IDBKeyRange* IDBKeyRange::fromScriptValue(ExecutionContext* context, const ScriptValue& value, ExceptionState& exceptionState)
{
if (value.isUndefined() || value.isNull())
return 0;
IDBKeyRange* range = scriptValueToIDBKeyRange(toIsolate(context), value);
if (range)
return range;
IDBKey* key = scriptValueToIDBKey(toIsolate(context), value);
if (!key || !key->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return new IDBKeyRange(key, key, LowerBoundClosed, UpperBoundClosed);
}
ScriptState* eventListenerHandlerScriptState(Frame* frame, EventListener* listener)
{
if (listener->type() != EventListener::JSEventListenerType)
return 0;
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::HandleScope scope(toIsolate(frame));
v8::Handle<v8::Context> v8Context = frame->script().windowShell(v8Listener->world())->context();
return ScriptState::forContext(v8Context);
}
V8CustomElementLifecycleCallbacks::~V8CustomElementLifecycleCallbacks()
{
if (!m_owner)
return;
v8::HandleScope handleScope(toIsolate(scriptExecutionContext()));
if (V8PerContextData* perContextData = creationContextData())
perContextData->clearCustomElementBinding(m_owner);
}
IDBKeyRange* IDBKeyRange::only(ExecutionContext* context, const ScriptValue& keyValue, ExceptionState& exceptionState)
{
IDBKey* key = scriptValueToIDBKey(toIsolate(context), keyValue);
if (!key || !key->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return IDBKeyRange::create(key, key, LowerBoundClosed, UpperBoundClosed);
}
IDBKeyRange* IDBKeyRange::lowerBound(ExecutionContext* context, const ScriptValue& boundValue, bool open, ExceptionState& exceptionState)
{
IDBKey* bound = scriptValueToIDBKey(toIsolate(context), boundValue);
if (!bound || !bound->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return IDBKeyRange::create(bound, 0, open ? LowerBoundOpen : LowerBoundClosed, UpperBoundOpen);
}
ScriptState* ScriptState::forWorld(LocalFrame* frame, DOMWrapperWorld& world) {
ASSERT(frame);
v8::HandleScope handleScope(toIsolate(frame));
v8::Local<v8::Context> context = toV8Context(frame, world);
if (context.IsEmpty())
return nullptr;
ScriptState* scriptState = ScriptState::from(context);
ASSERT(scriptState->contextIsValid());
return scriptState;
}
ScriptPromise ScriptPromise::createPending(ExecutionContext* context)
{
ASSERT(context);
v8::Isolate* isolate = toIsolate(context);
ASSERT(isolate->InContext());
v8::Handle<v8::Context> v8Context = toV8Context(context, DOMWrapperWorld::current());
v8::Handle<v8::Object> creationContext = v8Context.IsEmpty() ? v8::Object::New(isolate) : v8Context->Global();
v8::Handle<v8::Object> promise = V8PromiseCustom::createPromise(creationContext, isolate);
return ScriptPromise(promise, isolate);
}
IDBKeyRange* IDBKeyRange::bound(ExecutionContext* context, const ScriptValue& lowerValue, const ScriptValue& upperValue, bool lowerOpen, bool upperOpen, ExceptionState& exceptionState)
{
IDBKey* lower = scriptValueToIDBKey(toIsolate(context), lowerValue);
IDBKey* upper = scriptValueToIDBKey(toIsolate(context), upperValue);
if (!lower || !lower->isValid() || !upper || !upper->isValid()) {
exceptionState.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
if (upper->isLessThan(lower)) {
exceptionState.throwDOMException(DataError, "The lower key is greater than the upper key.");
return 0;
}
if (upper->isEqual(lower) && (lowerOpen || upperOpen)) {
exceptionState.throwDOMException(DataError, "The lower key and upper key are equal and one of the bounds is open.");
return 0;
}
return IDBKeyRange::create(lower, upper, lowerOpen ? LowerBoundOpen : LowerBoundClosed, upperOpen ? UpperBoundOpen : UpperBoundClosed);
}
V8CustomElementLifecycleCallbacks::V8CustomElementLifecycleCallbacks(ScriptExecutionContext* scriptExecutionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> enteredView, v8::Handle<v8::Function> leftView, v8::Handle<v8::Function> attributeChanged)
: CustomElementLifecycleCallbacks(flagSet(enteredView, leftView, attributeChanged))
, ActiveDOMCallback(scriptExecutionContext)
, m_world(DOMWrapperWorld::current())
, m_prototype(toIsolate(scriptExecutionContext), prototype)
, m_created(toIsolate(scriptExecutionContext), created)
, m_enteredView(toIsolate(scriptExecutionContext), enteredView)
, m_leftView(toIsolate(scriptExecutionContext), leftView)
, m_attributeChanged(toIsolate(scriptExecutionContext), attributeChanged)
, m_owner(0)
{
m_prototype.makeWeak(&m_prototype, weakCallback<v8::Object>);
#define MAKE_WEAK(Var, _) \
if (!m_##Var.isEmpty()) \
m_##Var.makeWeak(&m_##Var, weakCallback<v8::Function>);
CALLBACK_LIST(MAKE_WEAK)
#undef MAKE_WEAK
}
bool V8GCController::hasPendingActivity(ExecutionContext* executionContext)
{
// V8GCController::hasPendingActivity is used only when a worker checks if
// the worker contains any wrapper that has pending activities.
ASSERT(!isMainThread());
DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, scanPendingActivityHistogram, new CustomCountHistogram("Blink.ScanPendingActivityDuration", 1, 1000, 50));
double startTime = WTF::currentTimeMS();
PendingActivityVisitor visitor(executionContext);
toIsolate(executionContext)->VisitHandlesWithClassIds(&visitor);
scanPendingActivityHistogram.count(static_cast<int>(WTF::currentTimeMS() - startTime));
return visitor.pendingActivityFound();
}
v8::Local<v8::Object> V8WorkerGlobalScopeEventListener::getReceiverObject(ExecutionContext* context, Event* event)
{
v8::Local<v8::Object> listener = getListenerObject(context);
if (!listener.IsEmpty() && !listener->IsFunction())
return listener;
EventTarget* target = event->currentTarget();
v8::Isolate* isolate = toIsolate(context);
v8::Handle<v8::Value> value = toV8(target, v8::Handle<v8::Object>(), isolate);
if (value.IsEmpty())
return v8::Local<v8::Object>();
return v8::Local<v8::Object>::New(isolate, v8::Handle<v8::Object>::Cast(value));
}
PassRefPtr<V8CustomElementLifecycleCallbacks> V8CustomElementLifecycleCallbacks::create(ExecutionContext* executionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> attached, v8::Handle<v8::Function> detached, v8::Handle<v8::Function> attributeChanged)
{
v8::Isolate* isolate = toIsolate(executionContext);
// A given object can only be used as a Custom Element prototype
// once; see customElementIsInterfacePrototypeObject
#define SET_HIDDEN_VALUE(Value, Name) \
ASSERT(V8HiddenValue::getHiddenValue(isolate, prototype, V8HiddenValue::customElement##Name(isolate)).IsEmpty()); \
if (!Value.IsEmpty()) \
V8HiddenValue::setHiddenValue(isolate, prototype, V8HiddenValue::customElement##Name(isolate), Value);
CALLBACK_LIST(SET_HIDDEN_VALUE)
#undef SET_HIDDEN_VALUE
return adoptRef(new V8CustomElementLifecycleCallbacks(executionContext, prototype, created, attached, detached, attributeChanged));
}
PassRefPtr<V8CustomElementLifecycleCallbacks> V8CustomElementLifecycleCallbacks::create(ScriptExecutionContext* scriptExecutionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> enteredView, v8::Handle<v8::Function> leftView, v8::Handle<v8::Function> attributeChanged)
{
v8::Isolate* isolate = toIsolate(scriptExecutionContext);
// A given object can only be used as a Custom Element prototype
// once; see customElementIsInterfacePrototypeObject
#define SET_HIDDEN_PROPERTY(Value, Name) \
ASSERT(prototype->GetHiddenValue(V8HiddenPropertyName::customElement##Name(isolate)).IsEmpty()); \
if (!Value.IsEmpty()) \
prototype->SetHiddenValue(V8HiddenPropertyName::customElement##Name(isolate), Value);
CALLBACK_LIST(SET_HIDDEN_PROPERTY)
#undef SET_HIDDEN_PROPERTY
return adoptRef(new V8CustomElementLifecycleCallbacks(scriptExecutionContext, prototype, created, enteredView, leftView, attributeChanged));
}
ScriptValue eventListenerHandler(Document* document, EventListener* listener)
{
if (listener->type() != EventListener::JSEventListenerType)
return ScriptValue();
v8::Isolate* isolate = toIsolate(document);
v8::HandleScope scope(isolate);
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::Handle<v8::Context> context = toV8Context(document, v8Listener->world());
v8::Context::Scope contextScope(context);
v8::Handle<v8::Object> function = v8Listener->getListenerObject(document);
if (function.IsEmpty())
return ScriptValue();
return ScriptValue(function, isolate);
}
String eventListenerHandlerBody(Document* document, EventListener* listener)
{
if (listener->type() != EventListener::JSEventListenerType)
return "";
v8::HandleScope scope(toIsolate(document));
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener);
v8::Handle<v8::Context> context = toV8Context(document, v8Listener->world());
v8::Context::Scope contextScope(context);
v8::Handle<v8::Object> object = v8Listener->getListenerObject(document);
if (object.IsEmpty())
return "";
v8::Handle<v8::Function> function = eventListenerEffectiveFunction(scope.GetIsolate(), object);
if (function.IsEmpty())
return "";
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, functionString, function, "");
return functionString;
}
V8CustomElementLifecycleCallbacks::V8CustomElementLifecycleCallbacks(ExecutionContext* executionContext, v8::Handle<v8::Object> prototype, v8::Handle<v8::Function> created, v8::Handle<v8::Function> attached, v8::Handle<v8::Function> detached, v8::Handle<v8::Function> attributeChanged)
: CustomElementLifecycleCallbacks(flagSet(attached, detached, attributeChanged))
, ContextLifecycleObserver(executionContext)
, m_owner(0)
, m_scriptState(NewScriptState::current(toIsolate(executionContext)))
, m_prototype(m_scriptState->isolate(), prototype)
, m_created(m_scriptState->isolate(), created)
, m_attached(m_scriptState->isolate(), attached)
, m_detached(m_scriptState->isolate(), detached)
, m_attributeChanged(m_scriptState->isolate(), attributeChanged)
{
m_prototype.setWeak(&m_prototype, weakCallback<v8::Object>);
#define MAKE_WEAK(Var, _) \
if (!m_##Var.isEmpty()) \
m_##Var.setWeak(&m_##Var, weakCallback<v8::Function>);
CALLBACK_LIST(MAKE_WEAK)
#undef MAKE_WEAK
}
void V8AbstractEventListener::handleEvent(ExecutionContext* executionContext, Event* event)
{
if (!executionContext)
return;
// Don't reenter V8 if execution was terminated in this instance of V8.
if (executionContext->isJSExecutionForbidden())
return;
// A ScriptState used by the event listener needs to be calculated based on
// the ExecutionContext that fired the the event listener and the world
// that installed the event listener.
ASSERT(event);
v8::HandleScope handleScope(toIsolate(executionContext));
v8::Local<v8::Context> v8Context = toV8Context(executionContext, world());
if (v8Context.IsEmpty())
return;
ScriptState* scriptState = ScriptState::from(v8Context);
if (!scriptState->contextIsValid())
return;
handleEvent(scriptState, event);
}
void V8CustomElementLifecycleCallbacks::created(Element* element)
{
if (!canInvokeCallback())
return;
element->setCustomElementState(Element::Upgraded);
v8::Isolate* isolate = toIsolate(scriptExecutionContext());
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Context> context = toV8Context(scriptExecutionContext(), m_world.get());
if (context.IsEmpty())
return;
v8::Context::Scope scope(context);
v8::Handle<v8::Object> receiver = DOMDataStore::current(isolate)->get<V8Element>(element, isolate);
if (!receiver.IsEmpty()) {
// Swizzle the prototype of the existing wrapper. We don't need to
// worry about non-existent wrappers; they will get the right
// prototype when wrapped.
v8::Handle<v8::Object> prototype = m_prototype.newLocal(isolate);
if (prototype.IsEmpty())
return;
receiver->SetPrototype(prototype);
}
v8::Handle<v8::Function> callback = m_created.newLocal(isolate);
if (callback.IsEmpty())
return;
if (receiver.IsEmpty())
receiver = toV8(element, context->Global(), isolate).As<v8::Object>();
ASSERT(!receiver.IsEmpty());
v8::TryCatch exceptionCatcher;
exceptionCatcher.SetVerbose(true);
ScriptController::callFunctionWithInstrumentation(scriptExecutionContext(), callback, receiver, 0, 0, isolate);
}