static v8::Handle<v8::Value> noteOnCallback(const v8::Arguments& args)
{
FeatureObserver::observe(activeDOMWindow(BindingState::instance()), FeatureObserver::LegacyWebAudio);
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
AudioBufferSourceNode* imp = V8AudioBufferSourceNode::toNative(args.Holder());
V8TRYCATCH(double, when, static_cast<double>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));
imp->noteOn(when);
return v8Undefined();
}
static v8::Handle<v8::Value> postMessageCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestActiveDOMObject.postMessage");
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(args.Holder());
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, message, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
imp->postMessage(message);
return v8Undefined();
}
static v8::Handle<v8::Value> setValueAndClosePopupCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
PagePopupController* imp = V8PagePopupController::toNative(args.Holder());
V8TRYCATCH(int, numberValue, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, stringValue, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
imp->setValueAndClosePopup(numberValue, stringValue);
return v8Undefined();
}
static v8::Handle<v8::Value> supplementalMethod2Callback(const v8::Arguments& args)
{
INC_STATS("DOM.TestInterface.supplementalMethod2");
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestInterface* imp = V8TestInterface::toNative(args.Holder());
ExceptionCode ec = 0;
{
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
RefPtr<TestObj> result = TestSupplemental::supplementalMethod2(scriptContext, imp, strArg, objArg, ec);
if (UNLIKELY(ec))
goto fail;
return toV8(result.release(), args.Holder(), args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8XMLHttpRequest::openMethodCustom(const v8::Arguments& args)
{
// Four cases:
// open(method, url)
// open(method, url, async)
// open(method, url, async, user)
// open(method, url, async, user, passwd)
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(args.Holder());
String method = toWebCoreString(args[0]);
String urlstring = toWebCoreString(args[1]);
ScriptExecutionContext* context = getScriptExecutionContext();
KURL url = context->completeURL(urlstring);
ExceptionCode ec = 0;
if (args.Length() >= 3) {
bool async = args[2]->BooleanValue();
if (args.Length() >= 4 && !args[3]->IsUndefined()) {
String user = toWebCoreStringWithNullCheck(args[3]);
if (args.Length() >= 5 && !args[4]->IsUndefined()) {
String passwd = toWebCoreStringWithNullCheck(args[4]);
xmlHttpRequest->open(method, url, async, user, passwd, ec);
} else
xmlHttpRequest->open(method, url, async, user, ec);
} else
xmlHttpRequest->open(method, url, async, ec);
} else
xmlHttpRequest->open(method, url, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
return v8::Undefined();
}
static v8::Handle<v8::Value> multiTransferListMethod(const v8::Arguments& args)
{
TestSerializedScriptValueInterface* imp = V8TestSerializedScriptValueInterface::toNative(args.Holder());
if (args.Length() <= 0) {
imp->multiTransferList();
return v8Undefined();
}
MessagePortArray messagePortArrayTx;
ArrayBufferArray arrayBufferArrayTx;
if (args.Length() > 1) {
if (!extractTransferables(args[1], messagePortArrayTx, arrayBufferArrayTx, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool firstDidThrow = false;
RefPtr<SerializedScriptValue> first = SerializedScriptValue::create(args[0], &messagePortArrayTx, &arrayBufferArrayTx, firstDidThrow, args.GetIsolate());
if (firstDidThrow)
return v8Undefined();
if (args.Length() <= 1) {
imp->multiTransferList(first);
return v8Undefined();
}
if (args.Length() <= 2) {
imp->multiTransferList(first, messagePortArrayTx);
return v8Undefined();
}
MessagePortArray messagePortArrayTxx;
ArrayBufferArray arrayBufferArrayTxx;
if (args.Length() > 3) {
if (!extractTransferables(args[3], messagePortArrayTxx, arrayBufferArrayTxx, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool secondDidThrow = false;
RefPtr<SerializedScriptValue> second = SerializedScriptValue::create(args[2], &messagePortArrayTxx, &arrayBufferArrayTxx, secondDidThrow, args.GetIsolate());
if (secondDidThrow)
return v8Undefined();
if (args.Length() <= 3) {
imp->multiTransferList(first, messagePortArrayTx, second);
return v8Undefined();
}
imp->multiTransferList(first, messagePortArrayTx, second, messagePortArrayTxx);
return v8Undefined();
}
v8::Handle<v8::Value> SetTimeoutOrInterval(const v8::Arguments& args, bool singleShot)
{
WorkerContext* workerContext = V8WorkerContext::toNative(args.Holder());
int argumentCount = args.Length();
if (argumentCount < 1)
return v8::Undefined();
v8::Handle<v8::Value> function = args[0];
int32_t timeout = argumentCount >= 2 ? args[1]->Int32Value() : 0;
int timerId;
WorkerContextExecutionProxy* proxy = workerContext->script()->proxy();
if (!proxy)
return v8::Undefined();
v8::Handle<v8::Context> v8Context = proxy->context();
if (function->IsString()) {
if (ContentSecurityPolicy* policy = workerContext->contentSecurityPolicy()) {
if (!policy->allowEval())
return v8Integer(0, args.GetIsolate());
}
WTF::String stringFunction = toWebCoreString(function);
timerId = DOMTimer::install(workerContext, adoptPtr(new ScheduledAction(v8Context, stringFunction, workerContext->url())), timeout, singleShot);
} else if (function->IsFunction()) {
size_t paramCount = argumentCount >= 2 ? argumentCount - 2 : 0;
v8::Local<v8::Value>* params = 0;
if (paramCount > 0) {
params = new v8::Local<v8::Value>[paramCount];
for (size_t i = 0; i < paramCount; ++i)
params[i] = args[i+2];
}
// ScheduledAction takes ownership of actual params and releases them in its destructor.
OwnPtr<ScheduledAction> action = adoptPtr(new ScheduledAction(v8Context, v8::Handle<v8::Function>::Cast(function), paramCount, params));
// FIXME: We should use a OwnArrayPtr for params.
delete [] params;
timerId = DOMTimer::install(workerContext, action.release(), timeout, singleShot);
} else
return v8::Undefined();
return v8Integer(timerId, args.GetIsolate());
}
v8::Handle<v8::Value> V8AudioContext::constructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.AudioContext.Contructor");
if (!args.IsConstructCall())
return throwTypeError("AudioContext constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
Document* document = currentDocument(BindingState::instance());
RefPtr<AudioContext> audioContext;
if (!args.Length()) {
// Constructor for default AudioContext which talks to audio hardware.
ExceptionCode ec = 0;
audioContext = AudioContext::create(document, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
if (!audioContext.get())
return throwError(SyntaxError, "audio resources unavailable for AudioContext construction", args.GetIsolate());
} else {
// Constructor for offline (render-target) AudioContext which renders into an AudioBuffer.
// new AudioContext(in unsigned long numberOfChannels, in unsigned long numberOfFrames, in float sampleRate);
if (args.Length() < 3)
return throwNotEnoughArgumentsError(args.GetIsolate());
bool ok = false;
int32_t numberOfChannels = toInt32(args[0], ok);
if (!ok || numberOfChannels <= 0 || numberOfChannels > 10)
return throwError(SyntaxError, "Invalid number of channels", args.GetIsolate());
int32_t numberOfFrames = toInt32(args[1], ok);
if (!ok || numberOfFrames <= 0)
return throwError(SyntaxError, "Invalid number of frames", args.GetIsolate());
float sampleRate = toFloat(args[2]);
if (sampleRate <= 0)
return throwError(SyntaxError, "Invalid sample rate", args.GetIsolate());
ExceptionCode ec = 0;
audioContext = AudioContext::createOfflineContext(document, numberOfChannels, numberOfFrames, sampleRate, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
}
if (!audioContext.get())
return throwError(SyntaxError, "Error creating AudioContext", args.GetIsolate());
// Transform the holder into a wrapper object for the audio context.
V8DOMWrapper::setDOMWrapper(args.Holder(), &info, audioContext.get());
audioContext->ref();
return args.Holder();
}
static v8::Handle<v8::Value> saveCallback(const v8::Arguments& args)
{
if (args.Length() < 3)
return throwNotEnoughArgumentsError(args.GetIsolate());
InspectorFrontendHost* imp = V8InspectorFrontendHost::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, url, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, content, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
V8TRYCATCH(bool, forceSaveAs, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->BooleanValue());
imp->save(url, content, forceSaveAs);
return v8Undefined();
}
static v8::Handle<v8::Value> setVelocityCallback(const v8::Arguments& args)
{
if (args.Length() < 3)
return throwNotEnoughArgumentsError(args.GetIsolate());
PannerNode* imp = V8PannerNode::toNative(args.Holder());
V8TRYCATCH(float, x, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));
V8TRYCATCH(float, y, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->NumberValue()));
V8TRYCATCH(float, z, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->NumberValue()));
imp->setVelocity(x, y, z);
return v8Undefined();
}
static v8::Handle<v8::Value> excitingFunctionCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(args.Holder());
if (!BindingSecurity::shouldAllowAccessToFrame(BindingState::instance(), imp->frame()))
return v8Undefined();
V8TRYCATCH(Node*, nextChild, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
imp->excitingFunction(nextChild);
return v8Undefined();
}
static v8::Handle<v8::Value> histogramEnumerationCallback(const v8::Arguments& args)
{
if (args.Length() < 3)
return throwNotEnoughArgumentsError(args.GetIsolate());
PagePopupController* imp = V8PagePopupController::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, name, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH(int, sample, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
V8TRYCATCH(int, boundaryValue, toInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));
imp->histogramEnumeration(name, sample, boundaryValue);
return v8Undefined();
}
v8::Handle<v8::Value> V8Document::createTouchListMethodCustom(const v8::Arguments& args)
{
RefPtr<TouchList> touchList = TouchList::create();
for (int i = 0; i < args.Length(); i++) {
Touch* touch = V8DOMWrapper::isWrapperOfType(args[i], &V8Touch::info) ? V8Touch::toNative(args[i]->ToObject()) : 0;
touchList->append(touch);
}
return toV8(touchList.release(), args.Holder(), args.GetIsolate());
}
v8::Handle<v8::Value> V8HTMLFormControlsCollection::namedItemCallback(const v8::Arguments& args)
{
INC_STATS("DOM.HTMLCollection.namedItem()");
HTMLFormControlsCollection* imp = V8HTMLFormControlsCollection::toNative(args.Holder());
v8::Handle<v8::Value> result = getNamedItems(imp, toWebCoreString(args[0]), args.Holder(), args.GetIsolate());
if (result.IsEmpty())
return v8::Undefined(args.GetIsolate());
return result;
}
static v8::Handle<v8::Value> getFrequencyResponseCallback(const v8::Arguments& args)
{
if (args.Length() < 3)
return throwNotEnoughArgumentsError(args.GetIsolate());
BiquadFilterNode* imp = V8BiquadFilterNode::toNative(args.Holder());
V8TRYCATCH(Float32Array*, frequencyHz, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
V8TRYCATCH(Float32Array*, magResponse, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined))) : 0);
V8TRYCATCH(Float32Array*, phaseResponse, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
imp->getFrequencyResponse(frequencyHz, magResponse, phaseResponse);
return v8Undefined();
}
v8::Handle<v8::Value> V8InjectedScriptHost::storageIdCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return v8::Undefined();
INC_STATS("InjectedScriptHost.storageId()");
InjectedScriptHost* host = V8InjectedScriptHost::toNative(args.Holder());
Storage* storage = V8Storage::toNative(v8::Handle<v8::Object>::Cast(args[0]));
if (storage)
return v8StringOrUndefined(host->storageIdImpl(storage), args.GetIsolate());
return v8::Undefined();
}
v8::Handle<v8::Value> V8DOMFormData::constructorCallbackCustom(const v8::Arguments& args)
{
HTMLFormElement* form = 0;
if (args.Length() > 0 && V8HTMLFormElement::HasInstance(args[0]))
form = V8HTMLFormElement::toNative(args[0]->ToObject());
RefPtr<DOMFormData> domFormData = DOMFormData::create(form);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(domFormData.release(), &info, wrapper, args.GetIsolate());
return wrapper;
}
static v8::Handle<v8::Value> constructor(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
ExceptionCode ec = 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, args[0]);
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, args[1]);
ScriptExecutionContext* context = getScriptExecutionContext();
RefPtr<TestInterface> impl = TestInterface::create(context, str1, str2, ec);
v8::Handle<v8::Object> wrapper = args.Holder();
if (ec)
goto fail;
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8TestInterface::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8SVGLength::convertToSpecifiedUnitsCallback(const v8::Arguments& args)
{
INC_STATS("DOM.SVGLength.convertToSpecifiedUnits");
SVGPropertyTearOff<SVGLength>* wrapper = V8SVGLength::toNative(args.Holder());
if (wrapper->role() == AnimValRole)
return V8Proxy::setDOMException(NO_MODIFICATION_ALLOWED_ERR, args.GetIsolate());
if (args.Length() < 1)
return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
SVGLength& imp = wrapper->propertyReference();
ExceptionCode ec = 0;
EXCEPTION_BLOCK(int, unitType, toUInt32(args[0]));
SVGLengthContext lengthContext(wrapper->contextElement());
imp.convertToSpecifiedUnits(unitType, lengthContext, ec);
if (UNLIKELY(ec))
return V8Proxy::setDOMException(ec, args.GetIsolate());
wrapper->commitChange();
return v8::Handle<v8::Value>();
}
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> V8InjectedScriptHost::inspectedObjectMethodCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return v8::Undefined();
if (!args[0]->IsInt32())
return throwTypeError("argument has to be an integer", args.GetIsolate());
InjectedScriptHost* host = V8InjectedScriptHost::toNative(args.Holder());
InjectedScriptHost::InspectableObject* object = host->inspectedObject(args[0]->ToInt32()->Value());
return object->get(ScriptState::current()).v8Value();
}
void V8WebCLPlatform::getSupportedExtensionsMethodCustom(const v8::Arguments& args)
{
ExceptionState es(args.GetIsolate());
WebCLPlatform* platform = V8WebCLPlatform::toNative(args.Holder());
Vector<String> extensions = platform->getSupportedExtensions(es);
v8::Local<v8::Array> array = v8::Array::New(extensions.size());
for (size_t i = 0; i < extensions.size(); i++)
array->Set(v8::Integer::New(i), v8::String::New(fromWebCoreString(extensions[i]), extensions[i].length()));
v8SetReturnValue(args, array);
}
static v8::Handle<v8::Value> excitingFunctionCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestActiveDOMObject.excitingFunction");
if (args.Length() < 1)
return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(args.Holder());
if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
return v8::Handle<v8::Value>();
EXCEPTION_BLOCK(Node*, nextChild, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
imp->excitingFunction(nextChild);
return v8::Handle<v8::Value>();
}
static v8::Handle<v8::Value> queryUsageAndQuotaCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
StorageInfo* imp = V8StorageInfo::toNative(args.Holder());
V8TRYCATCH(int, storageType, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
RefPtr<StorageInfoUsageCallback> usageCallback;
if (args.Length() > 1 && !args[1]->IsNull() && !args[1]->IsUndefined()) {
if (!args[1]->IsFunction())
return throwTypeError(0, args.GetIsolate());
usageCallback = V8StorageInfoUsageCallback::create(args[1], getScriptExecutionContext());
}
RefPtr<StorageInfoErrorCallback> errorCallback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8StorageInfoErrorCallback::create(args[2], getScriptExecutionContext());
}
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
imp->queryUsageAndQuota(scriptContext, storageType, usageCallback, errorCallback);
return v8Undefined();
}
static v8::Handle<v8::Value> clearCallback(const v8::Arguments& args)
{
RefPtr<SVGStaticListPropertyTearOff<SVGStringList> > imp = V8SVGStringList::toNative(args.Holder());
ExceptionCode ec = 0;
{
imp->clear(ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8HTMLAllCollection::callAsFunctionCallback(const v8::Arguments& args)
{
INC_STATS("DOM.HTMLAllCollection.callAsFunction()");
if (args.Length() < 1)
return v8::Undefined();
HTMLAllCollection* imp = V8HTMLAllCollection::toNative(args.Holder());
if (args.Length() == 1)
return getItem(imp, args[0], args.Holder(), args.GetIsolate());
// If there is a second argument it is the index of the item we want.
String name = toWebCoreString(args[0]);
v8::Local<v8::Uint32> index = args[1]->ToArrayIndex();
if (index.IsEmpty())
return v8::Undefined();
if (Node* node = imp->namedItemWithIndex(name, index->Uint32Value()))
return toV8(node, args.Holder(), args.GetIsolate());
return v8::Undefined();
}
static v8::Handle<v8::Value> V8TestNamedConstructorConstructorCallback(const v8::Arguments& args)
{
INC_STATS("DOM.TestNamedConstructor.Constructor");
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.");
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
Frame* frame = currentFrame(BindingState::instance());
if (!frame)
return throwError(ReferenceError, "TestNamedConstructor constructor associated frame is unavailable", args.GetIsolate());
Document* document = frame->document();
// Make sure the document is added to the DOM Node map. Otherwise, the TestNamedConstructor instance
// may end up being the only node in the map and get garbage-collected prematurely.
toV8(document, args.GetIsolate());
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
ExceptionCode ec = 0;
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str1, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str2, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, str3, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsNullString));
RefPtr<TestNamedConstructor> impl = TestNamedConstructor::createForJSConstructor(document, str1, str2, str3, ec);
v8::Handle<v8::Object> wrapper = args.Holder();
if (ec)
goto fail;
V8DOMWrapper::setDOMWrapper(wrapper, &V8TestNamedConstructorConstructor::info, impl.get());
V8DOMWrapper::setJSWrapperForActiveDOMObject(impl.release(), wrapper, args.GetIsolate());
return wrapper;
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8Worker::postMessageMethodCustom(const v8::Arguments& args)
{
Worker* worker = V8Worker::toNative(args.Holder());
MessagePortArray ports;
ArrayBufferArray arrayBuffers;
if (args.Length() > 1) {
if (!extractTransferables(args[1], ports, arrayBuffers, args.GetIsolate()))
return v8::Undefined();
}
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(args[0],
&ports,
&arrayBuffers,
didThrow,
args.GetIsolate());
if (didThrow)
return v8::Undefined();
ExceptionCode ec = 0;
worker->postMessage(message.release(), &ports, ec);
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> addRuleCallback(const v8::Arguments& args)
{
CSSStyleSheet* imp = V8CSSStyleSheet::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, selector, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, style, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
if (args.Length() <= 2) {
int result = imp->addRule(selector, style, ec);
if (UNLIKELY(ec))
goto fail;
return v8Integer(result, args.GetIsolate());
}
V8TRYCATCH(unsigned, index, toUInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));
int result = imp->addRule(selector, style, index, ec);
if (UNLIKELY(ec))
goto fail;
return v8Integer(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8InjectedScriptHost::databaseIdCallback(const v8::Arguments& args)
{
INC_STATS("InjectedScriptHost.databaseId()");
if (args.Length() < 1)
return v8::Undefined();
#if ENABLE(SQL_DATABASE)
InjectedScriptHost* host = V8InjectedScriptHost::toNative(args.Holder());
Database* database = V8Database::toNative(v8::Handle<v8::Object>::Cast(args[0]));
if (database)
return v8StringOrUndefined(host->databaseIdImpl(database), args.GetIsolate());
#endif
return v8::Undefined();
}