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;
}
