short V8NodeFilterCondition::acceptNode(ScriptState* state, Node* node) const { ASSERT(v8::Context::InContext()); if (!m_filter->IsFunction()) return NodeFilter::FILTER_ACCEPT; v8::TryCatch exceptionCatcher; v8::Handle<v8::Object> object = v8::Context::GetCurrent()->Global(); v8::Handle<v8::Function> callback = v8::Handle<v8::Function>::Cast(m_filter); OwnArrayPtr<v8::Handle<v8::Value> > args(new v8::Handle<v8::Value>[1]); args[0] = toV8(node); V8Proxy* proxy = V8Proxy::retrieve(); ASSERT(proxy); v8::Handle<v8::Value> result = proxy->callFunction(callback, object, 1, args.get()); if (exceptionCatcher.HasCaught()) { state->setException(exceptionCatcher.Exception()); return NodeFilter::FILTER_REJECT; } ASSERT(!result.IsEmpty()); return result->Int32Value(); }
String V8CustomXPathNSResolver::lookupNamespaceURI(const String& prefix) { v8::Handle<v8::Function> lookupNamespaceURIFunc; v8::Handle<v8::String> lookupNamespaceURIName = v8::String::New("lookupNamespaceURI"); // Check if the resolver has a function property named lookupNamespaceURI. if (m_resolver->Has(lookupNamespaceURIName)) { v8::Handle<v8::Value> lookupNamespaceURI = m_resolver->Get(lookupNamespaceURIName); if (lookupNamespaceURI->IsFunction()) lookupNamespaceURIFunc = v8::Handle<v8::Function>::Cast(lookupNamespaceURI); } if (lookupNamespaceURIFunc.IsEmpty() && !m_resolver->IsFunction()) { Frame* frame = V8Proxy::retrieveFrameForEnteredContext(); logInfo(frame, "XPathNSResolver does not have a lookupNamespaceURI method.", String()); return String(); } // Catch exceptions from calling the namespace resolver. v8::TryCatch try_catch; try_catch.SetVerbose(true); // Print exceptions to console. const int argc = 1; v8::Handle<v8::Value> argv[argc] = { v8String(prefix) }; v8::Handle<v8::Function> function = lookupNamespaceURIFunc.IsEmpty() ? v8::Handle<v8::Function>::Cast(m_resolver) : lookupNamespaceURIFunc; V8Proxy* proxy = V8Proxy::retrieve(); v8::Handle<v8::Value> retval = proxy->callFunction(function, m_resolver, argc, argv); // Eat exceptions from namespace resolver and return an empty string. This will most likely cause NAMESPACE_ERR. if (try_catch.HasCaught()) return String(); return toWebCoreStringWithNullCheck(retval); }
// FIXME: Fix it same as _NPN_Invoke (HandleScope and such). bool _NPN_InvokeDefault(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result) { if (!npObject) return false; if (npObject->_class != npScriptObjectClass) { if (npObject->_class->invokeDefault) return npObject->_class->invokeDefault(npObject, arguments, argumentCount, result); VOID_TO_NPVARIANT(*result); return true; } V8NPObject* v8NpObject = reinterpret_cast<V8NPObject*>(npObject); VOID_TO_NPVARIANT(*result); v8::HandleScope handleScope; v8::Handle<v8::Context> context = toV8Context(npp, npObject); if (context.IsEmpty()) return false; v8::Context::Scope scope(context); ExceptionCatcher exceptionCatcher; // Lookup the function object and call it. v8::Handle<v8::Object> functionObject(v8NpObject->v8Object); if (!functionObject->IsFunction()) return false; v8::Local<v8::Value> resultObject; v8::Handle<v8::Function> function(v8::Function::Cast(*functionObject)); if (!function->IsNull()) { V8Proxy* proxy = toV8Proxy(npObject); ASSERT(proxy); OwnArrayPtr<v8::Handle<v8::Value> > argv(createValueListFromVariantArgs(arguments, argumentCount, npObject)); resultObject = proxy->callFunction(function, functionObject, argumentCount, argv.get()); } // If we had an error, return false. The spec is a little unclear here, but says "Returns true if the method was // successfully invoked". If we get an error return value, was that successfully invoked? if (resultObject.IsEmpty()) return false; convertV8ObjectToNPVariant(resultObject, npObject, result); return true; }
bool _NPN_Invoke(NPP npp, NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result) { if (!npObject) return false; if (npObject->_class != npScriptObjectClass) { if (npObject->_class->invoke) return npObject->_class->invoke(npObject, methodName, arguments, argumentCount, result); VOID_TO_NPVARIANT(*result); return true; } V8NPObject* v8NpObject = reinterpret_cast<V8NPObject*>(npObject); PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(methodName); if (!identifier->isString) return false; v8::HandleScope handleScope; // FIXME: should use the plugin's owner frame as the security context. v8::Handle<v8::Context> context = toV8Context(npp, npObject); if (context.IsEmpty()) return false; v8::Context::Scope scope(context); if (methodName == _NPN_GetStringIdentifier("eval")) { if (argumentCount != 1) return false; if (arguments[0].type != NPVariantType_String) return false; return _NPN_Evaluate(npp, npObject, const_cast<NPString*>(&arguments[0].value.stringValue), result); } v8::Handle<v8::Value> functionObject = v8NpObject->v8Object->Get(v8::String::New(identifier->value.string)); if (functionObject.IsEmpty() || functionObject->IsNull()) { NULL_TO_NPVARIANT(*result); return false; } if (functionObject->IsUndefined()) { VOID_TO_NPVARIANT(*result); return false; } V8Proxy* proxy = toV8Proxy(npObject); ASSERT(proxy); // Call the function object. v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(functionObject); OwnArrayPtr<v8::Handle<v8::Value> > argv(createValueListFromVariantArgs(arguments, argumentCount, npObject)); v8::Local<v8::Value> resultObject = proxy->callFunction(function, v8NpObject->v8Object, argumentCount, argv.get()); // If we had an error, return false. The spec is a little unclear here, but says "Returns true if the method was // successfully invoked". If we get an error return value, was that successfully invoked? if (resultObject.IsEmpty()) return false; convertV8ObjectToNPVariant(resultObject, npObject, result); return true; }