static void V8TestInterfaceNamedConstructor2ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (!info.IsConstructCall()) { V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::constructorNotCallableAsFunction("Audio")); return; } if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::WrapExistingObject) { v8SetReturnValue(info, info.Holder()); return; } if (UNLIKELY(info.Length() < 1)) { V8ThrowException::throwException(createMinimumArityTypeErrorForConstructor(info.GetIsolate(), "TestInterfaceNamedConstructor2", 1, info.Length()), info.GetIsolate()); return; } V8StringResource<> stringArg; { stringArg = info[0]; if (!stringArg.prepare()) return; } RefPtr<TestInterfaceNamedConstructor2> impl = TestInterfaceNamedConstructor2::createForJSConstructor(stringArg); v8::Local<v8::Object> wrapper = info.Holder(); wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceNamedConstructor2Constructor::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); }
static void constructor4(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceConstructor2", info.Holder(), info.GetIsolate()); TestInterfaceEmpty* testInterfaceEmptyArg; int longArg; V8StringResource<> defaultUndefinedOptionalStringArg; V8StringResource<> defaultNullStringOptionalStringArg; Dictionary defaultUndefinedOptionalDictionaryArg; V8StringResource<> optionalStringArg; { int numArgsPassed = info.Length(); while (numArgsPassed > 0) { if (!info[numArgsPassed - 1]->IsUndefined()) break; --numArgsPassed; } testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]); if (!testInterfaceEmptyArg) { exceptionState.throwTypeError("parameter 1 is not of type 'TestInterfaceEmpty'."); exceptionState.throwIfNeeded(); return; } longArg = toInt32(info.GetIsolate(), info[1], NormalConversion, exceptionState); if (exceptionState.throwIfNeeded()) return; defaultUndefinedOptionalStringArg = info[2]; if (!defaultUndefinedOptionalStringArg.prepare()) return; if (!info[3]->IsUndefined()) { defaultNullStringOptionalStringArg = info[3]; if (!defaultNullStringOptionalStringArg.prepare()) return; } else { defaultNullStringOptionalStringArg = nullptr; } if (!isUndefinedOrNull(info[4]) && !info[4]->IsObject()) { exceptionState.throwTypeError("parameter 5 ('defaultUndefinedOptionalDictionaryArg') is not an object."); exceptionState.throwIfNeeded(); return; } defaultUndefinedOptionalDictionaryArg = Dictionary(info[4], info.GetIsolate(), exceptionState); if (exceptionState.throwIfNeeded()) return; if (UNLIKELY(numArgsPassed <= 5)) { RefPtr<TestInterfaceConstructor2> impl = TestInterfaceConstructor2::create(testInterfaceEmptyArg, longArg, defaultUndefinedOptionalStringArg, defaultNullStringOptionalStringArg, defaultUndefinedOptionalDictionaryArg); v8::Local<v8::Object> wrapper = info.Holder(); wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructor2::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); return; } optionalStringArg = info[5]; if (!optionalStringArg.prepare()) return; } RefPtr<TestInterfaceConstructor2> impl = TestInterfaceConstructor2::create(testInterfaceEmptyArg, longArg, defaultUndefinedOptionalStringArg, defaultNullStringOptionalStringArg, defaultUndefinedOptionalDictionaryArg, optionalStringArg); v8::Local<v8::Object> wrapper = info.Holder(); wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructor2::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); }
void V8HTMLCanvasElement::getContextMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { v8::Handle<v8::Object> holder = info.Holder(); v8::Isolate* isolate = info.GetIsolate(); HTMLCanvasElement* impl = V8HTMLCanvasElement::toNative(holder); TOSTRING_VOID(V8StringResource<>, contextIdResource, info[0]); String contextId = contextIdResource; RefPtr<CanvasContextAttributes> attributes = nullptr; if (contextId == "webgl" || contextId == "experimental-webgl") { RefPtr<WebGLContextAttributes> webGLAttributes = WebGLContextAttributes::create(); if (info.Length() > 1 && info[1]->IsObject()) { v8::Handle<v8::Object> jsAttributes = info[1]->ToObject(); v8::Handle<v8::String> alpha = v8AtomicString(isolate, "alpha"); if (jsAttributes->Has(alpha) && !isUndefinedOrNull(jsAttributes->Get(alpha))) webGLAttributes->setAlpha(jsAttributes->Get(alpha)->BooleanValue()); v8::Handle<v8::String> depth = v8AtomicString(isolate, "depth"); if (jsAttributes->Has(depth) && !isUndefinedOrNull(jsAttributes->Get(depth))) webGLAttributes->setDepth(jsAttributes->Get(depth)->BooleanValue()); v8::Handle<v8::String> stencil = v8AtomicString(isolate, "stencil"); if (jsAttributes->Has(stencil) && !isUndefinedOrNull(jsAttributes->Get(stencil))) webGLAttributes->setStencil(jsAttributes->Get(stencil)->BooleanValue()); v8::Handle<v8::String> antialias = v8AtomicString(isolate, "antialias"); if (jsAttributes->Has(antialias) && !isUndefinedOrNull(jsAttributes->Get(antialias))) webGLAttributes->setAntialias(jsAttributes->Get(antialias)->BooleanValue()); v8::Handle<v8::String> premultipliedAlpha = v8AtomicString(isolate, "premultipliedAlpha"); if (jsAttributes->Has(premultipliedAlpha) && !isUndefinedOrNull(jsAttributes->Get(premultipliedAlpha))) webGLAttributes->setPremultipliedAlpha(jsAttributes->Get(premultipliedAlpha)->BooleanValue()); v8::Handle<v8::String> preserveDrawingBuffer = v8AtomicString(isolate, "preserveDrawingBuffer"); if (jsAttributes->Has(preserveDrawingBuffer) && !isUndefinedOrNull(jsAttributes->Get(preserveDrawingBuffer))) webGLAttributes->setPreserveDrawingBuffer(jsAttributes->Get(preserveDrawingBuffer)->BooleanValue()); v8::Handle<v8::String> failIfMajorPerformanceCaveat = v8AtomicString(isolate, "failIfMajorPerformanceCaveat"); if (jsAttributes->Has(failIfMajorPerformanceCaveat) && !isUndefinedOrNull(jsAttributes->Get(failIfMajorPerformanceCaveat))) webGLAttributes->setFailIfMajorPerformanceCaveat(jsAttributes->Get(failIfMajorPerformanceCaveat)->BooleanValue()); } attributes = webGLAttributes; } else { RefPtr<Canvas2DContextAttributes> canvas2DAttributes = Canvas2DContextAttributes::create(); attributes = canvas2DAttributes; } CanvasRenderingContext* result = impl->getContext(contextId, attributes.get()); if (!result) { v8SetReturnValueNull(info); return; } if (result->is2d()) { v8::Handle<v8::Value> v8Result = toV8(toCanvasRenderingContext2D(result), info.Holder(), info.GetIsolate()); v8SetReturnValue(info, v8Result); return; } if (result->is3d()) { v8::Handle<v8::Value> v8Result = toV8(toWebGLRenderingContext(result), info.Holder(), info.GetIsolate()); v8SetReturnValue(info, v8Result); return; } ASSERT_NOT_REACHED(); v8SetReturnValueNull(info); }
// FIXME(fqian): returning string is cheating, and we should // fix this by calling toString function on the receiver. // However, V8 implements toString in JavaScript, which requires // switching context of receiver. I consider it is dangerous. void V8Window::toStringMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args) { v8::Handle<v8::Object> domWrapper = args.This()->FindInstanceInPrototypeChain(V8Window::GetTemplate(args.GetIsolate(), worldTypeInMainThread(args.GetIsolate()))); if (domWrapper.IsEmpty()) { v8SetReturnValue(args, args.This()->ObjectProtoToString()); return; } v8SetReturnValue(args, domWrapper->ObjectProtoToString()); }
// FIXME(fqian): returning string is cheating, and we should // fix this by calling toString function on the receiver. // However, V8 implements toString in JavaScript, which requires // switching context of receiver. I consider it is dangerous. void V8Window::toStringMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { v8::Handle<v8::Object> domWrapper = V8Window::findInstanceInPrototypeChain(info.This(), info.GetIsolate()); if (domWrapper.IsEmpty()) { v8SetReturnValue(info, info.This()->ObjectProtoToString()); return; } v8SetReturnValue(info, domWrapper->ObjectProtoToString()); }
void V8InspectorFrontendHost::platformMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { #if OS(MACOSX) v8SetReturnValue(info, v8AtomicString(info.GetIsolate(), "mac")); #elif OS(WIN) v8SetReturnValue(info, v8AtomicString(info.GetIsolate(), "windows")); #else // Unix-like systems v8SetReturnValue(info, v8AtomicString(info.GetIsolate(), "linux")); #endif }
void V8PopStateEvent::stateAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info) { v8::Local<v8::Value> result = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate())); if (!result.IsEmpty()) { v8SetReturnValue(info, result); return; } PopStateEvent* event = V8PopStateEvent::toImpl(info.Holder()); History* history = event->history(); if (!history || !event->serializedState()) { if (!event->serializedState()) { // If we're in an isolated world and the event was created in the main world, // we need to find the 'state' property on the main world wrapper and clone it. v8::Local<v8::Value> mainWorldState = V8HiddenValue::getHiddenValueFromMainWorldWrapper(info.GetIsolate(), event, V8HiddenValue::state(info.GetIsolate())); if (!mainWorldState.IsEmpty()) event->setSerializedState(SerializedScriptValueFactory::instance().createAndSwallowExceptions(info.GetIsolate(), mainWorldState)); } if (event->serializedState()) result = event->serializedState()->deserialize(); else result = v8::Null(info.GetIsolate()); v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); return; } // There's no cached value from a previous invocation, nor a state value was provided by the // event, but there is a history object, so first we need to see if the state object has been // deserialized through the history object already. // The current history state object might've changed in the meantime, so we need to take care // of using the correct one, and always share the same deserialization with history.state. bool isSameState = history->isSameAsCurrentState(event->serializedState()); if (isSameState) { v8::Local<v8::Value> v8HistoryValue = toV8(history, info.Holder(), info.GetIsolate()); if (v8HistoryValue.IsEmpty()) return; v8::Local<v8::Object> v8History = v8HistoryValue.As<v8::Object>(); if (!history->stateChanged()) { result = V8HiddenValue::getHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate())); if (!result.IsEmpty()) { v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); return; } } result = event->serializedState()->deserialize(info.GetIsolate()); V8HiddenValue::setHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate()), result); } else { result = event->serializedState()->deserialize(info.GetIsolate()); } v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); }
void V8XMLHttpRequest::responseAttributeGetterCustom( const v8::FunctionCallbackInfo<v8::Value>& info) { XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toImpl(info.Holder()); ExceptionState exceptionState(info.GetIsolate(), ExceptionState::GetterContext, "XMLHttpRequest", "response"); switch (xmlHttpRequest->getResponseTypeCode()) { case XMLHttpRequest::ResponseTypeDefault: case XMLHttpRequest::ResponseTypeText: responseTextAttributeGetterCustom(info); return; case XMLHttpRequest::ResponseTypeJSON: { v8::Isolate* isolate = info.GetIsolate(); ScriptString jsonSource = xmlHttpRequest->responseJSONSource(); if (jsonSource.isEmpty()) { v8SetReturnValue(info, v8::Null(isolate)); return; } // Catch syntax error. Swallows an exception (when thrown) as the // spec says. https://xhr.spec.whatwg.org/#response-body v8::Local<v8::Value> json = fromJSONString( isolate, toCoreString(jsonSource.v8Value()), exceptionState); if (exceptionState.hadException()) { exceptionState.clearException(); v8SetReturnValue(info, v8::Null(isolate)); } else { v8SetReturnValue(info, json); } return; } case XMLHttpRequest::ResponseTypeDocument: { Document* document = xmlHttpRequest->responseXML(exceptionState); v8SetReturnValueFast(info, document, xmlHttpRequest); return; } case XMLHttpRequest::ResponseTypeBlob: { Blob* blob = xmlHttpRequest->responseBlob(); v8SetReturnValueFast(info, blob, xmlHttpRequest); return; } case XMLHttpRequest::ResponseTypeArrayBuffer: { DOMArrayBuffer* arrayBuffer = xmlHttpRequest->responseArrayBuffer(); v8SetReturnValueFast(info, arrayBuffer, xmlHttpRequest); return; } } }
void V8InjectedScriptHost::isHTMLAllCollectionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; if (!info[0]->IsObject()) { v8SetReturnValue(info, false); return; } v8SetReturnValue(info, V8HTMLAllCollection::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))); }
void V8PopStateEvent::stateAttributeGetterCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { v8::Local<v8::Value> result = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate())); if (!result.IsEmpty()) { v8SetReturnValue(info, result); return; } PopStateEvent* event = V8PopStateEvent::toImpl(info.Holder()); History* history = event->history(); if (!history || !event->serializedState()) { // If the event doesn't have serializedState(), it means that the // event was initialized with PopStateEventInit. In such case, we need // to get a v8 value for the current world from state(). if (event->serializedState()) result = event->serializedState()->deserialize(); else result = event->state().v8ValueFor(ScriptState::current(info.GetIsolate())); if (result.IsEmpty()) result = v8::Null(info.GetIsolate()); v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); return; } // There's no cached value from a previous invocation, nor a state value was provided by the // event, but there is a history object, so first we need to see if the state object has been // deserialized through the history object already. // The current history state object might've changed in the meantime, so we need to take care // of using the correct one, and always share the same deserialization with history.state. bool isSameState = history->isSameAsCurrentState(event->serializedState()); if (isSameState) { v8::Local<v8::Value> v8HistoryValue = toV8(history, info.Holder(), info.GetIsolate()); if (v8HistoryValue.IsEmpty()) return; v8::Local<v8::Object> v8History = v8HistoryValue.As<v8::Object>(); if (!history->stateChanged()) { result = V8HiddenValue::getHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate())); if (!result.IsEmpty()) { v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); return; } } result = event->serializedState()->deserialize(info.GetIsolate()); V8HiddenValue::setHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate()), result); } else { result = event->serializedState()->deserialize(info.GetIsolate()); } v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); }
static void promiseMethodPartialOverload3Method(const v8::FunctionCallbackInfo<v8::Value>& info) { TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder()); Document* document; { document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]); if (!document) { v8SetReturnValue(info, ScriptPromise::rejectRaw(ScriptState::current(info.GetIsolate()), V8ThrowException::createTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("promiseMethodPartialOverload", "TestInterface", "parameter 1 is not of type 'Document'.")))); return; } } v8SetReturnValue(info, TestPartialInterfaceImplementation3::promiseMethodPartialOverload(*impl, document).v8Value()); }
void V8InjectedScriptHost::subtypeCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; v8::Isolate* isolate = info.GetIsolate(); v8::Local<v8::Value> value = info[0]; if (value->IsArray() || value->IsTypedArray() || value->IsArgumentsObject()) { v8SetReturnValue(info, v8AtomicString(isolate, "array")); return; } if (value->IsDate()) { v8SetReturnValue(info, v8AtomicString(isolate, "date")); return; } if (value->IsRegExp()) { v8SetReturnValue(info, v8AtomicString(isolate, "regexp")); return; } if (value->IsMap() || value->IsWeakMap()) { v8SetReturnValue(info, v8AtomicString(isolate, "map")); return; } if (value->IsSet() || value->IsWeakSet()) { v8SetReturnValue(info, v8AtomicString(isolate, "set")); return; } if (value->IsMapIterator() || value->IsSetIterator()) { v8SetReturnValue(info, v8AtomicString(isolate, "iterator")); return; } if (value->IsGeneratorObject()) { v8SetReturnValue(info, v8AtomicString(isolate, "generator")); return; } if (V8Node::hasInstance(value, isolate)) { v8SetReturnValue(info, v8AtomicString(isolate, "node")); return; } if (V8NodeList::hasInstance(value, isolate) || V8DOMTokenList::hasInstance(value, isolate) || V8HTMLCollection::hasInstance(value, isolate) || V8HTMLAllCollection::hasInstance(value, isolate)) { v8SetReturnValue(info, v8AtomicString(isolate, "array")); return; } if (value->IsNativeError() || V8DOMException::hasInstance(value, isolate)) { v8SetReturnValue(info, v8AtomicString(isolate, "error")); return; } }
void V8MessageEvent::dataAttributeGetterCustom( const v8::FunctionCallbackInfo<v8::Value>& info) { ScriptState* scriptState = ScriptState::current(info.GetIsolate()); auto privateCachedData = V8PrivateProperty::getMessageEventCachedData(info.GetIsolate()); v8::Local<v8::Value> cachedData = privateCachedData.get(scriptState->context(), info.Holder()); if (!cachedData.IsEmpty()) { v8SetReturnValue(info, cachedData); return; } MessageEvent* event = V8MessageEvent::toImpl(info.Holder()); v8::Local<v8::Value> result; switch (event->getDataType()) { case MessageEvent::DataTypeScriptValue: result = event->dataAsScriptValue().v8ValueFor(scriptState); if (result.IsEmpty()) result = v8::Null(info.GetIsolate()); break; case MessageEvent::DataTypeSerializedScriptValue: if (SerializedScriptValue* serializedValue = event->dataAsSerializedScriptValue()) { MessagePortArray ports = event->ports(); result = serializedValue->deserialize(info.GetIsolate(), &ports); } else { result = v8::Null(info.GetIsolate()); } break; case MessageEvent::DataTypeString: result = v8String(info.GetIsolate(), event->dataAsString()); break; case MessageEvent::DataTypeBlob: result = toV8(event->dataAsBlob(), info.Holder(), info.GetIsolate()); break; case MessageEvent::DataTypeArrayBuffer: result = toV8(event->dataAsArrayBuffer(), info.Holder(), info.GetIsolate()); break; } // Store the result as a private value so this callback returns the cached // result in future invocations. privateCachedData.set(scriptState->context(), info.Holder(), result); v8SetReturnValue(info, result); }
static void V8TestInterfaceConstructorConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (!info.IsConstructCall()) { V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::constructorNotCallableAsFunction("Audio")); return; } if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::WrapExistingObject) { v8SetReturnValue(info, info.Holder()); return; } ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceConstructor", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 1)) { setMinimumArityTypeError(exceptionState, 1, info.Length()); exceptionState.throwIfNeeded(); return; } V8StringResource<> arg; V8StringResource<> optArg; { TOSTRING_VOID_INTERNAL(arg, info[0]); if (UNLIKELY(info.Length() <= 1)) { ScriptState* scriptState = ScriptState::current(info.GetIsolate()); ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate()); Document& document = *toDocument(currentExecutionContext(info.GetIsolate())); RefPtr<TestInterfaceConstructor> impl = TestInterfaceConstructor::createForJSConstructor(scriptState, executionContext, document, arg, exceptionState); if (exceptionState.hadException()) { exceptionState.throwIfNeeded(); return; } v8::Local<v8::Object> wrapper = info.Holder(); impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructorConstructor::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); return; } TOSTRING_VOID_INTERNAL(optArg, info[1]); } ScriptState* scriptState = ScriptState::current(info.GetIsolate()); ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate()); Document& document = *toDocument(currentExecutionContext(info.GetIsolate())); RefPtr<TestInterfaceConstructor> impl = TestInterfaceConstructor::createForJSConstructor(scriptState, executionContext, document, arg, optArg, exceptionState); if (exceptionState.hadException()) { exceptionState.throwIfNeeded(); return; } v8::Local<v8::Object> wrapper = info.Holder(); impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructorConstructor::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); }
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceEventInitConstructor", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 2)) { setMinimumArityTypeError(exceptionState, 2, info.Length()); exceptionState.throwIfNeeded(); return; } V8StringResource<> type; TestInterfaceEventInit testInterfaceEventInit; { type = info[0]; if (!type.prepare()) return; if (!isUndefinedOrNull(info[1]) && !info[1]->IsObject()) { exceptionState.throwTypeError("parameter 2 ('testInterfaceEventInit') is not an object."); exceptionState.throwIfNeeded(); return; } V8TestInterfaceEventInit::toImpl(info.GetIsolate(), info[1], testInterfaceEventInit, exceptionState); if (exceptionState.throwIfNeeded()) return; } RefPtrWillBeRawPtr<TestInterfaceEventInitConstructor> impl = TestInterfaceEventInitConstructor::create(type, testInterfaceEventInit); v8::Local<v8::Object> wrapper = info.Holder(); wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceEventInitConstructor::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); }
void V8HTMLAllCollection::legacyCallCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; HTMLAllCollection* impl = V8HTMLAllCollection::toImpl(info.Holder()); Node& ownerNode = impl->ownerNode(); UseCounter::countIfNotPrivateScript(info.GetIsolate(), ownerNode.document(), UseCounter::DocumentAllLegacyCall); if (info.Length() == 1) { v8SetReturnValue(info, getItem(impl, info[0], info)); return; } // If there is a second argument it is the index of the item we want. TOSTRING_VOID(V8StringResource<>, name, info[0]); v8::Local<v8::Uint32> index; if (!info[1]->ToArrayIndex(info.GetIsolate()->GetCurrentContext()).ToLocal(&index)) return; if (Node* node = impl->namedItemWithIndex(name, index->Value())) { v8SetReturnValueFast(info, node, impl); return; } }
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info) { TestNode* impl = TestNode::create(); v8::Local<v8::Object> wrapper = info.Holder(); wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestNode::wrapperTypeInfo, wrapper); v8SetReturnValue(info, wrapper); }
void V8InjectedScriptHost::functionDetailsCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1 || !info[0]->IsFunction()) return; v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(info[0]); int lineNumber = function->GetScriptLineNumber(); int columnNumber = function->GetScriptColumnNumber(); v8::Isolate* isolate = info.GetIsolate(); v8::Local<v8::Object> location = v8::Object::New(isolate); location->Set(v8AtomicString(isolate, "lineNumber"), v8::Integer::New(isolate, lineNumber)); location->Set(v8AtomicString(isolate, "columnNumber"), v8::Integer::New(isolate, columnNumber)); location->Set(v8AtomicString(isolate, "scriptId"), v8::Integer::New(isolate, function->ScriptId())->ToString(isolate)); v8::Local<v8::Object> result = v8::Object::New(isolate); result->Set(v8AtomicString(isolate, "location"), location); v8::Local<v8::String> name = functionDisplayName(function); result->Set(v8AtomicString(isolate, "functionName"), name.IsEmpty() ? v8AtomicString(isolate, "") : name); result->Set(v8AtomicString(isolate, "isGenerator"), v8::Boolean::New(isolate, function->IsGeneratorFunction())); InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder()); V8DebuggerImpl& debugger = static_cast<V8DebuggerImpl&>(host->debugger()); v8::MaybeLocal<v8::Value> scopes = debugger.functionScopes(function); if (!scopes.IsEmpty() && scopes.ToLocalChecked()->IsArray()) result->Set(v8AtomicString(isolate, "rawScopes"), scopes.ToLocalChecked()); v8SetReturnValue(info, result); }
void V8Crypto::getRandomValuesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "getRandomValues", "Crypto", info.Holder(), info.GetIsolate()); if (info.Length() < 1) { exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length())); exceptionState.throwIfNeeded(); return; } v8::Handle<v8::Value> buffer = info[0]; if (!V8ArrayBufferView::hasInstance(buffer, info.GetIsolate())) { exceptionState.throwTypeError("First argument is not an ArrayBufferView"); } else { ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(v8::Handle<v8::Object>::Cast(buffer)); ASSERT(arrayBufferView); Crypto* crypto = V8Crypto::toNative(info.Holder()); crypto->getRandomValues(arrayBufferView, exceptionState); } if (exceptionState.throwIfNeeded()) return; v8SetReturnValue(info, buffer); }
void V8InjectedScriptHost::isDOMWrapperCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; v8SetReturnValue(info, V8DOMWrapper::isWrapper(info.GetIsolate(), info[0])); }
void npObjectPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info, bool namedProperty) { NPObject* npObject = v8ObjectToNPObject(info.Holder()); // Verify that our wrapper wasn't using a NPObject which // has already been deleted. if (!npObject || !_NPN_IsAlive(npObject)) throwError(v8ReferenceError, "NPObject deleted", info.GetIsolate()); if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate) { uint32_t count; NPIdentifier* identifiers; if (npObject->_class->enumerate(npObject, &identifiers, &count)) { v8::Handle<v8::Array> properties = v8::Array::New(count); for (uint32_t i = 0; i < count; ++i) { IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]); if (namedProperty) properties->Set(v8::Integer::New(i, info.GetIsolate()), v8::String::NewSymbol(identifier->string())); else properties->Set(v8::Integer::New(i, info.GetIsolate()), v8::Integer::New(identifier->number(), info.GetIsolate())); } v8SetReturnValue(info, properties); return; } } }
static void setItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "setItem", "TestInterface2", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 2)) { setMinimumArityTypeError(exceptionState, 2, info.Length()); exceptionState.throwIfNeeded(); return; } TestInterface2* impl = V8TestInterface2::toImpl(info.Holder()); unsigned index; TestInterfaceEmpty* value; { index = toUInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState); if (exceptionState.throwIfNeeded()) return; value = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]); if (!value) { exceptionState.throwTypeError("parameter 2 is not of type 'TestInterfaceEmpty'."); exceptionState.throwIfNeeded(); return; } } TestInterfaceEmpty* result = impl->setItem(index, value, exceptionState); if (exceptionState.hadException()) { exceptionState.throwIfNeeded(); return; } v8SetReturnValue(info, result); }
static void eventHandlerAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) { v8::Local<v8::Object> holder = info.Holder(); TestInterfaceNode* impl = V8TestInterfaceNode::toImpl(holder); EventListener* cppValue(impl->eventHandlerAttribute()); v8SetReturnValue(info, cppValue ? v8::Local<v8::Value>(V8AbstractEventListener::cast(cppValue)->getListenerObject(impl->executionContext())) : v8::Local<v8::Value>(v8::Null(info.GetIsolate()))); }
static void setNamedItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "setNamedItem", "TestInterface2", info.Holder(), info.GetIsolate()); if (UNLIKELY(info.Length() < 2)) { setMinimumArityTypeError(exceptionState, 2, info.Length()); exceptionState.throwIfNeeded(); return; } TestInterface2* impl = V8TestInterface2::toImpl(info.Holder()); V8StringResource<> name; TestInterfaceEmpty* value; { name = info[0]; if (!name.prepare()) return; value = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]); if (!value && !isUndefinedOrNull(info[1])) { exceptionState.throwTypeError("parameter 2 is not of type 'TestInterfaceEmpty'."); exceptionState.throwIfNeeded(); return; } } TestInterfaceEmpty* result = impl->setNamedItem(name, value, exceptionState); if (exceptionState.hadException()) { exceptionState.throwIfNeeded(); return; } v8SetReturnValue(info, result); }
void V8HTMLAllCollection::legacyCallCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; HTMLAllCollection* imp = V8HTMLAllCollection::toNative(info.Holder()); Node* ownerNode = imp->ownerNode(); ASSERT(ownerNode); UseCounter::count(ownerNode->document(), UseCounter::DocumentAllLegacyCall); if (info.Length() == 1) { v8SetReturnValue(info, getItem(imp, info[0], info)); return; } // If there is a second argument it is the index of the item we want. V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, info[0]); v8::Local<v8::Uint32> index = info[1]->ToArrayIndex(); if (index.IsEmpty()) return; if (Node* node = imp->namedItemWithIndex(name, index->Uint32Value())) { v8SetReturnValueFast(info, node, imp); return; } }
void V8InjectedScriptHost::getEventListenersMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; v8::Local<v8::Value> value = info[0]; if (!V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) return; Node* node = V8Node::toNative(value->ToObject()); if (!node) return; InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder()); Vector<EventListenerInfo> listenersArray; host->getEventListenersImpl(node, listenersArray); v8::Local<v8::Object> result = v8::Object::New(); for (size_t i = 0; i < listenersArray.size(); ++i) { v8::Handle<v8::Array> listeners = getJSListenerFunctions(&node->document(), listenersArray[i]); if (!listeners->Length()) continue; AtomicString eventType = listenersArray[i].eventType; result->Set(v8String(eventType, info.GetIsolate()), listeners); } v8SetReturnValue(info, result); }
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info) { RefPtrWillBeRawPtr<TestNode> impl = TestNode::create(); v8::Handle<v8::Object> wrapper = info.Holder(); impl->associateWithWrapper(&V8TestNode::wrapperTypeInfo, wrapper, info.GetIsolate()); v8SetReturnValue(info, wrapper); }
static void setExceptionAsReturnValue(const v8::FunctionCallbackInfo<v8::Value>& info, v8::Local<v8::Object> returnValue, v8::TryCatch& tryCatch) { v8::Isolate* isolate = info.GetIsolate(); returnValue->Set(v8::String::NewFromUtf8(isolate, "result"), tryCatch.Exception()); returnValue->Set(v8::String::NewFromUtf8(isolate, "exceptionDetails"), JavaScriptCallFrame::createExceptionDetails(isolate, tryCatch.Message())); v8SetReturnValue(info, returnValue); }
void V8Window::eventAttributeGetterCustom( const v8::PropertyCallbackInfo<v8::Value>& info) { LocalDOMWindow* impl = toLocalDOMWindow(V8Window::toImpl(info.Holder())); ExceptionState exceptionState(ExceptionState::GetterContext, "event", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), impl, exceptionState)) { return; } LocalFrame* frame = impl->frame(); ASSERT(frame); // This is a fast path to retrieve info.Holder()->CreationContext(). v8::Local<v8::Context> context = toV8Context(frame, DOMWrapperWorld::current(info.GetIsolate())); if (context.IsEmpty()) return; v8::Local<v8::Value> jsEvent = V8HiddenValue::getHiddenValue( ScriptState::current(info.GetIsolate()), context->Global(), V8HiddenValue::event(info.GetIsolate())); if (jsEvent.IsEmpty()) return; v8SetReturnValue(info, jsEvent); }
static void staticPromiseMethodPartialOverload2Method(const v8::FunctionCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(ExceptionState::ExecutionContext, "staticPromiseMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate()); staticPromiseMethodPartialOverload2MethodPromise(info, exceptionState); if (exceptionState.hadException()) v8SetReturnValue(info, exceptionState.reject(ScriptState::current(info.GetIsolate())).v8Value()); }