static v8::Handle<v8::Value> changeVersionCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
Database* imp = V8Database::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, oldVersion, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, newVersion, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
RefPtr<SQLTransactionCallback> callback;
if (args.Length() > 2 && !args[2]->IsNull() && !args[2]->IsUndefined()) {
if (!args[2]->IsFunction())
return throwTypeError(0, args.GetIsolate());
callback = V8SQLTransactionCallback::create(args[2], getScriptExecutionContext());
}
RefPtr<SQLTransactionErrorCallback> errorCallback;
if (args.Length() > 3 && !args[3]->IsNull() && !args[3]->IsUndefined()) {
if (!args[3]->IsFunction())
return throwTypeError(0, args.GetIsolate());
errorCallback = V8SQLTransactionErrorCallback::create(args[3], getScriptExecutionContext());
}
RefPtr<VoidCallback> successCallback;
if (args.Length() > 4 && !args[4]->IsNull() && !args[4]->IsUndefined()) {
if (!args[4]->IsFunction())
return throwTypeError(0, args.GetIsolate());
successCallback = V8VoidCallback::create(args[4], getScriptExecutionContext());
}
imp->changeVersion(oldVersion, newVersion, callback, errorCallback, successCallback);
return v8Undefined();
}
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();
Document* document = currentDocument(BindingState::instance());
// 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.Holder(), args.GetIsolate());
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
ExceptionCode ec = 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str1, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str2, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, 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::createDOMWrapper(impl.release(), &V8TestNamedConstructorConstructor::info, wrapper, args.GetIsolate());
return wrapper;
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> V8TestNamedConstructorConstructorCallback(const v8::Arguments& args)
{
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
Document* document = currentDocument();
// 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.Holder(), args.GetIsolate());
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]);
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str3, argumentOrNull(args, 2));
RefPtr<TestNamedConstructor> impl = TestNamedConstructor::createForJSConstructor(document, str1, str2, str3, ec);
v8::Handle<v8::Object> wrapper = args.Holder();
if (ec)
return setDOMException(ec, args.GetIsolate());
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8TestNamedConstructorConstructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
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());
}
static v8::Handle<v8::Value> webkitGetEntriesByNameCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Performance* imp = V8Performance::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, name, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, entryType, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsNullString));
return toV8(imp->webkitGetEntriesByName(name, entryType), args.Holder(), args.GetIsolate());
}
static v8::Handle<v8::Value> appendCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
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));
imp->append(url, content);
return v8Undefined();
}
static v8::Handle<v8::Value> initMutationEventCallback(const v8::Arguments& args)
{
MutationEvent* imp = V8MutationEvent::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH(bool, canBubble, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)->BooleanValue());
V8TRYCATCH(bool, cancelable, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)->BooleanValue());
V8TRYCATCH(Node*, relatedNode, V8Node::HasInstance(MAYBE_MISSING_PARAMETER(args, 3, DefaultIsUndefined)) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 3, DefaultIsUndefined))) : 0);
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, prevValue, MAYBE_MISSING_PARAMETER(args, 4, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, newValue, MAYBE_MISSING_PARAMETER(args, 5, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, attrName, MAYBE_MISSING_PARAMETER(args, 6, DefaultIsUndefined));
V8TRYCATCH(int, attrChange, toUInt32(MAYBE_MISSING_PARAMETER(args, 7, DefaultIsUndefined)));
imp->initMutationEvent(type, canBubble, cancelable, relatedNode, prevValue, newValue, attrName, attrChange);
return v8Undefined();
}
v8::Handle<v8::Value> V8History::replaceStateMethodCustom(const v8::Arguments& args)
{
bool didThrow = false;
RefPtr<SerializedScriptValue> historyState = SerializedScriptValue::create(args[0], 0, 0, didThrow, args.GetIsolate());
if (didThrow)
return v8::Undefined();
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, title, args[1]);
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, url, argumentOrNull(args, 2));
ExceptionCode ec = 0;
History* history = V8History::toNative(args.Holder());
history->stateObjectAdded(historyState.release(), title, url, History::StateObjectReplace, ec);
args.Holder()->DeleteHiddenValue(V8HiddenPropertyName::state());
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> webkitClearMeasuresCallback(const v8::Arguments& args)
{
Performance* imp = V8Performance::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, measureName, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsNullString));
imp->webkitClearMeasures(measureName);
return v8Undefined();
}
static v8::Handle<v8::Value> readAsTextCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
FileReaderSync* imp = V8FileReaderSync::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(Blob*, blob, V8Blob::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Blob::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
if (args.Length() <= 1) {
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
String result = imp->readAsText(scriptContext, blob, ec);
if (UNLIKELY(ec))
goto fail;
return v8String(result, args.GetIsolate());
}
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, encoding, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
ScriptExecutionContext* scriptContext = getScriptExecutionContext();
String result = imp->readAsText(scriptContext, blob, encoding, ec);
if (UNLIKELY(ec))
goto fail;
return v8String(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> setRGBColorICCColorCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
SVGColor* imp = V8SVGColor::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, rgbColor, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, iccColor, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
imp->setRGBColorICCColor(rgbColor, iccColor, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> namedItemCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
DOMNamedFlowCollection* imp = V8DOMNamedFlowCollection::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, name, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
return toV8(imp->namedItem(name), args.Holder(), args.GetIsolate());
}
static v8::Handle<v8::Value> unregisterProtocolHandlerCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwNotEnoughArgumentsError(args.GetIsolate());
Navigator* imp = V8Navigator::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, scheme, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, url, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
NavigatorContentUtils::unregisterProtocolHandler(imp, scheme, url, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> localizeNumberStringCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
PagePopupController* imp = V8PagePopupController::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, numberString, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
return v8String(imp->localizeNumberString(numberString), args.GetIsolate());
}
static v8::Handle<v8::Value> webkitMeasureCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Performance* imp = V8Performance::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, measureName, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, startMark, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsNullString));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, endMark, MAYBE_MISSING_PARAMETER(args, 2, DefaultIsNullString));
imp->webkitMeasure(measureName, startMark, endMark, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> setCustomValidityCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
HTMLButtonElement* imp = V8HTMLButtonElement::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithUndefinedOrNullCheck>, error, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
imp->setCustomValidity(error);
return v8Undefined();
}
static v8::Handle<v8::Value> anotherFunctionMethod(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestCustomNamedGetter* imp = V8TestCustomNamedGetter::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]);
imp->anotherFunction(str);
return v8Undefined();
}
static v8::Handle<v8::Value> copyTextCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
InjectedScriptHost* imp = V8InjectedScriptHost::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, text, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
imp->copyText(text);
return v8Undefined();
}
static v8::Handle<v8::Value> anotherFunctionCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestCustomNamedGetter* imp = V8TestCustomNamedGetter::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
imp->anotherFunction(str);
return v8Undefined();
}
static v8::Handle<v8::Value> postMessageCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, 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> removeEventListenerCallback(const v8::Arguments& args)
{
RefPtr<EventListener> listener = V8DOMWrapper::getEventListener(args[1], false, ListenerFindOnly);
if (listener) {
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithNullCheck>, stringResource, args[0]);
V8MediaSource::toNative(args.Holder())->removeEventListener(stringResource, listener.get(), args[2]->BooleanValue());
removeHiddenDependency(args.Holder(), args[1], V8MediaSource::eventListenerCacheIndex);
}
return v8Undefined();
}
static v8::Handle<v8::Value> constructor4(const v8::Arguments& args)
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, string, args[0]);
RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(string);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &V8TestOverloadedConstructors::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
return wrapper;
}
static v8::Handle<v8::Value> addEventListenerMethod(const v8::Arguments& args)
{
RefPtr<EventListener> listener = V8EventListenerList::getEventListener(args[1], false, ListenerFindOrCreate);
if (listener) {
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<WithNullCheck>, stringResource, args[0]);
V8TestEventTarget::toNative(args.Holder())->addEventListener(stringResource, listener, args[2]->BooleanValue());
createHiddenDependency(args.Holder(), args[1], V8TestEventTarget::eventListenerCacheIndex, args.GetIsolate());
}
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> V8Intent::constructorCallbackCustom(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
if (args.Length() == 1) {
// Use the dictionary constructor. This block will return if the
// argument isn't a valid Dictionary.
V8TRYCATCH(Dictionary, options, Dictionary(args[0], args.GetIsolate()));
ExceptionCode ec = 0;
RefPtr<Intent> impl = Intent::create(ScriptState::current(), options, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &info, wrapper, args.GetIsolate());
return wrapper;
}
ExceptionCode ec = 0;
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, action, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
MessagePortArray messagePortArrayTransferList;
ArrayBufferArray arrayBufferArrayTransferList;
if (args.Length() > 3) {
if (!extractTransferables(args[3], messagePortArrayTransferList, arrayBufferArrayTransferList, args.GetIsolate()))
return throwTypeError("Could not extract transferables", args.GetIsolate());
}
bool dataDidThrow = false;
RefPtr<SerializedScriptValue> data = SerializedScriptValue::create(args[2], &messagePortArrayTransferList, &arrayBufferArrayTransferList, dataDidThrow);
if (dataDidThrow)
return setDOMException(DATA_CLONE_ERR, args.GetIsolate());
RefPtr<Intent> impl = Intent::create(action, type, data, messagePortArrayTransferList, ec);
if (ec)
return setDOMException(ec, args.GetIsolate());
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper(impl.release(), &info, wrapper, args.GetIsolate());
return wrapper;
}
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());
}
static v8::Handle<v8::Value> endOfStreamCallback(const v8::Arguments& args)
{
MediaSource* imp = V8MediaSource::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, error, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsNullString));
imp->endOfStream(error, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
static v8::Handle<v8::Value> setStringValueCallback(const v8::Arguments& args)
{
CSSPrimitiveValue* imp = V8CSSPrimitiveValue::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH(int, stringType, toUInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, stringValue, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
imp->setStringValue(stringType, stringValue, ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8DeviceMotionEvent::initDeviceMotionEventCallback(const v8::Arguments& args)
{
DeviceMotionEvent* imp = V8DeviceMotionEvent::toNative(args.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]);
bool bubbles = args[1]->BooleanValue();
bool cancelable = args[2]->BooleanValue();
RefPtr<DeviceMotionData::Acceleration> acceleration = readAccelerationArgument(args[3]);
RefPtr<DeviceMotionData::Acceleration> accelerationIncludingGravity = readAccelerationArgument(args[4]);
RefPtr<DeviceMotionData::RotationRate> rotationRate = readRotationRateArgument(args[5]);
bool intervalProvided = !isUndefinedOrNull(args[6]);
double interval = args[6]->NumberValue();
RefPtr<DeviceMotionData> deviceMotionData = DeviceMotionData::create(acceleration, accelerationIncludingGravity, rotationRate, intervalProvided, interval);
imp->initDeviceMotionEvent(type, bubbles, cancelable, deviceMotionData.get());
return v8Undefined();
}
