void V8Window::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
// None of these need to be RefPtr because info and context are guaranteed
// to hold on to them.
DOMWindow* window = V8Window::toNative(info.Holder());
DOMWindow* source = callingDOMWindow(info.GetIsolate());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "Window", info.Holder(), info.GetIsolate());
// If called directly by WebCore we don't have a calling context.
if (!source) {
exceptionState.throwTypeError("No active calling context exists.");
exceptionState.throwIfNeeded();
return;
}
// This function has variable arguments and can be:
// Per current spec:
// postMessage(message, targetOrigin)
// postMessage(message, targetOrigin, {sequence of transferrables})
// Legacy non-standard implementations in webkit allowed:
// postMessage(message, {sequence of transferrables}, targetOrigin);
MessagePortArray portArray;
ArrayBufferArray arrayBufferArray;
int targetOriginArgIndex = 1;
if (info.Length() > 2) {
int transferablesArgIndex = 2;
if (isLegacyTargetOriginDesignation(info[2])) {
targetOriginArgIndex = 2;
transferablesArgIndex = 1;
}
if (!SerializedScriptValue::extractTransferables(info[transferablesArgIndex], transferablesArgIndex, portArray, arrayBufferArray, exceptionState, info.GetIsolate())) {
exceptionState.throwIfNeeded();
return;
}
}
TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, targetOrigin, info[targetOriginArgIndex]);
RefPtr<SerializedScriptValue> message = SerializedScriptValue::create(info[0], &portArray, &arrayBufferArray, exceptionState, info.GetIsolate());
if (exceptionState.throwIfNeeded())
return;
window->postMessage(message.release(), &portArray, targetOrigin, source, exceptionState);
exceptionState.throwIfNeeded();
}
void V8XMLHttpRequest::openMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
// Four cases:
// open(method, url)
// open(method, url, async)
// open(method, url, async, user)
// open(method, url, async, user, passwd)
ExceptionState exceptionState(ExceptionState::ExecutionContext, "open", "XMLHttpRequest", info.Holder(), info.GetIsolate());
if (info.Length() < 2) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
exceptionState.throwIfNeeded();
return;
}
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, method, info[0]);
TOSTRING_VOID(V8StringResource<>, urlstring, info[1]);
ExecutionContext* context = currentExecutionContext(info.GetIsolate());
KURL url = context->completeURL(urlstring);
if (info.Length() >= 3) {
bool async = info[2]->BooleanValue();
if (info.Length() >= 4 && !info[3]->IsUndefined()) {
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, user, info[3]);
if (info.Length() >= 5 && !info[4]->IsUndefined()) {
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, password, info[4]);
xmlHttpRequest->open(method, url, async, user, password, exceptionState);
} else {
xmlHttpRequest->open(method, url, async, user, exceptionState);
}
} else {
xmlHttpRequest->open(method, url, async, exceptionState);
}
} else {
xmlHttpRequest->open(method, url, exceptionState);
}
exceptionState.throwIfNeeded();
}
static void voidMethodDocumentMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
TestIntegerIndexedPrimaryGlobal* impl = V8TestIntegerIndexedPrimaryGlobal::toImpl(info.Holder());
if (UNLIKELY(info.Length() < 1)) {
V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("voidMethodDocument", "TestIntegerIndexedPrimaryGlobal", ExceptionMessages::notEnoughArguments(1, info.Length())));
return;
}
Document* document;
document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
if (!document) {
V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("voidMethodDocument", "TestIntegerIndexedPrimaryGlobal", "parameter 1 is not of type 'Document'."));
return;
}
impl->voidMethodDocument(document);
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (UNLIKELY(info.Length() < 2)) {
throwTypeError(ExceptionMessages::failedToExecute("Constructor", "TestTypedefs", ExceptionMessages::notEnoughArguments(2, info.Length())), info.GetIsolate());
return;
}
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, hello, info[0]);
if (info.Length() <= 1 || !info[1]->IsFunction()) {
throwTypeError(ExceptionMessages::failedToExecute("Constructor", "TestTypedefs", "The callback provided as parameter 2 is not a function."), info.GetIsolate());
return;
}
OwnPtr<TestCallbackInterface> testCallbackInterface = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[1]), getExecutionContext());
RefPtr<TestTypedefs> impl = TestTypedefs::create(hello, testCallbackInterface);
v8::Handle<v8::Object> wrapper = info.Holder();
V8DOMWrapper::associateObjectWithWrapper<V8TestTypedefs>(impl.release(), &V8TestTypedefs::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
v8SetReturnValue(info, wrapper);
}
void TNodeJsFOut::write(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
EAssertR(Args.Length() == 1, "Invalid number of arguments to fout.write()");
TNodeJsFOut* JsFOut = ObjectWrap::Unwrap<TNodeJsFOut>(Args.This());
EAssertR(!JsFOut->SOut.Empty(), "Output stream already closed!");
if (Args[0]->IsString()) {
JsFOut->SOut->PutStr(*v8::String::Utf8Value(Args[0]->ToString()));
} else if (Args[0]->IsInt32()) {
JsFOut->SOut->PutStr(TInt::GetStr(Args[0]->Int32Value()));
} else if (Args[0]->IsNumber()) {
JsFOut->SOut->PutStr(TFlt::GetStr(Args[0]->NumberValue()));
} else {
EFailR("Invalid type passed to fout.write() function.");
}
Args.GetReturnValue().Set(Args.Holder());
}
static void supplementalMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "supplementalMethod2", "TestInterface", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 2)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
exceptionState.throwIfNeeded();
return;
}
TestInterface* impl = V8TestInterface::toNative(info.Holder());
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, info[0]);
V8TRYCATCH_VOID(TestObject*, objArg, V8TestObject::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
ASSERT(impl);
ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
RefPtr<TestObject> result = TestPartialInterface::supplementalMethod2(scriptContext, *impl, strArg, objArg, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValue(info, result.release());
}
void V8HTMLCanvasElement::toDataURLMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
ExceptionState exceptionState(ExceptionState::ExecutionContext, "toDataURL", "HTMLCanvasElement", info.Holder(), info.GetIsolate());
TOSTRING_VOID(V8StringResource<>, type, info[0]);
double quality;
double* qualityPtr = 0;
if (info.Length() > 1 && info[1]->IsNumber()) {
quality = info[1]->NumberValue();
qualityPtr = &quality;
}
String result = canvas->toDataURL(type, qualityPtr, exceptionState);
exceptionState.throwIfNeeded();
v8SetReturnValueStringOrUndefined(info, result, info.GetIsolate());
}
static void testInterfaceOrTestInterfaceEmptyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestTypedefs* impl = V8TestTypedefs::toNative(info.Holder());
bool result0Enabled = false;
RefPtr<TestInterfaceImplementation> result0;
bool result1Enabled = false;
RefPtr<TestInterfaceEmpty> result1;
impl->testInterfaceOrTestInterfaceEmptyMethod(result0Enabled, result0, result1Enabled, result1);
if (result0Enabled) {
v8SetReturnValue(info, result0.release());
return;
}
if (result1Enabled) {
v8SetReturnValue(info, result1.release());
return;
}
v8SetReturnValueNull(info);
}
void V8Window::showModalDialogMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
DOMWindow* impl = V8Window::toNative(info.Holder());
ExceptionState exceptionState(ExceptionState::ExecutionContext, "showModalDialog", "Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessToFrame(impl->frame(), exceptionState)) {
exceptionState.throwIfNeeded();
return;
}
// FIXME: Handle exceptions properly.
String urlString = toCoreStringWithUndefinedOrNullCheck(info[0]);
DialogHandler handler(info[1]);
String dialogFeaturesString = toCoreStringWithUndefinedOrNullCheck(info[2]);
impl->showModalDialog(urlString, dialogFeaturesString, activeDOMWindow(), firstDOMWindow(), setUpDialog, &handler);
v8SetReturnValue(info, handler.returnValue(info.GetIsolate()));
}
void Shape::addLine(const v8::FunctionCallbackInfo<v8::Value>& args)
{
HandleScope scope;
if (args.Length() < 1 || !args[0]->IsObject() ||
!args[0]->ToObject()->GetConstructorName()->Equals(String::New("lineObj"))) {
ThrowException(String::New("Invalid argument"));
return;
}
Shape* s = ObjectWrap::Unwrap<Shape>(args.Holder());
shapeObj *shape = s->get();
Line* l = ObjectWrap::Unwrap<Line>(args[0]->ToObject());
lineObj *line = l->get();
msAddLine(shape, line);
}
// Custom constructor to make new TextTrackCue(...) return a VTTCue. This is legacy
// compat, not per spec, and should be removed at the earliest opportunity.
void V8TextTrackCue::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "TextTrackCue", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 3)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(3, info.Length()));
exceptionState.throwIfNeeded();
return;
}
V8TRYCATCH_VOID(double, startTime, static_cast<double>(info[0]->NumberValue()));
V8TRYCATCH_VOID(double, endTime, static_cast<double>(info[1]->NumberValue()));
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, text, info[2]);
Document& document = *toDocument(getExecutionContext());
UseCounter::count(document, UseCounter::TextTrackCueConstructor);
VTTCue* impl = VTTCue::create(document, startTime, endTime, text).leakRef();
v8::Handle<v8::Object> wrapper = wrap(impl, info.Holder(), info.GetIsolate());
info.GetReturnValue().Set(wrapper);
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ConstructionContext, "TestException");
if (UNLIKELY(info.Length() < 1)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
return;
}
unsigned argument;
argument = toUInt16(info.GetIsolate(), info[0], NormalConversion, exceptionState);
if (exceptionState.hadException())
return;
TestException* impl = TestException::create(argument);
v8::Local<v8::Object> wrapper = info.Holder();
wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestException::wrapperTypeInfo, wrapper);
v8SetReturnValue(info, wrapper);
}
void V8IntersectionObserver::constructorCustom(
const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(info.GetIsolate(),
ExceptionState::ConstructionContext,
"IntersectionObserver");
if (UNLIKELY(info.Length() < 1)) {
exceptionState.throwTypeError(
ExceptionMessages::notEnoughArguments(1, info.Length()));
return;
}
v8::Local<v8::Object> wrapper = info.Holder();
if (!info[0]->IsFunction()) {
exceptionState.throwTypeError(
"The callback provided as parameter 1 is not a function.");
return;
}
if (info.Length() > 1 && !isUndefinedOrNull(info[1]) &&
!info[1]->IsObject()) {
exceptionState.throwTypeError("parameter 2 ('options') is not an object.");
return;
}
IntersectionObserverInit intersectionObserverInit;
V8IntersectionObserverInit::toImpl(info.GetIsolate(), info[1],
intersectionObserverInit, exceptionState);
if (exceptionState.hadException())
return;
IntersectionObserverCallback* callback = new V8IntersectionObserverCallback(
v8::Local<v8::Function>::Cast(info[0]), wrapper,
ScriptState::current(info.GetIsolate()));
IntersectionObserver* observer = IntersectionObserver::create(
intersectionObserverInit, *callback, exceptionState);
if (exceptionState.hadException())
return;
ASSERT(observer);
v8SetReturnValue(info,
V8DOMWrapper::associateObjectWithWrapper(
info.GetIsolate(), observer, &wrapperTypeInfo, wrapper));
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterface", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 1)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
exceptionState.throwIfNeeded();
return;
}
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str1, info[0]);
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str2, info[1]);
ExecutionContext* context = getExecutionContext();
RefPtr<TestInterface> impl = TestInterface::create(context, str1, str2, exceptionState);
v8::Handle<v8::Object> wrapper = info.Holder();
if (exceptionState.throwIfNeeded())
return;
V8DOMWrapper::associateObjectWithWrapper<V8TestInterface>(impl.release(), &V8TestInterface::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
v8SetReturnValue(info, wrapper);
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestException", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 1)) {
setMinimumArityTypeError(exceptionState, 1, info.Length());
exceptionState.throwIfNeeded();
return;
}
unsigned argument;
{
argument = toUInt16(info.GetIsolate(), info[0], NormalConversion, exceptionState);
if (exceptionState.throwIfNeeded())
return;
}
RefPtr<TestException> impl = TestException::create(argument);
v8::Local<v8::Object> wrapper = info.Holder();
wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestException::wrapperTypeInfo, wrapper);
v8SetReturnValue(info, wrapper);
}
void V8InjectedScriptHost::monitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
String scriptId;
int lineNumber;
int columnNumber;
if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
return;
v8::Handle<v8::Value> name;
if (info.Length() > 0 && info[0]->IsFunction()) {
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(info[0]);
name = function->GetName();
if (!name->IsString() || !v8::Handle<v8::String>::Cast(name)->Length())
name = function->GetInferredName();
}
InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
host->monitorFunction(scriptId, lineNumber, columnNumber, toWebCoreStringWithUndefinedOrNullCheck(name));
}
static void constructor2(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceConstructor2", info.Holder(), info.GetIsolate());
Dictionary dictionaryArg;
{
if (!isUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
exceptionState.throwTypeError("parameter 1 ('dictionaryArg') is not an object.");
exceptionState.throwIfNeeded();
return;
}
dictionaryArg = Dictionary(info[0], info.GetIsolate(), exceptionState);
if (exceptionState.throwIfNeeded())
return;
}
RefPtr<TestInterfaceConstructor2> impl = TestInterfaceConstructor2::create(dictionaryArg);
v8::Local<v8::Object> wrapper = info.Holder();
wrapper = impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructor2::wrapperTypeInfo, wrapper);
v8SetReturnValue(info, wrapper);
}
static void constructor2(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceConstructor", info.Holder(), info.GetIsolate());
double doubleArg;
V8StringResource<> stringArg;
TestInterfaceEmpty* testInterfaceEmptyArg;
Dictionary dictionaryArg;
Vector<String> sequenceStringArg;
Vector<Dictionary> sequenceDictionaryArg;
Dictionary optionalDictionaryArg;
TestInterfaceEmpty* optionalTestInterfaceEmptyArg;
{
TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(doubleArg, toDouble(info[0], exceptionState), exceptionState);
TOSTRING_VOID_INTERNAL(stringArg, info[1]);
testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[2]);
if (!isUndefinedOrNull(info[3]) && !info[3]->IsObject()) {
exceptionState.throwTypeError("parameter 4 ('dictionaryArg') is not an object.");
exceptionState.throwIfNeeded();
return;
}
TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(dictionaryArg, Dictionary(info[3], info.GetIsolate(), exceptionState), exceptionState);
TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(sequenceStringArg, toImplArray<String>(info[4], 5, info.GetIsolate(), exceptionState), exceptionState);
TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(sequenceDictionaryArg, toImplArray<Dictionary>(info[5], 6, info.GetIsolate(), exceptionState), exceptionState);
if (!isUndefinedOrNull(info[6]) && !info[6]->IsObject()) {
exceptionState.throwTypeError("parameter 7 ('optionalDictionaryArg') is not an object.");
exceptionState.throwIfNeeded();
return;
}
TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(optionalDictionaryArg, Dictionary(info[6], info.GetIsolate(), exceptionState), exceptionState);
optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[7]);
}
ScriptState* scriptState = ScriptState::current(info.GetIsolate());
ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
Document& document = *toDocument(currentExecutionContext(info.GetIsolate()));
RefPtr<TestInterfaceConstructor> impl = TestInterfaceConstructor::create(scriptState, executionContext, document, doubleArg, stringArg, testInterfaceEmptyArg, dictionaryArg, sequenceStringArg, sequenceDictionaryArg, optionalDictionaryArg, optionalTestInterfaceEmptyArg, exceptionState);
if (exceptionState.hadException()) {
exceptionState.throwIfNeeded();
return;
}
v8::Local<v8::Object> wrapper = info.Holder();
impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructor::wrapperTypeInfo, wrapper);
v8SetReturnValue(info, wrapper);
}
/** read:
* read data from the current bufer to a new buffer object
*
* @param int togo
* bytes to be read
*
* @return object
* New Buffer containing the read data
*/
void CJSBuffer::FxRead(const v8::FunctionCallbackInfo<v8::Value> &args)
{
v8::HandleScope HandleScope(v8::Isolate::GetCurrent());
CJSBuffer* jBuffer = GetJSObject<CJSBuffer>(args.Holder());
CBufferObj* pBuffer = jBuffer->m_pBuffer;
if (args.Length() < 1)
{
args.GetIsolate()->ThrowException(v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), (uint8_t*)"Invalid Argument"));
return;
}
BUFFER_TRY
size_t ToGo = args[0]->Uint32Value();
CBuffer Buffer(ToGo);
Buffer.WriteData(pBuffer->ReadData(ToGo), ToGo);
CJSObject* jObject = CJSBuffer::New(new CBufferObj(Buffer), jBuffer->m_pScript);
args.GetReturnValue().Set(jObject->GetInstance());
BUFFER_CATCH
}
void MainThreadDebugger::querySelectorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
if (info.Length() < 1)
return;
String selector = toCoreStringWithUndefinedOrNullCheck(info[0]);
if (selector.isEmpty())
return;
Node* node = secondArgumentAsNode(info);
if (!node || !node->isContainerNode())
return;
ExceptionState exceptionState(ExceptionState::ExecutionContext, "$", "CommandLineAPI", info.Holder(), info.GetIsolate());
Element* element = toContainerNode(node)->querySelector(AtomicString(selector), exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (element)
info.GetReturnValue().Set(toV8(element, info.Holder(), info.GetIsolate()));
else
info.GetReturnValue().Set(v8::Null(info.GetIsolate()));
}
void V8MessagePort::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "MessagePort", info.Holder(), info.GetIsolate());
MessagePort* messagePort = V8MessagePort::toNative(info.Holder());
MessagePortArray portArray;
ArrayBufferArray arrayBufferArray;
if (info.Length() > 1) {
const int transferablesArgIndex = 1;
if (!SerializedScriptValue::extractTransferables(info[transferablesArgIndex], transferablesArgIndex, portArray, arrayBufferArray, exceptionState, info.GetIsolate())) {
exceptionState.throwIfNeeded();
return;
}
}
RefPtr<SerializedScriptValue> message = SerializedScriptValue::create(info[0], &portArray, &arrayBufferArray, exceptionState, info.GetIsolate());
if (exceptionState.throwIfNeeded())
return;
messagePort->postMessage(message.release(), &portArray, exceptionState);
exceptionState.throwIfNeeded();
}
void V8DeviceOrientationEvent::initDeviceOrientationEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
DeviceOrientationEvent* impl = V8DeviceOrientationEvent::toNative(info.Holder());
TOSTRING_VOID(V8StringResource<>, type, info[0]);
bool bubbles = info[1]->BooleanValue();
bool cancelable = info[2]->BooleanValue();
// If alpha, beta, gamma or absolute are null or undefined, mark them as not provided.
// Otherwise, use the standard JavaScript conversion.
bool alphaProvided = !isUndefinedOrNull(info[3]);
double alpha = info[3]->NumberValue();
bool betaProvided = !isUndefinedOrNull(info[4]);
double beta = info[4]->NumberValue();
bool gammaProvided = !isUndefinedOrNull(info[5]);
double gamma = info[5]->NumberValue();
bool absoluteProvided = !isUndefinedOrNull(info[6]);
bool absolute = info[6]->BooleanValue();
RefPtrWillBeRawPtr<DeviceOrientationData> orientation = DeviceOrientationData::create(alphaProvided, alpha, betaProvided, beta, gammaProvided, gamma, absoluteProvided, absolute);
impl->initDeviceOrientationEvent(type, bubbles, cancelable, orientation.get());
}
static void constructCustomElement(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
if (!info.IsConstructCall()) {
V8ThrowException::throwTypeError(
isolate, "DOM object constructor cannot be called as a function.");
return;
}
if (info.Length() > 0) {
V8ThrowException::throwTypeError(
isolate, "This constructor should be called without arguments.");
return;
}
ScriptState* scriptState = ScriptState::current(isolate);
v8::Local<v8::Object> data = v8::Local<v8::Object>::Cast(info.Data());
Document* document = V8Document::toImpl(
V8HiddenValue::getHiddenValue(
scriptState, data, V8HiddenValue::customElementDocument(isolate))
.As<v8::Object>());
TOSTRING_VOID(V8StringResource<>, namespaceURI,
V8HiddenValue::getHiddenValue(
scriptState, data,
V8HiddenValue::customElementNamespaceURI(isolate)));
TOSTRING_VOID(
V8StringResource<>, tagName,
V8HiddenValue::getHiddenValue(
scriptState, data, V8HiddenValue::customElementTagName(isolate)));
v8::Local<v8::Value> maybeType = V8HiddenValue::getHiddenValue(
scriptState, data, V8HiddenValue::customElementType(isolate));
TOSTRING_VOID(V8StringResource<>, type, maybeType);
ExceptionState exceptionState(ExceptionState::ConstructionContext,
"CustomElement", info.Holder(),
info.GetIsolate());
V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
Element* element = document->createElementNS(
namespaceURI, tagName, maybeType->IsNull() ? nullAtom : type,
exceptionState);
v8SetReturnValueFast(info, element, document);
}
void V8Window::postMessageMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
// None of these need to be RefPtr because args and context are guaranteed
// to hold on to them.
DOMWindow* window = V8Window::toNative(args.Holder());
DOMWindow* source = activeDOMWindow();
// If called directly by WebCore we don't have a calling context.
if (!source) {
throwTypeError(args.GetIsolate());
return;
}
// This function has variable arguments and can be:
// Per current spec:
// postMessage(message, targetOrigin)
// postMessage(message, targetOrigin, {sequence of transferrables})
// Legacy non-standard implementations in webkit allowed:
// postMessage(message, {sequence of transferrables}, targetOrigin);
MessagePortArray portArray;
ArrayBufferArray arrayBufferArray;
int targetOriginArgIndex = 1;
if (args.Length() > 2) {
int transferablesArgIndex = 2;
if (isLegacyTargetOriginDesignation(args[2])) {
targetOriginArgIndex = 2;
transferablesArgIndex = 1;
}
if (!extractTransferables(args[transferablesArgIndex], portArray, arrayBufferArray, args.GetIsolate()))
return;
}
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, targetOrigin, args[targetOriginArgIndex]);
bool didThrow = false;
RefPtr<SerializedScriptValue> message =
SerializedScriptValue::create(args[0], &portArray, &arrayBufferArray, didThrow, args.GetIsolate());
if (didThrow)
return;
ExceptionState es(args.GetIsolate());
window->postMessage(message.release(), &portArray, targetOrigin, source, es);
es.throwIfNeeded();
}
// Retrieve this module's information. Exposed to JavaScript
static void GetModuleInfo (const v8::FunctionCallbackInfo<v8::Value>& args)
{
auto isolate = args.GetIsolate ();
HandleScope scope (isolate);
// validate parameters
std::string error_string;
if (descriptor.ValidateParameters (GetModuleInfo, args, error_string))
{
// unwrap object so we can call the correct function on the instance
auto module = ObjectWrap::Unwrap<TDerivedLokiModule> (args.Holder ());
// return info object
args.GetReturnValue ().Set (module->getModuleInfo (isolate));
}
else
{
// if parameter validation failed for whatever reason, report the error
isolate->ThrowException (Exception::Error (String::NewFromUtf8 (isolate, error_string.c_str ())));
}
}
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() < 1) {
throwTypeError(ExceptionMessages::failedToConstruct("TestEventConstructor", "An event name must be provided."), args.GetIsolate());
return;
}
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, args[0]);
TestEventConstructorInit eventInit;
if (args.Length() >= 2) {
V8TRYCATCH_VOID(Dictionary, options, Dictionary(args[1], args.GetIsolate()));
if (!fillTestEventConstructorInit(eventInit, options))
return;
}
RefPtr<TestEventConstructor> event = TestEventConstructor::create(type, eventInit);
v8::Handle<v8::Object> wrapper = args.Holder();
V8DOMWrapper::associateObjectWithWrapper<V8TestEventConstructor>(event.release(), &V8TestEventConstructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
v8SetReturnValue(args, wrapper);
}
void TNodeJsSA::getOutTimestampVector(const v8::FunctionCallbackInfo<v8::Value>& Args) {
v8::Isolate* Isolate = v8::Isolate::GetCurrent();
v8::HandleScope HandleScope(Isolate);
// unwrap
TNodeJsSA* JsSA = ObjectWrap::Unwrap<TNodeJsSA>(Args.Holder());
// try to cast as IFltTmIO
TWPt<TQm::TStreamAggrOut::IFltTmIO> Aggr = dynamic_cast<TQm::TStreamAggrOut::IFltTmIO*>(JsSA->SA());
if (Aggr.Empty()) {
throw TQm::TQmExcept::New("TNodeJsSA::getOutTmV : stream aggregate does not implement IFltTmIO: " + JsSA->SA->GetAggrNm());
}
TUInt64V Res;
Aggr->GetOutTmMSecsV(Res);
int Len = Res.Len();
TFltV FltRes(Len);
for (int ElN = 0; ElN < Len; ElN++) {
FltRes[ElN] = (double)Res[ElN];
}
Args.GetReturnValue().Set(TNodeJsVec<TFlt, TAuxFltV>::New(FltRes));
}
static void strictSVGPointMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "strictSVGPointMethod", "TestSVG", info.Holder(), info.GetIsolate());
if (UNLIKELY(info.Length() < 2)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
exceptionState.throwIfNeeded();
return;
}
TestSVG* imp = V8TestSVG::toNative(info.Holder());
if (info.Length() > 0 && !V8SVGPoint::hasInstance(info[0], info.GetIsolate())) {
exceptionState.throwTypeError("parameter 1 is not of type 'SVGPoint'.");
exceptionState.throwIfNeeded();
return;
}
V8TRYCATCH_VOID(SVGPointTearOff*, item, V8SVGPoint::hasInstance(info[0], info.GetIsolate()) ? V8SVGPoint::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0);
V8TRYCATCH_EXCEPTION_VOID(unsigned, index, toUInt32(info[1], exceptionState), exceptionState);
RefPtr<SVGPointTearOff> result = imp->strictSVGPointMethod(item, index, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValue(info, result.release());
}
static void deleteNamedItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface2", "deleteNamedItem");
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
if (UNLIKELY(info.Length() < 1)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
return;
}
V8StringResource<> name;
name = info[0];
if (!name.prepare())
return;
bool result = impl->deleteNamedItem(name, exceptionState);
if (exceptionState.hadException()) {
return;
}
v8SetReturnValueBool(info, result);
}
static void itemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface2", "item");
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
if (UNLIKELY(info.Length() < 1)) {
exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
return;
}
unsigned index;
index = toUInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState);
if (exceptionState.hadException())
return;
TestInterfaceEmpty* result = impl->item(index, exceptionState);
if (exceptionState.hadException()) {
return;
}
v8SetReturnValue(info, result);
}