static PassRefPtr<CanvasStyle> toCanvasStyle(v8::Handle<v8::Value> value, v8::Isolate* isolate)
{
if (V8CanvasGradient::HasInstance(value, isolate, worldType(isolate)))
return CanvasStyle::createFromGradient(V8CanvasGradient::toNative(v8::Handle<v8::Object>::Cast(value)));
if (V8CanvasPattern::HasInstance(value, isolate, worldType(isolate)))
return CanvasStyle::createFromPattern(V8CanvasPattern::toNative(v8::Handle<v8::Object>::Cast(value)));
return 0;
}
// This function is customized to take advantage of the optional 4th argument: AttachBehavior
v8::Handle<v8::Value> V8Node::replaceChildMethodCustom(const v8::Arguments& args)
{
v8::Handle<v8::Object> holder = args.Holder();
Node* imp = V8Node::toNative(holder);
ExceptionCode ec = 0;
Node* newChild = V8Node::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
Node* oldChild = V8Node::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0;
bool success = imp->replaceChild(newChild, oldChild, ec, AttachLazily);
if (ec)
return setDOMException(ec, args.GetIsolate());
if (success)
return args[1];
return v8Null(args.GetIsolate());
}
void V8InjectedScriptHost::typeMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() < 1)
return;
v8::Handle<v8::Value> value = info[0];
if (value->IsString()) {
v8SetReturnValue(info, v8::String::NewSymbol("string"));
return;
}
if (value->IsArray()) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (value->IsBoolean()) {
v8SetReturnValue(info, v8::String::NewSymbol("boolean"));
return;
}
if (value->IsNumber()) {
v8SetReturnValue(info, v8::String::NewSymbol("number"));
return;
}
if (value->IsDate()) {
v8SetReturnValue(info, v8::String::NewSymbol("date"));
return;
}
if (value->IsRegExp()) {
v8SetReturnValue(info, v8::String::NewSymbol("regexp"));
return;
}
WrapperWorldType currentWorldType = worldType(info.GetIsolate());
if (V8Node::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("node"));
return;
}
if (V8NodeList::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (V8HTMLCollection::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (V8Int8Array::HasInstance(value, info.GetIsolate(), currentWorldType) || V8Int16Array::HasInstance(value, info.GetIsolate(), currentWorldType) || V8Int32Array::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (V8Uint8Array::HasInstance(value, info.GetIsolate(), currentWorldType) || V8Uint16Array::HasInstance(value, info.GetIsolate(), currentWorldType) || V8Uint32Array::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (V8Float32Array::HasInstance(value, info.GetIsolate(), currentWorldType) || V8Float64Array::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
if (V8Uint8ClampedArray::HasInstance(value, info.GetIsolate(), currentWorldType)) {
v8SetReturnValue(info, v8::String::NewSymbol("array"));
return;
}
}
v8::Handle<v8::Value> V8FormData::appendMethodCustom(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwError(v8SyntaxError, "Not enough arguments", args.GetIsolate());
DOMFormData* domFormData = V8FormData::toNative(args.Holder());
String name = toWebCoreStringWithNullCheck(args[0]);
v8::Handle<v8::Value> arg = args[1];
if (V8Blob::HasInstance(arg, args.GetIsolate(), worldType(args.GetIsolate()))) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
Blob* blob = V8Blob::toNative(object);
ASSERT(blob);
String filename;
if (args.Length() >= 3 && !args[2]->IsUndefined())
filename = toWebCoreStringWithNullCheck(args[2]);
domFormData->append(name, blob, filename);
} else
domFormData->append(name, toWebCoreStringWithNullCheck(arg));
return v8::Undefined();
}
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);
}
void V8HTMLOptionsCollection::addMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (!V8HTMLOptionElement::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) {
setDOMException(TYPE_MISMATCH_ERR, args.GetIsolate());
return;
}
HTMLOptionsCollection* imp = V8HTMLOptionsCollection::toNative(args.Holder());
HTMLOptionElement* option = V8HTMLOptionElement::toNative(v8::Handle<v8::Object>(v8::Handle<v8::Object>::Cast(args[0])));
ExceptionCode ec = 0;
if (args.Length() < 2)
imp->add(option, ec);
else {
bool ok;
V8TRYCATCH_VOID(int, index, toInt32(args[1], ok));
if (!ok)
ec = TYPE_MISMATCH_ERR;
else
imp->add(option, index, ec);
}
if (!ec)
return;
setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8InjectedScriptHost::getEventListenersMethodCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return v8::Undefined();
v8::Local<v8::Value> value = args[0];
if (!V8Node::HasInstance(value, args.GetIsolate(), worldType(args.GetIsolate())))
return v8::Undefined();
Node* node = V8Node::toNative(value->ToObject());
if (!node)
return v8::Undefined();
// This can only happen for orphan DocumentType nodes.
Document* document = node->document();
if (!node->document())
return v8::Undefined();
InjectedScriptHost* host = V8InjectedScriptHost::toNative(args.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(document, listenersArray[i]);
if (!listeners->Length())
continue;
AtomicString eventType = listenersArray[i].eventType;
result->Set(v8String(eventType, args.GetIsolate()), listeners);
}
return result;
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if ((info.Length() == 1 && (V8ArrayBuffer::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))))) {
TestOverloadedConstructorsV8Internal::constructor1(info);
return;
}
if ((info.Length() == 1 && (V8ArrayBufferView::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))))) {
TestOverloadedConstructorsV8Internal::constructor2(info);
return;
}
if ((info.Length() == 1 && (V8Blob::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))))) {
TestOverloadedConstructorsV8Internal::constructor3(info);
return;
}
if (info.Length() == 1) {
TestOverloadedConstructorsV8Internal::constructor4(info);
return;
}
if (UNLIKELY(info.Length() < 1)) {
throwTypeError(ExceptionMessages::failedToConstruct("TestOverloadedConstructors", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
return;
}
throwUninformativeAndGenericTypeError(info.GetIsolate());
return;
}
void V8Clipboard::setDragImageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
Clipboard* clipboard = V8Clipboard::toNative(args.Holder());
if (!clipboard->isForDragAndDrop())
return;
if (args.Length() != 3) {
throwError(v8SyntaxError, "setDragImage: Invalid number of arguments", args.GetIsolate());
return;
}
int x = toInt32(args[1]);
int y = toInt32(args[2]);
Node* node = 0;
if (V8Node::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))
node = V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0]));
if (!node || !node->isElementNode()) {
throwTypeError("setDragImageFromElement: Invalid first argument", args.GetIsolate());
return;
}
if (toElement(node)->hasTagName(HTMLNames::imgTag) && !node->inDocument())
clipboard->setDragImage(toHTMLImageElement(node)->cachedImage(), IntPoint(x, y));
else
clipboard->setDragImageElement(node, IntPoint(x, y));
}
v8::Local<v8::Function> V8PerContextData::constructorForTypeSlowCase(const WrapperTypeInfo* type)
{
ASSERT(!m_errorPrototype.isEmpty());
v8::Context::Scope scope(m_context.newLocal(m_isolate));
v8::Handle<v8::FunctionTemplate> functionTemplate = type->domTemplate(m_isolate, worldType(m_isolate));
// Getting the function might fail if we're running out of stack or memory.
v8::TryCatch tryCatch;
v8::Local<v8::Function> function = functionTemplate->GetFunction();
if (function.IsEmpty())
return v8::Local<v8::Function>();
if (type->parentClass) {
v8::Local<v8::Object> prototypeTemplate = constructorForType(type->parentClass);
if (prototypeTemplate.IsEmpty())
return v8::Local<v8::Function>();
function->SetPrototype(prototypeTemplate);
}
v8::Local<v8::Value> prototypeValue = function->Get(v8AtomicString(m_isolate, "prototype"));
if (!prototypeValue.IsEmpty() && prototypeValue->IsObject()) {
v8::Local<v8::Object> prototypeObject = v8::Local<v8::Object>::Cast(prototypeValue);
if (prototypeObject->InternalFieldCount() == v8PrototypeInternalFieldcount
&& type->wrapperTypePrototype == WrapperTypeObjectPrototype)
prototypeObject->SetAlignedPointerInInternalField(v8PrototypeTypeIndex, const_cast<WrapperTypeInfo*>(type));
type->installPerContextEnabledMethods(prototypeObject, m_isolate);
if (type->wrapperTypePrototype == WrapperTypeExceptionPrototype)
prototypeObject->SetPrototype(m_errorPrototype.newLocal(m_isolate));
}
m_constructorMap.set(type, UnsafePersistent<v8::Function>(m_isolate, function));
return function;
}
void ScriptProfiler::visitNodeWrappers(WrappedNodeVisitor* visitor)
{
// visitNodeWrappers() should receive a ScriptState and retrieve an Isolate
// from the ScriptState.
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
class DOMNodeWrapperVisitor : public v8::PersistentHandleVisitor {
public:
DOMNodeWrapperVisitor(WrappedNodeVisitor* visitor, v8::Isolate* isolate)
: m_visitor(visitor)
, m_isolate(isolate)
{
}
virtual void VisitPersistentHandle(v8::Persistent<v8::Value> value, uint16_t classId) OVERRIDE
{
if (classId != v8DOMNodeClassId)
return;
UNUSED_PARAM(m_isolate);
ASSERT(V8Node::HasInstance(value, m_isolate, worldType(m_isolate)));
ASSERT(value->IsObject());
v8::Persistent<v8::Object> wrapper = v8::Persistent<v8::Object>::Cast(value);
m_visitor->visitNode(V8Node::toNative(wrapper));
}
private:
static v8::Local<v8::Object> wrapInShadowTemplate(v8::Local<v8::Object> wrapper, Node* impl, v8::Isolate* isolate)
{
// This is only for getting a unique pointer which we can pass to privateTemplate.
static const char* shadowTemplateUniqueKey = "wrapInShadowTemplate";
WrapperWorldType currentWorldType = worldType(isolate);
v8::Handle<v8::FunctionTemplate> shadowTemplate;
if (!V8PerIsolateData::from(isolate)->hasPrivateTemplate(currentWorldType, &shadowTemplateUniqueKey)) {
shadowTemplate = v8::FunctionTemplate::New();
if (shadowTemplate.IsEmpty())
return v8::Local<v8::Object>();
shadowTemplate->SetClassName(v8::String::NewSymbol("HTMLDocument"));
shadowTemplate->Inherit(V8HTMLDocument::GetTemplate(isolate, currentWorldType));
shadowTemplate->InstanceTemplate()->SetInternalFieldCount(V8HTMLDocument::internalFieldCount);
} else {
shadowTemplate = V8PerIsolateData::from(isolate)->privateTemplate(currentWorldType, &shadowTemplateUniqueKey, 0, v8::Handle<v8::Value>(), v8::Handle<v8::Signature>());
}
v8::Local<v8::Function> shadowConstructor = shadowTemplate->GetFunction();
if (shadowConstructor.IsEmpty())
return v8::Local<v8::Object>();
v8::Local<v8::Object> shadow = V8ScriptRunner::instantiateObject(shadowConstructor);
if (shadow.IsEmpty())
return v8::Local<v8::Object>();
shadow->SetPrototype(wrapper);
V8DOMWrapper::setNativeInfo(wrapper, &V8HTMLDocument::info, impl);
return shadow;
}
v8::Handle<v8::Value> V8InjectedScriptHost::typeMethodCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return v8::Undefined();
v8::Handle<v8::Value> value = args[0];
if (value->IsString())
return v8::String::NewSymbol("string");
if (value->IsArray())
return v8::String::NewSymbol("array");
if (value->IsBoolean())
return v8::String::NewSymbol("boolean");
if (value->IsNumber())
return v8::String::NewSymbol("number");
if (value->IsDate())
return v8::String::NewSymbol("date");
if (value->IsRegExp())
return v8::String::NewSymbol("regexp");
WrapperWorldType currentWorldType = worldType(args.GetIsolate());
if (V8Node::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("node");
if (V8NodeList::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
if (V8HTMLCollection::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
if (V8Int8Array::HasInstance(value, args.GetIsolate(), currentWorldType) || V8Int16Array::HasInstance(value, args.GetIsolate(), currentWorldType) || V8Int32Array::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
if (V8Uint8Array::HasInstance(value, args.GetIsolate(), currentWorldType) || V8Uint16Array::HasInstance(value, args.GetIsolate(), currentWorldType) || V8Uint32Array::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
if (V8Float32Array::HasInstance(value, args.GetIsolate(), currentWorldType) || V8Float64Array::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
if (V8Uint8ClampedArray::HasInstance(value, args.GetIsolate(), currentWorldType))
return v8::String::NewSymbol("array");
return v8::Undefined();
}
bool extractTransferables(v8::Local<v8::Value> value, MessagePortArray& ports, ArrayBufferArray& arrayBuffers, bool& notASequence, v8::Isolate* isolate)
{
if (isUndefinedOrNull(value)) {
ports.resize(0);
arrayBuffers.resize(0);
return true;
}
uint32_t length = 0;
if (value->IsArray()) {
v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(value);
length = array->Length();
} else if (toV8Sequence(value, length, isolate).IsEmpty()) {
notASequence = true;
return false;
}
v8::Local<v8::Object> transferrables = v8::Local<v8::Object>::Cast(value);
// Validate the passed array of transferrables.
for (unsigned int i = 0; i < length; ++i) {
v8::Local<v8::Value> transferrable = transferrables->Get(i);
// Validation of non-null objects, per HTML5 spec 10.3.3.
if (isUndefinedOrNull(transferrable)) {
setDOMException(DataCloneError, isolate);
return false;
}
// Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
if (V8MessagePort::hasInstance(transferrable, isolate, worldType(isolate))) {
RefPtr<MessagePort> port = V8MessagePort::toNative(v8::Handle<v8::Object>::Cast(transferrable));
// Check for duplicate MessagePorts.
if (ports.contains(port)) {
setDOMException(DataCloneError, isolate);
return false;
}
ports.append(port.release());
} else if (V8ArrayBuffer::hasInstance(transferrable, isolate, worldType(isolate)))
arrayBuffers.append(V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(transferrable)));
else {
setDOMException(DataCloneError, isolate);
return false;
}
}
return true;
}
PassRefPtr<IDBKeyRange> scriptValueToIDBKeyRange(DOMRequestState* state, const ScriptValue& scriptValue)
{
v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
v8::Handle<v8::Value> value(scriptValue.v8Value());
if (V8IDBKeyRange::hasInstance(value, isolate, worldType(isolate)))
return V8IDBKeyRange::toNative(value.As<v8::Object>());
return 0;
}
PassRefPtr<XPathNSResolver> toXPathNSResolver(v8::Handle<v8::Value> value, v8::Isolate* isolate)
{
RefPtr<XPathNSResolver> resolver;
if (V8XPathNSResolver::HasInstance(value, isolate, worldType(isolate)))
resolver = V8XPathNSResolver::toNative(v8::Handle<v8::Object>::Cast(value));
else if (value->IsObject())
resolver = V8CustomXPathNSResolver::create(value->ToObject(), isolate);
return resolver;
}
static void constructor3(const v8::FunctionCallbackInfo<v8::Value>& info)
{
V8TRYCATCH_VOID(Blob*, blob, V8Blob::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0);
RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(blob);
v8::Handle<v8::Object> wrapper = info.Holder();
V8DOMWrapper::associateObjectWithWrapper<V8TestOverloadedConstructors>(impl.release(), &V8TestOverloadedConstructors::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
info.GetReturnValue().Set(wrapper);
}
static v8::Handle<v8::Value> constructor3(const v8::Arguments& args)
{
V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(blob);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8TestOverloadedConstructors::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
bool Dictionary::get(const String& key, RefPtr<SpeechRecognitionResultList>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
value = 0;
if (V8SpeechRecognitionResultList::HasInstance(v8Value, m_isolate, worldType(m_isolate)))
value = V8SpeechRecognitionResultList::toNative(v8::Handle<v8::Object>::Cast(v8Value));
return true;
}
v8::Handle<v8::Value> removeElement(HTMLSelectElement* imp, const v8::Arguments& args)
{
if (V8HTMLOptionElement::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate()))) {
HTMLOptionElement* element = V8HTMLOptionElement::toNative(v8::Handle<v8::Object>::Cast(args[0]));
imp->remove(element->index());
return v8::Undefined();
}
imp->remove(toInt32(args[0]));
return v8::Undefined();
}
void V8InjectedScriptHost::storageIdMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() > 0 && V8Storage::HasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))) {
Storage* storage = V8Storage::toNative(v8::Handle<v8::Object>::Cast(info[0]));
if (storage) {
InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
v8SetReturnValueStringOrUndefined(info, host->storageIdImpl(storage), info.GetIsolate());
return;
}
}
}
bool Dictionary::get(const String& key, RefPtr<MediaStream>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
value = 0;
if (V8MediaStream::HasInstance(v8Value, m_isolate, worldType(m_isolate)))
value = V8MediaStream::toNative(v8::Handle<v8::Object>::Cast(v8Value));
return true;
}
v8::Handle<v8::Value> V8DataView::constructorCustom(const v8::Arguments& args)
{
if (!args.Length()) {
// see constructWebGLArray -- we don't seem to be able to distingish between
// 'new DataView()' and the call used to construct the cached DataView object.
RefPtr<DataView> dataView = DataView::create(0);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(dataView.release(), &info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
if (args[0]->IsNull() || !V8ArrayBuffer::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))
return throwTypeError(0, args.GetIsolate());
return constructWebGLArrayWithArrayBufferArgument<DataView, char>(args, &info, v8::kExternalByteArray, false);
}
static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
{
if ((args.Length() == 1 && (V8ArrayBuffer::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))))
return TestOverloadedConstructorsV8Internal::constructor1(args);
if ((args.Length() == 1 && (V8ArrayBufferView::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))))
return TestOverloadedConstructorsV8Internal::constructor2(args);
if ((args.Length() == 1 && (V8Blob::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())))))
return TestOverloadedConstructorsV8Internal::constructor3(args);
if (args.Length() == 1)
return TestOverloadedConstructorsV8Internal::constructor4(args);
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
return throwTypeError(0, args.GetIsolate());
}
v8::Handle<v8::Value> V8XMLHttpRequest::sendMethodCustom(const v8::Arguments& args)
{
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(args.Holder());
InspectorInstrumentation::willSendXMLHttpRequest(xmlHttpRequest->scriptExecutionContext(), xmlHttpRequest->url());
ExceptionCode ec = 0;
if (args.Length() < 1)
xmlHttpRequest->send(ec);
else {
v8::Handle<v8::Value> arg = args[0];
WrapperWorldType currentWorldType = worldType(args.GetIsolate());
if (isUndefinedOrNull(arg))
xmlHttpRequest->send(ec);
else if (isDocumentType(arg, args.GetIsolate(), currentWorldType)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
Document* document = V8Document::toNative(object);
ASSERT(document);
xmlHttpRequest->send(document, ec);
} else if (V8Blob::HasInstance(arg, args.GetIsolate(), currentWorldType)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
Blob* blob = V8Blob::toNative(object);
ASSERT(blob);
xmlHttpRequest->send(blob, ec);
} else if (V8DOMFormData::HasInstance(arg, args.GetIsolate(), currentWorldType)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
DOMFormData* domFormData = V8DOMFormData::toNative(object);
ASSERT(domFormData);
xmlHttpRequest->send(domFormData, ec);
#if ENABLE(WEBGL) || ENABLE(BLOB)
} else if (V8ArrayBuffer::HasInstance(arg, args.GetIsolate(), currentWorldType)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(object);
ASSERT(arrayBuffer);
xmlHttpRequest->send(arrayBuffer, ec);
} else if (V8ArrayBufferView::HasInstance(arg, args.GetIsolate(), currentWorldType)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(object);
ASSERT(arrayBufferView);
xmlHttpRequest->send(arrayBufferView, ec);
#endif
} else
xmlHttpRequest->send(toWebCoreStringWithNullCheck(arg), ec);
}
if (ec)
return setDOMException(ec, args.GetIsolate());
return v8::Undefined();
}
v8::Handle<v8::Value> V8Document::evaluateMethodCustom(const v8::Arguments& args)
{
RefPtr<Document> document = V8Document::toNative(args.Holder());
ExceptionCode ec = 0;
String expression = toWebCoreString(args[0]);
RefPtr<Node> contextNode;
if (V8Node::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())))
contextNode = V8Node::toNative(v8::Handle<v8::Object>::Cast(args[1]));
RefPtr<XPathNSResolver> resolver = toXPathNSResolver(args[2], args.GetIsolate());
if (!resolver && !args[2]->IsNull() && !args[2]->IsUndefined())
return setDOMException(TYPE_MISMATCH_ERR, args.GetIsolate());
int type = toInt32(args[3]);
RefPtr<XPathResult> inResult;
if (V8XPathResult::HasInstance(args[4], args.GetIsolate(), worldType(args.GetIsolate())))
inResult = V8XPathResult::toNative(v8::Handle<v8::Object>::Cast(args[4]));
V8TRYCATCH(RefPtr<XPathResult>, result, document->evaluate(expression, contextNode.get(), resolver.get(), type, inResult.get(), ec));
if (ec)
return setDOMException(ec, args.GetIsolate());
return toV8Fast(result.release(), args, document.get());
}
static v8::Handle<v8::Value> dispatchEventMethod(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestEventTarget* imp = V8TestEventTarget::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Event*, evt, V8Event::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Event::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
bool result = imp->dispatchEvent(evt, ec);
if (UNLIKELY(ec))
goto fail;
return v8Boolean(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
void V8HTMLMediaElement::controllerAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
MediaController* controller = 0;
if (!value->IsNull()) {
if (!V8MediaController::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) {
throwTypeError("Value is not of type MediaController", info.GetIsolate());
return;
}
controller = V8MediaController::toNative(value->ToObject());
}
// 4.8.10.11.2 Media controllers: controller attribute.
// On setting, it must first remove the element's mediagroup attribute, if any,
HTMLMediaElement* imp = V8HTMLMediaElement::toNative(info.Holder());
imp->setMediaGroup(String());
// and then set the current media controller to the given value.
imp->setController(controller);
}
void V8AudioBufferSourceNode::bufferAttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
v8::Handle<v8::Object> holder = info.Holder();
AudioBufferSourceNode* imp = V8AudioBufferSourceNode::toNative(holder);
AudioBuffer* buffer = 0;
if (V8AudioBuffer::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) {
buffer = V8AudioBuffer::toNative(value->ToObject());
if (buffer && !imp->setBuffer(buffer)) {
throwTypeError("AudioBuffer unsupported number of channels", info.GetIsolate());
return;
}
}
if (!buffer) {
throwTypeError("Value is not of type AudioBuffer", info.GetIsolate());
return;
}
}
PassRefPtr<DOMStringList> toDOMStringList(v8::Handle<v8::Value> value, v8::Isolate* isolate)
{
v8::Local<v8::Value> v8Value(v8::Local<v8::Value>::New(isolate, value));
if (V8DOMStringList::HasInstance(v8Value, isolate, worldType(isolate))) {
RefPtr<DOMStringList> ret = V8DOMStringList::toNative(v8::Handle<v8::Object>::Cast(v8Value));
return ret.release();
}
if (!v8Value->IsArray())
return 0;
RefPtr<DOMStringList> ret = DOMStringList::create();
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(i, isolate));
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, 0);
ret->append(stringValue);
}
return ret.release();
}