JSValue* CInstance::invokeConstruct(ExecState* exec, const ArgList& args) { if (!_object->_class->construct) return jsUndefined(); unsigned count = args.size(); Vector<NPVariant, 8> cArgs(count); unsigned i; for (i = 0; i < count; i++) convertValueToNPVariant(exec, args.at(exec, i), &cArgs[i]); // Invoke the 'C' method. NPVariant resultVariant; VOID_TO_NPVARIANT(resultVariant); { JSLock::DropAllLocks dropAllLocks(false); _object->_class->construct(_object, cArgs.data(), count, &resultVariant); } for (i = 0; i < count; i++) _NPN_ReleaseVariantValue(&cArgs[i]); JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant, _rootObject.get()); _NPN_ReleaseVariantValue(&resultVariant); return resultValue; }
JSValue* CInstance::invokeMethod(ExecState* exec, const MethodList& methodList, const List& args) { // Overloading methods are not allowed by NPObjects. Should only be one // name match for a particular method. assert(methodList.length() == 1); CMethod* method = static_cast<CMethod*>(methodList.methodAt(0)); NPIdentifier ident = _NPN_GetStringIdentifier(method->name()); if (!_object->_class->hasMethod(_object, ident)) return jsUndefined(); unsigned count = args.size(); Vector<NPVariant, 128> cArgs(count); unsigned i; for (i = 0; i < count; i++) convertValueToNPVariant(exec, args.at(i), &cArgs[i]); // Invoke the 'C' method. NPVariant resultVariant; VOID_TO_NPVARIANT(resultVariant); _object->_class->invoke(_object, ident, cArgs, count, &resultVariant); for (i = 0; i < count; i++) _NPN_ReleaseVariantValue(&cArgs[i]); JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant); _NPN_ReleaseVariantValue(&resultVariant); return resultValue; }
EncodedJSValue JSC_HOST_CALL jsConsolePrototypeFunctionDebug(ExecState* exec) { JSValue thisValue = exec->hostThisValue(); JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue)); Console* imp = static_cast<Console*>(castedThis->impl()); unsigned count = exec->argumentCount(); Vector<NPVariant, 8> cArgs(count); unsigned i; for (i = 0; i < count; i++) JSC::Bindings::convertValueToNPVariant(exec, exec->argument(i), &cArgs[i]); // Invoke the 'C' method. bool retval = true; NPVariant resultVariant; VOID_TO_NPVARIANT(resultVariant); { JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly); //ASSERT(JSC::Bindings::globalExceptionString().isNull()); NPInvokeFunctionPtr ptr = (NPInvokeFunctionPtr)(imp->frame()->page()->chrome()->client()->getJavascriptCallCppCallback()); retval = ptr(0, 0, cArgs.data(), count, &resultVariant); //CInstance::moveGlobalExceptionToExecState(exec); } if (!retval) throwError(exec, createError(exec, "Error calling method on NPObject.")); for (i = 0; i < count; i++) _NPN_ReleaseVariantValue(&cArgs[i]); JSValue resultValue = JSC::Bindings::convertNPVariantToValue(exec, &resultVariant, 0); _NPN_ReleaseVariantValue(&resultVariant); return resultValue; // JSValue thisValue = exec->hostThisValue(); // if (!thisValue.inherits(&JSConsole::s_info)) // return throwVMTypeError(exec); // JSConsole* castedThis = static_cast<JSConsole*>(asObject(thisValue)); // Console* imp = static_cast<Console*>(castedThis->impl()); // RefPtr<ScriptArguments> scriptArguments(createScriptArguments(exec, 0)); // size_t maxStackSize = imp->shouldCaptureFullStackTrace() ? ScriptCallStack::maxCallStackSizeToCapture : 1; // RefPtr<ScriptCallStack> callStack(createScriptCallStack(exec, maxStackSize)); // // imp->debug(scriptArguments, callStack); // return JSValue::encode(jsUndefined()); }
JSValue* CField::valueFromInstance(ExecState* exec, const Instance* inst) const { const CInstance* instance = static_cast<const CInstance*>(inst); NPObject* obj = instance->getObject(); if (obj->_class->getProperty) { NPVariant property; VOID_TO_NPVARIANT(property); #ifdef ANDROID_NPN_SETEXCEPTION SetGlobalException(0); #endif // ANDROID_NPN_SETEXCEPTION bool result; { JSLock::DropAllLocks dropAllLocks(false); result = obj->_class->getProperty(obj, _fieldIdentifier, &property); } #ifdef ANDROID_NPN_SETEXCEPTION MoveGlobalExceptionToExecState(exec); #endif // ANDROID_NPN_SETEXCEPTION if (result) { JSValue* result = convertNPVariantToValue(exec, &property, instance->rootObject()); _NPN_ReleaseVariantValue(&property); return result; } } return jsUndefined(); }
static v8::Handle<v8::Value> npObjectGetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> key, v8::Isolate* isolate) { NPObject* npObject = v8ObjectToNPObject(self); // Verify that our wrapper wasn't using a NPObject which // has already been deleted. if (!npObject || !_NPN_IsAlive(npObject)) return throwError(v8ReferenceError, "NPObject deleted", isolate); if (npObject->_class->hasProperty && npObject->_class->getProperty && npObject->_class->hasProperty(npObject, identifier)) { if (!_NPN_IsAlive(npObject)) return throwError(v8ReferenceError, "NPObject deleted", isolate); NPVariant result; VOID_TO_NPVARIANT(result); if (!npObject->_class->getProperty(npObject, identifier, &result)) return v8Undefined(); v8::Handle<v8::Value> returnValue; if (_NPN_IsAlive(npObject)) returnValue = convertNPVariantToV8Object(&result, npObject, isolate); _NPN_ReleaseVariantValue(&result); return returnValue; } if (!_NPN_IsAlive(npObject)) return throwError(v8ReferenceError, "NPObject deleted", isolate); if (key->IsString() && npObject->_class->hasMethod && npObject->_class->hasMethod(npObject, identifier)) { if (!_NPN_IsAlive(npObject)) return throwError(v8ReferenceError, "NPObject deleted", isolate); PrivateIdentifier* id = static_cast<PrivateIdentifier*>(identifier); UnsafePersistent<v8::FunctionTemplate> functionTemplate = V8NPTemplateMap::sharedInstance(isolate).get(id); // FunctionTemplate caches function for each context. v8::Local<v8::Function> v8Function; // Cache templates using identifier as the key. if (functionTemplate.isEmpty()) { // Create a new template. v8::Local<v8::FunctionTemplate> temp = v8::FunctionTemplate::New(); temp->SetCallHandler(npObjectMethodHandler, key); V8NPTemplateMap::sharedInstance(isolate).set(id, temp); v8Function = temp->GetFunction(); } else { v8Function = functionTemplate.newLocal(isolate)->GetFunction(); } v8Function->SetName(v8::Handle<v8::String>::Cast(key)); return v8Function; } return v8Undefined(); }
JSValue* CInstance::invokeDefaultMethod(ExecState* exec, const List& args) { if (!_object->_class->invokeDefault) return jsUndefined(); unsigned count = args.size(); Vector<NPVariant, 128> cArgs(count); unsigned i; for (i = 0; i < count; i++) convertValueToNPVariant(exec, args.at(i), &cArgs[i]); // Invoke the 'C' method. NPVariant resultVariant; VOID_TO_NPVARIANT(resultVariant); _object->_class->invokeDefault(_object, cArgs, count, &resultVariant); for (i = 0; i < count; i++) _NPN_ReleaseVariantValue(&cArgs[i]); JSValue* resultValue = convertNPVariantToValue(exec, &resultVariant); _NPN_ReleaseVariantValue(&resultVariant); return resultValue; }
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue *aValue) const { const CInstance* instance = static_cast<const CInstance*>(inst); NPObject* obj = instance->getObject(); if (obj->_class->setProperty) { NPVariant variant; convertValueToNPVariant(exec, aValue, &variant); { JSLock::DropAllLocks dropAllLocks; obj->_class->setProperty(obj, _fieldIdentifier, &variant); } _NPN_ReleaseVariantValue(&variant); } }
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue aValue) const { const CInstance* instance = static_cast<const CInstance*>(inst); NPObject* obj = instance->getObject(); if (obj->_class->setProperty) { NPVariant variant; convertValueToNPVariant(exec, aValue, &variant); { JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly); obj->_class->setProperty(obj, _fieldIdentifier, &variant); CInstance::moveGlobalExceptionToExecState(exec); } _NPN_ReleaseVariantValue(&variant); } }
JSValue* CField::valueFromInstance(ExecState* exec, const Instance* inst) const { const CInstance* instance = static_cast<const CInstance*>(inst); NPObject* obj = instance->getObject(); if (obj->_class->getProperty) { NPVariant property; VOID_TO_NPVARIANT(property); bool result; { JSLock::DropAllLocks dropAllLocks; result = obj->_class->getProperty(obj, _fieldIdentifier, &property); } if (result) { JSValue* result = convertNPVariantToValue(exec, &property, instance->rootObject()); _NPN_ReleaseVariantValue(&property); return result; } } return jsUndefined(); }
void CField::setValueToInstance(ExecState *exec, const Instance *inst, JSValue* aValue) const { const CInstance* instance = static_cast<const CInstance*>(inst); NPObject* obj = instance->getObject(); if (obj->_class->setProperty) { NPVariant variant; convertValueToNPVariant(exec, aValue, &variant); #ifdef ANDROID_NPN_SETEXCEPTION SetGlobalException(0); #endif // ANDROID_NPN_SETEXCEPTION { JSLock::DropAllLocks dropAllLocks(false); obj->_class->setProperty(obj, _fieldIdentifier, &variant); } _NPN_ReleaseVariantValue(&variant); #ifdef ANDROID_NPN_SETEXCEPTION MoveGlobalExceptionToExecState(exec); #endif // ANDROID_NPN_SETEXCEPTION } }
static v8::Handle<v8::Value> npObjectSetProperty(v8::Local<v8::Object> self, NPIdentifier identifier, v8::Local<v8::Value> value, v8::Isolate* isolate) { NPObject* npObject = v8ObjectToNPObject(self); // Verify that our wrapper wasn't using a NPObject which has already been deleted. if (!npObject || !_NPN_IsAlive(npObject)) { throwError(v8ReferenceError, "NPObject deleted", isolate); return value; // Intercepted, but an exception was thrown. } if (npObject->_class->hasProperty && npObject->_class->setProperty && npObject->_class->hasProperty(npObject, identifier)) { if (!_NPN_IsAlive(npObject)) return throwError(v8ReferenceError, "NPObject deleted", isolate); NPVariant npValue; VOID_TO_NPVARIANT(npValue); convertV8ObjectToNPVariant(value, npObject, &npValue); bool success = npObject->_class->setProperty(npObject, identifier, &npValue); _NPN_ReleaseVariantValue(&npValue); if (success) return value; // Intercept the call. } return v8Undefined(); }
void WebBindings::releaseVariantValue(NPVariant* variant) { _NPN_ReleaseVariantValue(variant); }
// FIXME: need comments. // Params: holder could be HTMLEmbedElement or NPObject static void npObjectInvokeImpl(const v8::FunctionCallbackInfo<v8::Value>& args, InvokeFunctionType functionId) { NPObject* npObject; WrapperWorldType currentWorldType = worldType(args.GetIsolate()); // These three types are subtypes of HTMLPlugInElement. if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType) || V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType) || V8HTMLObjectElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)) { // The holder object is a subtype of HTMLPlugInElement. HTMLPlugInElement* element; if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)) element = V8HTMLAppletElement::toNative(args.Holder()); else if (V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)) element = V8HTMLEmbedElement::toNative(args.Holder()); else element = V8HTMLObjectElement::toNative(args.Holder()); ScriptInstance scriptInstance = element->getInstance(); if (scriptInstance) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); v8::HandleScope handleScope(isolate); npObject = v8ObjectToNPObject(scriptInstance->newLocal(isolate)); } else npObject = 0; } else { // The holder object is not a subtype of HTMLPlugInElement, it must be an NPObject which has three // internal fields. if (args.Holder()->InternalFieldCount() != npObjectInternalFieldCount) { throwError(v8ReferenceError, "NPMethod called on non-NPObject", args.GetIsolate()); return; } npObject = v8ObjectToNPObject(args.Holder()); } // Verify that our wrapper wasn't using a NPObject which has already been deleted. if (!npObject || !_NPN_IsAlive(npObject)) { throwError(v8ReferenceError, "NPObject deleted", args.GetIsolate()); return; } // Wrap up parameters. int numArgs = args.Length(); OwnArrayPtr<NPVariant> npArgs = adoptArrayPtr(new NPVariant[numArgs]); for (int i = 0; i < numArgs; i++) convertV8ObjectToNPVariant(args[i], npObject, &npArgs[i]); NPVariant result; VOID_TO_NPVARIANT(result); bool retval = true; switch (functionId) { case InvokeMethod: if (npObject->_class->invoke) { v8::Handle<v8::String> functionName = v8::Handle<v8::String>::Cast(args.Data()); NPIdentifier identifier = getStringIdentifier(functionName); retval = npObject->_class->invoke(npObject, identifier, npArgs.get(), numArgs, &result); } break; case InvokeConstruct: if (npObject->_class->construct) retval = npObject->_class->construct(npObject, npArgs.get(), numArgs, &result); break; case InvokeDefault: if (npObject->_class->invokeDefault) retval = npObject->_class->invokeDefault(npObject, npArgs.get(), numArgs, &result); break; default: break; } if (!retval) throwError(v8GeneralError, "Error calling method on NPObject.", args.GetIsolate()); for (int i = 0; i < numArgs; i++) _NPN_ReleaseVariantValue(&npArgs[i]); // Unwrap return values. v8::Handle<v8::Value> returnValue; if (_NPN_IsAlive(npObject)) returnValue = convertNPVariantToV8Object(&result, npObject, args.GetIsolate()); _NPN_ReleaseVariantValue(&result); v8SetReturnValue(args, returnValue); }
// KJS should only expose functions declared in npruntime.h (NPN_*) // and npruntime_priv.h (which is an extension of npruntime.h), and // not exposing _NPN_* functions declared in npruntime_impl.h. // KJSBridge implements NPN_* functions by wrapping around _NPN_* functions. // // Following styles in JavaScriptCore/bindings/npruntime.cpp void NPN_ReleaseVariantValue(NPVariant *variant) { _NPN_ReleaseVariantValue(variant); }