void convertToVariant(NPP npp, Object* value, NPVariant* variant, bool result) { if (!value) { NULL_TO_NPVARIANT(*variant); return; } if (ProxyObject* proxy = dynamic_cast<ProxyObject*>(value)) { if (result) { NPN_RetainObject(proxy->getNPObject()); } OBJECT_TO_NPVARIANT(proxy->getNPObject(), *variant); return; } if (PluginInstance* instance = static_cast<PluginInstance*>(npp->pdata)) { StubControl* stubControl = instance->getStubControl(); if (stubControl) { NPObject* object = stubControl->createStub(value); if (object) { if (result) { NPN_RetainObject(object); } OBJECT_TO_NPVARIANT(object, *variant); return; } } } NULL_TO_NPVARIANT(*variant); }
RuntimeNPObject::InvokeResult LibvlcRootNPObject::getProperty(int index, NPVariant &result) { /* is plugin still running */ if( isPluginRunning() ) { switch( index ) { case ID_root_audio: // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! audioObj ) audioObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcAudioNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(audioObj), result); return INVOKERESULT_NO_ERROR; case ID_root_input: // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! inputObj ) inputObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcInputNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(inputObj), result); return INVOKERESULT_NO_ERROR; case ID_root_playlist: // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! playlistObj ) playlistObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcPlaylistNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistObj), result); return INVOKERESULT_NO_ERROR; case ID_root_subtitle: // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! subtitleObj ) subtitleObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcSubtitleNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(subtitleObj), result); return INVOKERESULT_NO_ERROR; case ID_root_video: // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! videoObj ) videoObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcVideoNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(videoObj), result); return INVOKERESULT_NO_ERROR; case ID_root_VersionInfo: return invokeResultString(libvlc_get_version(),result); default: ; } } return INVOKERESULT_GENERIC_ERROR; }
bool JsAgent::onLoad(const NPVariant* args, unsigned argCount) { Debug::println("JsAgent::onLoad"); if(argCount != 4) { Debug::println("JsAgent::onLoad> argCount != 4"); return false; } if( !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_INT32(args[2]) || !NPVARIANT_IS_STRING(args[3]) ) { Debug::println("JsAgent::onLoad> arg types wrong"); return false; } NPObject* pObject = NPVARIANT_TO_OBJECT(args[0]); m_helper = NPN_RetainObject(pObject); NPObject* pDebug = NPN_CreateObject(getNPP(), GetNPClass<JsDebug>()); NPN_RetainObject(pDebug); Variant var; var.set(pDebug); if(!NPN_SetProperty(getNPP(), m_window, methods.debug, var.ptr())) { Debug::println("JsAgent::onLoad> set property failed"); return false; } NPString npstr = NPVARIANT_TO_STRING(args[1]); std::string host(npstr.UTF8Characters, npstr.UTF8Length); int port = NPVARIANT_TO_INT32(args[2]); npstr = NPVARIANT_TO_STRING(args[3]); std::string typeName(npstr.UTF8Characters, npstr.UTF8Length); if(!m_channel->connect(host.c_str(), port)) { Debug::println("JsAgent::onLoad> could not connect"); return false; } LoadMessage msg; msg.typeName = typeName; ArchiveWriter<Channel> ar(*m_channel); if(!Message::send(msg, ar)) { Debug::println("JsAgent::onLoad> send failed"); return false; } JsValue ret; return dispatchAndReturn(ret); }
NPObject* JsAgent::getRemoteObject(uint32_t id) { RefToObj_t::const_iterator it = m_remoteObjects.find(id); if(it == m_remoteObjects.end()) { JsObjectWrapper* wrapper = (JsObjectWrapper*)NPN_CreateObject(getNPP(), GetNPClass<JsObjectWrapper>()); wrapper->init(this, id); m_remoteObjects[id] = wrapper; return NPN_RetainObject(wrapper); } else { return NPN_RetainObject(it->second); } }
bool convert_mrb_to_js_data(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result) { if (DATA_TYPE(value) == &mrb_js_func_type){ NPObject *func = (NPObject *)DATA_PTR(value); NPN_RetainObject(func); OBJECT_TO_NPVARIANT(func, *result); return true; }else if (DATA_TYPE(value) == &mrb_js_obj_type){ NPObject *obj = (NPObject *)DATA_PTR(value); NPN_RetainObject(obj); OBJECT_TO_NPVARIANT(obj, *result); return true; } return false; }
NPObject* JsAgent::getLocalObject(uint32_t id) { RefToObj_t::const_iterator it = m_localRefToObj.find(id); if(it == m_localRefToObj.end()) return NULL; NPObject* ret = it->second; return NPN_RetainObject(ret); }
NPObject* CPlugin::GetWindowPropertyObject(const NPUTF8* szPropertyName) const { NPObject* pWindow = GetWindow(); NPVariant vObject; VOID_TO_NPVARIANT(vObject); if ((!NPN_GetProperty(m_pNPInstance, pWindow, GetIdentifier(szPropertyName), &vObject)) || !NPVARIANT_IS_OBJECT(vObject)) { if (!NPVARIANT_IS_VOID(vObject)) NPN_ReleaseVariantValue(&vObject); throw CString(_T("Cannot get window.")) + NPStringCharactersToCString(szPropertyName); } NPObject* pObject = NPVARIANT_TO_OBJECT(vObject); if (!pObject) { NPN_ReleaseVariantValue(&vObject); throw CString(_T("window.")) + NPStringCharactersToCString(szPropertyName) + _T(" is null"); } NPN_RetainObject(pObject); NPN_ReleaseVariantValue(&vObject); return pObject; }
bool nsScriptableObjectOverwolfSample::Echo( NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { if (argCount < 2 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_OBJECT(args[1])) { NPN_SetException(this, "invalid params passed to function"); return true; } // add ref count to callback object so it won't delete NPN_RetainObject(NPVARIANT_TO_OBJECT(args[1])); // convert into std::string std::string message; message.append( NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length); // post to separate thread so that we are responsive return thread_->PostTask( std::bind( &nsScriptableObjectOverwolfSample::EchoTask, this, message, NPVARIANT_TO_OBJECT(args[1]))); }
bool nsScriptableObjectOverwolfSample::Add( NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) { if (argCount < 3 || !NPVARIANT_IS_DOUBLE(args[0]) || !NPVARIANT_IS_DOUBLE(args[1]) || !NPVARIANT_IS_OBJECT(args[2])) { NPN_SetException(this, "invalid params passed to function"); return true; } // add ref count to callback object so it won't delete NPN_RetainObject(NPVARIANT_TO_OBJECT(args[2])); // post to separate thread so that we are responsive return thread_->PostTask( std::bind( &nsScriptableObjectOverwolfSample::AddTask, this, NPVARIANT_TO_DOUBLE(args[0]), NPVARIANT_TO_DOUBLE(args[1]), NPVARIANT_TO_OBJECT(args[2]))); }
// here we supply our scriptable object NPError nsPluginInstanceInputTracker::GetValue( NPPVariable variable, void* ret_value) { NPError rv = NPERR_INVALID_PARAM; switch (variable) { case NPPVpluginScriptableNPObject: { if (nullptr == scriptable_object_) { { CriticalSectionLocker lock(scriptable_object_CS_); scriptable_object_ = NPN_CreateObject( instance_, GET_NPOBJECT_CLASS(nsScriptableObjectInputTracker)); NPN_RetainObject(scriptable_object_); ((nsScriptableObjectInputTracker*)scriptable_object_)->Init(); *(NPObject **)ret_value = scriptable_object_; } } rv = NPERR_NO_ERROR; return rv; } default: break; } return rv; }
void nsPluginInstance::CreateScriptableObject() { NPObject *so = NPN_CreateObject(mInstance, &CPCManScriptable::MyClass); m_pPCManScriptable = (CPCManScriptable *) so; // We retain it until we are released ourselves. NPN_RetainObject(so); }
bool PluginMethodListenOnFile::ExecuteListenOnFile( const NPVariant *args, uint32_t argCount, NPVariant *result) { std::string filename; bool skip_to_end = false; try { if (argCount < 3 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_BOOLEAN(args[1]) || !NPVARIANT_IS_OBJECT(args[2])) { NPN_SetException( object_, "invalid or missing params passed to function - expecting 3 params: " "filename, skipToEnd, callback(status, data)"); return false; } callback_ = NPVARIANT_TO_OBJECT(args[2]); skip_to_end = NPVARIANT_TO_BOOLEAN(args[1]); // add ref count to callback object so it won't delete NPN_RetainObject(callback_); filename.append( NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length); } catch(...) { } if (nullptr == thread_.get()) { thread_.reset(new utils::Thread); if (!thread_->Start()) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't start file listening thread"); return false; } } std::wstring wide_filename = utils::Encoders::utf8_decode(filename); if (!file_stream_.Initialize(wide_filename.c_str(), this, skip_to_end)) { NPN_SetException( __super::object_, "an unexpected error occurred - couldn't open the file for read access"); return false; } return thread_->PostTask( std::bind( &PluginMethodListenOnFile::StartListening, this)); }
bool WriteReq::SetProperty(NPIdentifier name, const NPVariant *value) { if(value->type == NPVariantType_Object) { if(name == cb_func) { NPN_ReleaseObject(cb_callback); cb_callback = value->value.objectValue; NPN_RetainObject(cb_callback); } if(name == oncomplete_func) { NPN_ReleaseObject(oncomplete_callback); oncomplete_callback = value->value.objectValue; NPN_RetainObject(oncomplete_callback); } } return true; }
NPObject * CNPPluginMisc::GetScriptableObject() { if (!m_pScriptableObject) m_pScriptableObject = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); if (m_pScriptableObject) NPN_RetainObject(m_pScriptableObject); return m_pScriptableObject; }
void webapp_monitor_set_icon_loader_callback (NPObject *callback) { g_debug ("%s called", G_STRFUNC); if (!the_monitor) { g_debug ("%s monitor not initialized", G_STRFUNC); return; } the_monitor->icon_loader_callback = NPN_RetainObject (callback); }
NPObject *CPlugin::GetScriptableObject() { if (!m_pScriptableObject) { m_pScriptableObject = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); } if (m_pScriptableObject) { NPN_RetainObject(m_pScriptableObject); } return m_pScriptableObject; }
int OnHeadersComplete(http_parser* parser) { ParserWrap* wrap = (ParserWrap*)parser->data; NPP npp = wrap->m_Instance; // this is a bit hacky // we have to create an empty javascript object // so we use a function we created and passed to // the plugin NPVariant info; wrap->apply(wrap->create_info,NULL,0,&info); NPVariant major; major.type = NPVariantType_Double; major.value.doubleValue = parser->http_major; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("versionMajor"),&major); NPVariant minor; minor.type = NPVariantType_Double; minor.value.doubleValue = parser->http_major; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("versionMinor"),&minor); /*NPVariant method; method.type = NPVariantType_String; NPString method_str = {(NPUTF8 *)parser->method,strlen((char*)parser->method)}; method.value.stringValue = method; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("method"),&method);*/ NPVariant status; status.type = NPVariantType_Double; status.value.doubleValue = parser->status_code; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("statusCode"),&status); NPVariant upgrade; upgrade.type = NPVariantType_Bool; upgrade.value.boolValue = parser->upgrade; NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("upgrade"),&upgrade); NPVariant keepAlive; keepAlive.type = NPVariantType_Bool; keepAlive.value.boolValue = http_should_keep_alive(parser); NPN_SetProperty(npp,info.value.objectValue,NPN_GetStringIdentifier("shouldKeepAlive"),&keepAlive); NPVariant* args = new NPVariant; args->type = NPVariantType_Object; args->value.objectValue = info.value.objectValue; NPN_RetainObject(info.value.objectValue); NPVariant result; wrap->apply(wrap->onheaderscomplete_callback,args,1,&result); return 0; }
static NPError NPP_GetValue(NPP instance, NPPVariable variable, void* value) { InstanceData* id = NPPToInstance(instance); if (variable == NPPVpluginScriptableNPObject) { NPObject* obj = NPN_CreateObject(instance, const_cast<NPClass*>(&sProtoNPClass)); id->proto = NPN_RetainObject(obj); *static_cast<NPObject**>(value) = obj; return NPERR_NO_ERROR; } return NPERR_GENERIC_ERROR; }
NPObject* JsAgent::wrapDelegate(NPObject* obj) { VariantArray args(1); args[0].set(obj); Variant varRet; if(!NPN_Invoke(getNPP(), m_helper, methods.wrapDelegate, args.get(), args.size(), varRet.ptr())) return NULL; if(!varRet.isObject()) return NULL; return NPN_RetainObject(varRet.asObject()); }
bool TCPWrap::SetProperty(NPIdentifier name, const NPVariant *value) { if(name == onread_cb) { NPN_ReleaseObject(onread_callback); onread_callback = value->value.objectValue; NPN_RetainObject(onread_callback); } if(name == onconnection_cb) { NPN_ReleaseObject(onconnection_callback); onconnection_callback = value->value.objectValue; NPN_RetainObject(onconnection_callback); } if(name == socket_prop) { NPN_ReleaseObject(socket_pointer); socket_pointer = value->value.objectValue; NPN_RetainObject(socket_pointer); } return true; }
bool xplayerNPObject::ObjectVariant (NPVariant* _result, NPObject* object) { if (object) { NPN_RetainObject (object); OBJECT_TO_NPVARIANT (object, *_result); } else { NULL_TO_NPVARIANT (*_result); } return true; }
uint32_t JsAgent::getRefId(NPObject* pObject) { uint32_t id; ObjToRef_t::const_iterator it = m_localObjToRef.find(pObject); if(it == m_localObjToRef.end()) { id = m_lastRefId++; pObject = NPN_RetainObject(pObject); m_localObjToRef[pObject] = id; m_localRefToObj[id] = pObject; } else { id = it->second; } return id; }
NPObject * CPlugin::GetScriptableObject() { OutputDebugStringA("cplugin_getscriptableobject"); if (!m_pScriptableObject) { m_pScriptableObject = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); } if (m_pScriptableObject) { NPN_RetainObject(m_pScriptableObject); } return m_pScriptableObject; }
NPError StatementObject::Init(SQLHANDLE dbc, NPObject *conn) { m_hdbc = dbc; SQLHANDLE hstmt; NPError rc = CheckDbcRC(SQLAllocHandle(SQL_HANDLE_STMT, m_hdbc, &hstmt)); if (rc != NPERR_NO_ERROR) return rc; m_hstmt = hstmt; m_conn = conn; NPN_RetainObject(conn); return NPERR_NO_ERROR; }
NPObject * CPlugin::GetScriptableObject() { if (!m_pScriptableObject) { m_pScriptableObject = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); } if (m_pScriptableObject) { NPN_RetainObject(m_pScriptableObject); } //kk for invalidating the output ( (ScriptablePluginObject*) m_pScriptableObject )->m_hWnd = m_hWnd; return m_pScriptableObject; }
NPObject *CPlugin::GetScriptableObject() { if (!m_pScriptableObject) { m_pScriptableObject = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject)); if (m_pIEHostWindow) m_pIEHostWindow->RunAsync([this] { FireInitEvent(); }); } if (m_pScriptableObject) { NPN_RetainObject(m_pScriptableObject); } return m_pScriptableObject; }
bool ParserWrap::SetProperty(NPIdentifier name, const NPVariant *value) { NPObject** callback; if(name == onmessagebegin_func) { callback = &onmessagebegin_callback; } if(name == onurl_func) { callback = &onurl_callback; } if(name == onheaderfield_func) { callback = &onheaderfield_callback; } if(name == onheadervalue_func) { callback = &onheadervalue_callback; } if(name == onheaderscomplete_func) { callback = &onheaderscomplete_callback; } if(name == onbody_func) { callback = &onbody_callback; } if(name == onmessagecomplete_func) { callback = &onmessagecomplete_callback; } if(name == createinfo_prop) { callback = &create_info; } if(callback != NULL) { NPN_ReleaseObject(*callback); *callback = value->value.objectValue; NPN_RetainObject(*callback); } return true; }
void OnConnection(uv_stream_t* server, int status) { uv_tcp_t* stream = new uv_tcp_t; TCPWrap* tcpWrap = (TCPWrap*)server->data; TCPWrap* newTcpWrap = (TCPWrap*)NPN_CreateObject(tcpWrap->m_Instance,&TCPWrap::_npclass); newTcpWrap->init(stream); NPN_RetainObject((NPObject*)newTcpWrap); int r = uv_accept(server, (uv_stream_t*)stream); NPVariant* args = new NPVariant[1]; args[0].type = NPVariantType_Object; args[0].value.objectValue = (NPObject*)newTcpWrap; tcpWrap->fireCallback("onconnection",args,1); }
RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result) { /* is plugin still running */ if( isPluginRunning() ) { VlcPlugin* p_plugin = getPrivate<VlcPlugin>(); libvlc_exception_t ex; libvlc_exception_init(&ex); switch( index ) { case ID_playlist_itemcount: /* deprecated */ { int val = p_plugin->playlist_count(&ex); RETURN_ON_EXCEPTION(this,ex); INT32_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_playlist_isplaying: { int val = p_plugin->playlist_isplaying(&ex); RETURN_ON_EXCEPTION(this,ex); BOOLEAN_TO_NPVARIANT(val, result); return INVOKERESULT_NO_ERROR; } case ID_playlist_items: { // create child object in lazyman fashion to avoid // ownership problem with firefox if( ! playlistItemsObj ) playlistItemsObj = NPN_CreateObject(_instance, RuntimeNPClass< LibvlcPlaylistItemsNPObject>::getClass()); OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistItemsObj), result); return INVOKERESULT_NO_ERROR; } default: ; } } return INVOKERESULT_GENERIC_ERROR; }
NPError nsPluginInstanceOverwolfGW2::GetValue(NPPVariable variable, void* ret_value) { NPError rv = NPERR_INVALID_PARAM; switch (variable) { case NPPVpluginScriptableNPObject: if (scriptable_object == NULL) { scriptable_object = NPN_CreateObject(instance, GET_NPOBJECT_CLASS(nsScriptableObjectOverwolfGW2)); NPN_RetainObject(scriptable_object); ((nsScriptableObjectOverwolfGW2*)scriptable_object)->Init(); } *(NPObject **)ret_value = scriptable_object; rv = NPERR_NO_ERROR; default: break; } return rv; }