void V8MessageEvent::initMessageEventMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { MessageEvent* event = V8MessageEvent::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, typeArg, info[0]); V8TRYCATCH_VOID(bool, canBubbleArg, info[1]->BooleanValue()); V8TRYCATCH_VOID(bool, cancelableArg, info[2]->BooleanValue()); v8::Handle<v8::Value> dataArg = info[3]; V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, originArg, info[4]); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, lastEventIdArg, info[5]); DOMWindow* sourceArg = toDOMWindow(info[6], info.GetIsolate()); OwnPtr<MessagePortArray> portArray; const int portArrayIndex = 7; if (!isUndefinedOrNull(info[portArrayIndex])) { portArray = adoptPtr(new MessagePortArray); bool success = false; *portArray = toRefPtrNativeArray<MessagePort, V8MessagePort>(info[portArrayIndex], portArrayIndex + 1, info.GetIsolate(), &success); if (!success) return; } event->initMessageEvent(typeArg, canBubbleArg, cancelableArg, originArg, lastEventIdArg, sourceArg, portArray.release()); if (!dataArg.IsEmpty()) { V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::data(info.GetIsolate()), dataArg); if (DOMWrapperWorld::current(info.GetIsolate())->isIsolatedWorld()) event->setSerializedData(SerializedScriptValue::createAndSwallowExceptions(dataArg, info.GetIsolate())); } }
void V8Window::openMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { DOMWindow* impl = V8Window::toNative(info.Holder()); ExceptionState exceptionState(ExceptionState::ExecutionContext, "open", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), impl->frame(), exceptionState)) { exceptionState.throwIfNeeded(); return; } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, urlString, info[0]); AtomicString frameName; if (info[1]->IsUndefined() || info[1]->IsNull()) { frameName = "_blank"; } else { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, frameNameResource, info[1]); frameName = frameNameResource; } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, windowFeaturesString, info[2]); RefPtr<DOMWindow> openedWindow = impl->open(urlString, frameName, windowFeaturesString, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate())); if (!openedWindow) return; v8SetReturnValueFast(info, openedWindow.release(), impl); }
static void namedPropertySetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info) { if (info.Holder()->HasRealNamedProperty(name)) return; if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty()) return; TestEventTarget* imp = V8TestEventTarget::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, propertyName, name); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, propertyValue, jsValue); bool result = imp->anonymousNamedSetter(propertyName, propertyValue); if (!result) return; v8SetReturnValue(info, jsValue); }
static void textAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { HTMLTitleElement* imp = V8HTMLTitleElement::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, v, value); imp->setText(v); return; }
static void aAttributeSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { RealClass* imp = V8TestInterfaceImplementedAs::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); imp->setA(v); return; }
static void xmlspaceAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { SVGSwitchElement* imp = V8SVGSwitchElement::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); imp->setXmlspace(v); return; }
void V8HTMLAllCollection::legacyCallCustom(const v8::FunctionCallbackInfo<v8::Value>& info) { if (info.Length() < 1) return; HTMLAllCollection* imp = V8HTMLAllCollection::toNative(info.Holder()); Node* ownerNode = imp->ownerNode(); ASSERT(ownerNode); UseCounter::count(ownerNode->document(), UseCounter::DocumentAllLegacyCall); if (info.Length() == 1) { v8SetReturnValue(info, getItem(imp, info[0], info)); return; } // If there is a second argument it is the index of the item we want. V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, info[0]); v8::Local<v8::Uint32> index = info[1]->ToArrayIndex(); if (index.IsEmpty()) return; if (Node* node = imp->namedItemWithIndex(name, index->Uint32Value())) { v8SetReturnValueFast(info, node, imp); return; } }
static void selectorTextAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { CSSPageRule* imp = V8CSSPageRule::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, v, value); imp->setSelectorText(v); return; }
static void supplementalStr2AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { TestInterface* imp = V8TestInterface::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); TestSupplemental::setSupplementalStr2(imp, v); return; }
static void modeAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { TextTrack* imp = V8TextTrack::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); imp->setMode(v); return; }
void V8History::replaceStateMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args) { bool didThrow = false; RefPtr<SerializedScriptValue> historyState = SerializedScriptValue::create(args[0], 0, 0, didThrow, args.GetIsolate()); if (didThrow) return; V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, title, args[1]); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(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()); v8SetReturnValue(args, setDOMException(ec, args.GetIsolate())); }
static void effectAllowedAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { Clipboard* imp = V8Clipboard::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); imp->setEffectAllowed(v); return; }
static void mediaAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { HTMLSourceElement* imp = V8HTMLSourceElement::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); imp->setMedia(v); return; }
void V8AbstractEventListener::invokeEventHandler(ExecutionContext* context, Event* event, v8::Local<v8::Value> jsEvent) { // If jsEvent is empty, attempt to set it as a hidden value would crash v8. if (jsEvent.IsEmpty()) return; v8::Local<v8::Context> v8Context = toV8Context(context, world()); if (v8Context.IsEmpty()) return; // We push the event being processed into the global object, so that it can be exposed by DOMWindow's bindings. v8::Handle<v8::String> eventSymbol = v8AtomicString(v8Context->GetIsolate(), "event"); v8::Local<v8::Value> returnValue; { // Catch exceptions thrown in the event handler so they do not propagate to javascript code that caused the event to fire. v8::TryCatch tryCatch; tryCatch.SetVerbose(true); // Save the old 'event' property so we can restore it later. v8::Local<v8::Value> savedEvent = getHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol); tryCatch.Reset(); // Make the event available in the global object, so DOMWindow can expose it. setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, jsEvent); tryCatch.Reset(); returnValue = callListenerFunction(context, jsEvent, event); if (tryCatch.HasCaught()) event->target()->uncaughtExceptionInEventHandler(); if (!tryCatch.CanContinue()) { // Result of TerminateExecution(). if (context->isWorkerGlobalScope()) toWorkerGlobalScope(context)->script()->forbidExecution(); return; } tryCatch.Reset(); // Restore the old event. This must be done for all exit paths through this method. if (savedEvent.IsEmpty()) setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, v8::Undefined(v8Context->GetIsolate())); else setHiddenValue(v8Context->GetIsolate(), v8Context->Global(), eventSymbol, savedEvent); tryCatch.Reset(); } ASSERT(!handleOutOfMemory() || returnValue.IsEmpty()); if (returnValue.IsEmpty()) return; if (!returnValue->IsNull() && !returnValue->IsUndefined() && event->isBeforeUnloadEvent()) { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringReturnValue, returnValue); toBeforeUnloadEvent(event)->setReturnValue(stringReturnValue); } if (m_isAttribute && shouldPreventDefault(returnValue)) event->preventDefault(); }
static void supplementalStr2AttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) { v8::Handle<v8::Object> holder = info.Holder(); TestInterface* impl = V8TestInterface::toNative(holder); ASSERT(impl); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value); TestPartialInterface::setSupplementalStr2(*impl, cppValue); }
static void stringAttrWithSetterExceptionAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) { ExceptionState exceptionState(ExceptionState::SetterContext, "stringAttrWithSetterException", "TestTypedefs", info.Holder(), info.GetIsolate()); TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, jsValue); imp->setStringAttrWithSetterException(cppValue, exceptionState); exceptionState.throwIfNeeded(); }
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(info.GetIsolate(), impl->frame(), exceptionState)) { exceptionState.throwIfNeeded(); return; } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, urlString, info[0]); DialogHandler handler(info[1]); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, dialogFeaturesString, info[2]); impl->showModalDialog(urlString, dialogFeaturesString, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), setUpDialog, &handler); v8SetReturnValue(info, handler.returnValue(info.GetIsolate())); }
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()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, method, info[0]); V8TRYCATCH_FOR_V8STRINGRESOURCE_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()) { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, user, info[3]); if (info.Length() >= 5 && !info[4]->IsUndefined()) { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, 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 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 constructor4(const v8::FunctionCallbackInfo<v8::Value>& info) { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, string, info[0]); RefPtr<TestOverloadedConstructors> impl = TestOverloadedConstructors::create(string); v8::Handle<v8::Object> wrapper = info.Holder(); V8DOMWrapper::associateObjectWithWrapper<V8TestOverloadedConstructors>(impl.release(), &V8TestOverloadedConstructors::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent); info.GetReturnValue().Set(wrapper); }
static void namedItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("namedItem", "TestEventTarget", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate()); return; } TestEventTarget* imp = V8TestEventTarget::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, info[0]); v8SetReturnValue(info, imp->namedItem(name)); }
static void baseValAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { SVGAnimatedString* imp = V8SVGAnimatedString::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); ExceptionCode ec = 0; imp->setBaseVal(v, ec); if (UNLIKELY(ec)) setDOMException(ec, info.GetIsolate()); return; }
static void textAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { HTMLOptionElement* imp = V8HTMLOptionElement::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); ExceptionCode ec = 0; imp->setText(v, ec); if (UNLIKELY(ec)) setDOMException(ec, info.GetIsolate()); return; }
static void cssTextAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info) { CSSRule* imp = V8CSSRule::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, v, value); ExceptionCode ec = 0; imp->setCssText(v, ec); if (UNLIKELY(ec)) setDOMException(ec, info.GetIsolate()); return; }
static void func1Method(const v8::FunctionCallbackInfo<v8::Value>& args) { if (UNLIKELY(args.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("func1", "RealClass", ExceptionMessages::notEnoughArguments(1, args.Length())), args.GetIsolate()); return; } RealClass* imp = V8TestInterfaceImplementedAs::toNative(args.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, a, args[0]); v8SetReturnValueString(args, imp->func1(a), args.GetIsolate()); return; }
void V8HTMLFormControlsCollection::namedItemMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args) { V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, args[0]); HTMLFormControlsCollection* imp = V8HTMLFormControlsCollection::toNative(args.Holder()); v8::Handle<v8::Value> result = getNamedItems(imp, name, args); if (result.IsEmpty()) { v8SetReturnValueNull(args); return; } v8SetReturnValue(args, result); }
static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info) { if (UNLIKELY(info.Length() < 1)) { throwTypeError(ExceptionMessages::failedToExecute("Constructor", "TestInterfaceConstructor3", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate()); return; } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0]); RefPtr<TestInterfaceConstructor3> impl = TestInterfaceConstructor3::create(stringArg); v8::Handle<v8::Object> wrapper = info.Holder(); V8DOMWrapper::associateObjectWithWrapper<V8TestInterfaceConstructor3>(impl.release(), &V8TestInterfaceConstructor3::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent); v8SetReturnValue(info, wrapper); }
static void V8TestNamedConstructorConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) { if (!info.IsConstructCall()) { throwTypeError(ExceptionMessages::failedToConstruct("Audio", "Please use the 'new' operator, this DOM object constructor cannot be called as a function."), info.GetIsolate()); return; } if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) { v8SetReturnValue(info, info.Holder()); return; } Document* document = currentDocument(); ASSERT(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, info.Holder(), info.GetIsolate()); ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestNamedConstructor", 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]); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str3, argumentOrNull(info, 2)); RefPtr<TestNamedConstructor> impl = TestNamedConstructor::createForJSConstructor(*document, str1, str2, str3, exceptionState); v8::Handle<v8::Object> wrapper = info.Holder(); if (exceptionState.throwIfNeeded()) return; V8DOMWrapper::associateObjectWithWrapper<V8TestNamedConstructor>(impl.release(), &V8TestNamedConstructorConstructor::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent); v8SetReturnValue(info, wrapper); }
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 = activeDOMWindow(); // If called directly by WebCore we don't have a calling context. if (!source) { throwUninformativeAndGenericTypeError(info.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 (info.Length() > 2) { int transferablesArgIndex = 2; if (isLegacyTargetOriginDesignation(info[2])) { targetOriginArgIndex = 2; transferablesArgIndex = 1; } bool notASequence = false; if (!extractTransferables(info[transferablesArgIndex], portArray, arrayBufferArray, notASequence, info.GetIsolate())) { if (notASequence) throwTypeError(ExceptionMessages::failedToExecute("postMessage", "Window", ExceptionMessages::notAnArrayTypeArgumentOrValue(transferablesArgIndex + 1)), info.GetIsolate()); return; } } V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, targetOrigin, info[targetOriginArgIndex]); bool didThrow = false; RefPtr<SerializedScriptValue> message = SerializedScriptValue::create(info[0], &portArray, &arrayBufferArray, didThrow, info.GetIsolate()); if (didThrow) return; ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", "Window", info.Holder(), info.GetIsolate()); window->postMessage(message.release(), &portArray, targetOrigin, source, exceptionState); exceptionState.throwIfNeeded(); }
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* imp = V8TestInterface::toNative(info.Holder()); V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, info[0]); V8TRYCATCH_VOID(TestObj*, objArg, V8TestObject::hasInstance(info[1], info.GetIsolate()) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); ExecutionContext* scriptContext = getExecutionContext(); RefPtr<TestObj> result = TestPartialInterface::supplementalMethod2(scriptContext, imp, strArg, objArg, exceptionState); if (exceptionState.throwIfNeeded()) return; v8SetReturnValue(info, result.release()); }