v8::MaybeLocal<v8::Script> V8ScriptRunner::compileScript(v8::Local<v8::String> code, const String& fileName, const String& sourceMapUrl, const TextPosition& scriptStartPosition, v8::Isolate* isolate, ScriptResource* resource, ScriptStreamer* streamer, CachedMetadataHandler* cacheHandler, AccessControlStatus corsStatus, V8CacheOptions cacheOptions, bool isInternalScript)
{
TRACE_EVENT1("v8", "v8.compile", "fileName", fileName.utf8());
TRACE_EVENT_SCOPED_SAMPLING_STATE("v8", "V8Compile");
ASSERT(!streamer || resource);
ASSERT(!resource || resource->cacheHandler() == cacheHandler);
// NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
// 1, whereas v8 starts at 0.
v8::ScriptOrigin origin(
v8String(isolate, fileName),
v8::Integer::New(isolate, scriptStartPosition.m_line.zeroBasedInt()),
v8::Integer::New(isolate, scriptStartPosition.m_column.zeroBasedInt()),
v8Boolean(corsStatus == SharableCrossOrigin, isolate),
v8::Local<v8::Integer>(),
v8Boolean(isInternalScript, isolate),
v8String(isolate, sourceMapUrl));
OwnPtr<CompileFn> compileFn = streamer
? selectCompileFunction(cacheOptions, resource, streamer)
: selectCompileFunction(cacheOptions, cacheHandler, code);
return (*compileFn)(isolate, code, origin);
}
v8::Handle<v8::Value> convertNPVariantToV8Object(const NPVariant* variant, NPObject* owner, v8::Isolate* isolate)
{
NPVariantType type = variant->type;
switch (type) {
case NPVariantType_Int32:
return v8::Integer::New(NPVARIANT_TO_INT32(*variant), isolate);
case NPVariantType_Double:
return v8::Number::New(isolate, NPVARIANT_TO_DOUBLE(*variant));
case NPVariantType_Bool:
return v8Boolean(NPVARIANT_TO_BOOLEAN(*variant), isolate);
case NPVariantType_Null:
return v8::Null(isolate);
case NPVariantType_Void:
return v8::Undefined(isolate);
case NPVariantType_String: {
NPString src = NPVARIANT_TO_STRING(*variant);
return v8::String::NewFromUtf8(isolate, src.UTF8Characters, v8::String::kNormalString, src.UTF8Length);
}
case NPVariantType_Object: {
NPObject* object = NPVARIANT_TO_OBJECT(*variant);
if (V8NPObject* v8Object = npObjectToV8NPObject(object))
return v8::Local<v8::Object>::New(isolate, v8Object->v8Object);
return createV8ObjectForNPObject(object, owner, isolate);
}
default:
return v8::Undefined(isolate);
}
}
static v8::Handle<v8::Value> primaryAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLDataGridColElement.primary._get");
HTMLDataGridColElement* imp = V8HTMLDataGridColElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8Boolean(imp->primary());
}
v8::Handle<v8::Value> V8WebSocket::sendCallback(const v8::Arguments& args)
{
INC_STATS("DOM.WebSocket.send()");
if (!args.Length())
return throwError("Not enough arguments", V8Proxy::SyntaxError);
WebSocket* webSocket = V8WebSocket::toNative(args.Holder());
v8::Handle<v8::Value> message = args[0];
ExceptionCode ec = 0;
bool result;
if (V8ArrayBuffer::HasInstance(message)) {
ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(message));
ASSERT(arrayBuffer);
result = webSocket->send(arrayBuffer, ec);
} else if (V8Blob::HasInstance(message)) {
Blob* blob = V8Blob::toNative(v8::Handle<v8::Object>::Cast(message));
ASSERT(blob);
result = webSocket->send(blob, ec);
} else {
v8::TryCatch tryCatch;
v8::Handle<v8::String> stringMessage = message->ToString();
if (tryCatch.HasCaught())
return throwError(tryCatch.Exception());
result = webSocket->send(toWebCoreString(stringMessage), ec);
}
if (ec)
return throwError(ec);
return v8Boolean(result);
}
static v8::Handle<v8::Value> containsCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Node.contains");
Node* imp = V8Node::toNative(args.Holder());
EXCEPTION_BLOCK(Node*, other, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined)) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined))) : 0);
return v8Boolean(imp->contains(other));
}
v8::Handle<v8::Boolean> V8DOMStringMap::namedPropertyDeleter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.DOMStringMap.NamedPropertyDeleter");
ExceptionCode ec = 0;
V8DOMStringMap::toNative(info.Holder())->deleteItem(toWebCoreString(name), ec);
return v8Boolean(!ec, info.GetIsolate());
}
bool V8TestCallback::callbackWithBoolean(bool boolParam)
{
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_world.get());
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Handle<v8::Value> boolParamHandle = v8Boolean(boolParam, v8Context->GetIsolate());
if (boolParamHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
v8::Handle<v8::Value> argv[] = {
boolParamHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), 1, argv, callbackReturnValue, scriptExecutionContext());
}
static v8::Handle<v8::Value> matchMediumCallback(const v8::Arguments& args)
{
INC_STATS("DOM.StyleMedia.matchMedium");
StyleMedia* imp = V8StyleMedia::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, mediaquery, args[0]);
return v8Boolean(imp->matchMedium(mediaquery));
}
static v8::Handle<v8::Value> hasExtensionCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGPolylineElement.hasExtension");
SVGPolylineElement* imp = V8SVGPolylineElement::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, extension, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
return v8Boolean(imp->hasExtension(extension));
}
static v8::Handle<v8::Value> containsCallback(const v8::Arguments& args)
{
INC_STATS("DOM.DOMStringList.contains");
DOMStringList* imp = V8DOMStringList::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, string, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
return v8Boolean(imp->contains(string));
}
static v8::Handle<v8::Value> isMapAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.isMap._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8Boolean(imp->hasAttribute(WebCore::HTMLNames::ismapAttr));
}
ScriptValue WebGLAny(ScriptState* scriptState, const bool* value, size_t size)
{
v8::Local<v8::Array> array = v8::Array::New(scriptState->isolate(), size);
for (size_t ii = 0; ii < size; ++ii)
array->Set(v8::Integer::New(scriptState->isolate(), ii), v8Boolean(value[ii], scriptState->isolate()));
return ScriptValue(scriptState, array);
}
static v8::Handle<v8::Value> isDefaultNamespaceCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Node.isDefaultNamespace");
Node* imp = V8Node::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<WithNullCheck>, namespaceURI, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
return v8Boolean(imp->isDefaultNamespace(namespaceURI));
}
v8::Handle<v8::Value> convertNPVariantToV8Object(const NPVariant* variant, NPObject* npobject)
{
NPVariantType type = variant->type;
switch (type) {
case NPVariantType_Int32:
return v8Integer(NPVARIANT_TO_INT32(*variant));
case NPVariantType_Double:
return v8::Number::New(NPVARIANT_TO_DOUBLE(*variant));
case NPVariantType_Bool:
return v8Boolean(NPVARIANT_TO_BOOLEAN(*variant));
case NPVariantType_Null:
return v8::Null();
case NPVariantType_Void:
return v8::Undefined();
case NPVariantType_String: {
NPString src = NPVARIANT_TO_STRING(*variant);
return v8::String::New(src.UTF8Characters, src.UTF8Length);
}
case NPVariantType_Object: {
NPObject* obj = NPVARIANT_TO_OBJECT(*variant);
if (obj->_class == npScriptObjectClass)
return reinterpret_cast<V8NPObject*>(obj)->v8Object;
return createV8ObjectForNPObject(obj, npobject);
}
default:
return v8::Undefined();
}
}
static v8::Handle<v8::Value> hasExtensionCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGLineElement.hasExtension");
SVGLineElement* imp = V8SVGLineElement::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, extension, args[0]);
return v8Boolean(imp->hasExtension(extension));
}
static v8::Handle<v8::Value> completeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.complete._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8Boolean(imp->complete());
}
bool ScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, ScriptValue* newCallFrames, ScriptObject* result)
{
ensureDebuggerScriptCompiled();
v8::HandleScope scope;
OwnPtr<v8::Context::Scope> contextScope;
if (!isPaused())
contextScope = adoptPtr(new v8::Context::Scope(v8::Debug::GetDebugContext()));
v8::Handle<v8::Value> argv[] = { v8String(sourceID), v8String(newContent), v8Boolean(preview) };
v8::TryCatch tryCatch;
tryCatch.SetVerbose(false);
v8::Local<v8::Value> v8result = callDebuggerMethod("setScriptSource", 3, argv);
if (tryCatch.HasCaught()) {
v8::Local<v8::Message> message = tryCatch.Message();
if (!message.IsEmpty())
*error = toWebCoreStringWithNullOrUndefinedCheck(message->Get());
else
*error = "Unknown error.";
return false;
}
ASSERT(!v8result.IsEmpty());
if (v8result->IsObject())
*result = ScriptObject(ScriptState::current(), v8result->ToObject());
// Call stack may have changed after if the edited function was on the stack.
if (!preview && isPaused())
*newCallFrames = currentCallFrame();
return true;
}
static v8::Handle<v8::Value> isSupportedCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Node.isSupported");
Node* imp = V8Node::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, feature, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<WithNullCheck>, version, MAYBE_MISSING_PARAMETER(args, 1, MissingIsUndefined));
return v8Boolean(imp->isSupported(feature, version));
}
static v8::Handle<v8::Value> hasFeatureCallback(const v8::Arguments& args)
{
INC_STATS("DOM.DOMImplementation.hasFeature");
DOMImplementation* imp = V8DOMImplementation::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, feature, MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined));
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<WithNullCheck>, version, MAYBE_MISSING_PARAMETER(args, 1, MissingIsUndefined));
return v8Boolean(imp->hasFeature(feature, version));
}
static v8::Handle<v8::Value> setDataCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
Clipboard* imp = V8Clipboard::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, data, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
return v8Boolean(imp->setData(type, data), args.GetIsolate());
}
ScriptValue WebGLAny(ScriptState* scriptState, const bool* value, size_t size) {
v8::Local<v8::Array> array = v8::Array::New(scriptState->isolate(), size);
for (size_t i = 0; i < size; ++i) {
if (!v8CallBoolean(array->CreateDataProperty(
scriptState->context(), i,
v8Boolean(value[i], scriptState->isolate()))))
return ScriptValue();
}
return ScriptValue(scriptState, array);
}
static v8::Handle<v8::Value> setDataCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Clipboard.setData");
if (args.Length() < 2)
return v8::Handle<v8::Value>();
Clipboard* imp = V8Clipboard::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, type, args[0]);
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, data, args[1]);
return v8Boolean(imp->setData(type, data));
}
v8::Handle<v8::Value> V8InjectedScriptHost::isHTMLAllCollectionMethodCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return v8::Undefined();
if (!args[0]->IsObject())
return v8Boolean(false, args.GetIsolate());
return v8::Boolean::New(V8HTMLAllCollection::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())));
}
static v8::Handle<v8::Value> isVertexArrayOESCallback(const v8::Arguments& args)
{
INC_STATS("DOM.OESVertexArrayObject.isVertexArrayOES");
OESVertexArrayObject* imp = V8OESVertexArrayObject::toNative(args.Holder());
if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLVertexArrayObjectOES::HasInstance(args[0])) {
V8Proxy::throwTypeError();
return notHandledByInterceptor();
}
EXCEPTION_BLOCK(WebGLVertexArrayObjectOES*, arrayObject, V8WebGLVertexArrayObjectOES::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined)) ? V8WebGLVertexArrayObjectOES::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, MissingIsUndefined))) : 0);
return v8Boolean(imp->isVertexArrayOES(arrayObject));
}
static v8::Handle<v8::Value> booleanValueAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.XPathResult.booleanValue._get");
XPathResult* imp = V8XPathResult::toNative(info.Holder());
ExceptionCode ec = 0;
bool v = imp->booleanValue(ec);
if (UNLIKELY(ec)) {
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
return v8Boolean(v);
}
v8::Handle<v8::Value> V8InjectedScriptHost::isHTMLAllCollectionCallback(const v8::Arguments& args)
{
INC_STATS("InjectedScriptHost.isHTMLAllCollectionCallback()");
if (args.Length() < 1)
return v8::Undefined();
if (!args[0]->IsObject())
return v8Boolean(false, args.GetIsolate());
v8::HandleScope handleScope;
return v8::Boolean::New(V8HTMLAllCollection::HasInstance(args[0]));
}
v8::Handle<v8::Value> V8Clipboard::setDataCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Clipboard.setData()");
Clipboard* clipboard = V8Clipboard::toNative(args.Holder());
if (args.Length() != 2)
return throwError("setData: Invalid number of arguments", V8Proxy::SyntaxError);
String type = toWebCoreString(args[0]);
String data = toWebCoreString(args[1]);
return v8Boolean(clipboard->setData(type, data));
}
v8::Local<v8::Value> toV8(const BooleanOrString& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
{
switch (impl.m_type) {
case BooleanOrString::SpecificTypeNone:
return v8::Null(isolate);
case BooleanOrString::SpecificTypeBoolean:
return v8Boolean(impl.getAsBoolean(), isolate);
case BooleanOrString::SpecificTypeString:
return v8String(isolate, impl.getAsString());
default:
ASSERT_NOT_REACHED();
}
return v8::Local<v8::Value>();
}
void V8TestCallbackInterface::voidMethodBooleanArg(bool boolArg)
{
if (!canInvokeCallback())
return;
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Local<v8::Value> boolArgHandle = v8Boolean(boolArg, m_scriptState->isolate());
v8::Local<v8::Value> argv[] = { boolArgHandle };
V8ScriptRunner::callFunction(m_callback.newLocal(m_scriptState->isolate()), m_scriptState->getExecutionContext(), v8::Undefined(m_scriptState->isolate()), 1, argv, m_scriptState->isolate());
}
static v8::Handle<v8::Value> dispatchEventCallback(const v8::Arguments& args) {
INC_STATS("DOM.XMLHttpRequestUpload.dispatchEvent");
XMLHttpRequestUpload* imp = V8XMLHttpRequestUpload::toNative(args.Holder());
ExceptionCode ec = 0;
{
Event* evt = V8Event::HasInstance(args[0]) ? V8Event::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
bool result = imp->dispatchEvent(evt, ec);
if (UNLIKELY(ec)) goto fail;
return v8Boolean(result);
}
fail:
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
