bool
ConstructablePluginObject::Construct(const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
printf("Creating new ConstructablePluginObject!\n");
NPObject *myobj =
NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
if (!myobj)
return false;
OBJECT_TO_NPVARIANT(myobj, *result);
return true;
}
bool convert_mrb_to_js(mrb_state *mrb, mrb_value value, NPP npp, NPVariant *result)
{
switch(mrb_type(value)){
case MRB_TT_FALSE:
if (mrb_nil_p(value)){
NULL_TO_NPVARIANT(*result);
}else{
BOOLEAN_TO_NPVARIANT(false, *result);
}
return true;
case MRB_TT_TRUE:
BOOLEAN_TO_NPVARIANT(true, *result);
return true;
case MRB_TT_FIXNUM:
INT32_TO_NPVARIANT(mrb_fixnum(value), *result);
return true;
case MRB_TT_FLOAT:
DOUBLE_TO_NPVARIANT(mrb_float(value), *result);
return true;
case MRB_TT_ARRAY:
return convert_mrb_to_js_array(mrb, value, npp, result);
case MRB_TT_HASH:
return convert_mrb_to_js_hash(mrb, value, npp, result);
case MRB_TT_STRING:
return convert_mrb_to_js_string(mrb, value, npp, result);
case MRB_TT_DATA:
return convert_mrb_to_js_data(mrb, value, npp, result);
case MRB_TT_PROC:
OBJECT_TO_NPVARIANT(MrbProcObject::Create(npp, mrb, value), *result);
return true;
default:
OBJECT_TO_NPVARIANT(MrbJsObject::Create(npp, mrb, value), *result);
return true;
}
return false;
}
static bool
plugin_object_get_property (NPObject *npobj,
NPIdentifier name,
NPVariant *result)
{
PluginObject *obj;
g_return_val_if_fail (plugin_object_has_property (npobj, name), FALSE);
obj = (PluginObject*) npobj;
if (obj->listener)
OBJECT_TO_NPVARIANT (obj->listener, *result);
else
NULL_TO_NPVARIANT (*result);
return TRUE;
}
static bool pluginGetProperty(NPObject* obj, NPIdentifier name, NPVariant* result)
{
PluginObject* plugin = reinterpret_cast<PluginObject*>(obj);
if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) {
STRINGZ_TO_NPVARIANT("property", *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) {
BOOLEAN_TO_NPVARIANT(plugin->eventLogging, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) {
BOOLEAN_TO_NPVARIANT(plugin->logDestroy, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_HAS_STREAM]) {
BOOLEAN_TO_NPVARIANT(plugin->stream != 0, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
NPObject* testObject = plugin->testObject;
browser->retainobject(testObject);
OBJECT_TO_NPVARIANT(testObject, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) {
BOOLEAN_TO_NPVARIANT(plugin->returnErrorFromNewStream, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_PRIVATE_BROWSING_ENABLED]) {
NPBool privateBrowsingEnabled = FALSE;
browser->getvalue(plugin->npp, NPNVprivateModeBool, &privateBrowsingEnabled);
BOOLEAN_TO_NPVARIANT(privateBrowsingEnabled, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_CACHED_PRIVATE_BROWSING_ENABLED]) {
BOOLEAN_TO_NPVARIANT(plugin->cachedPrivateBrowsingMode, *result);
return true;
} else if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) {
browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS");
return true;
} else if (name == pluginPropertyIdentifiers[ID_LAST_SET_WINDOW_ARGUMENTS]) {
char* buf = static_cast<char*>(browser->memalloc(256));
snprintf(buf, 256, "x: %d, y: %d, width: %u, height: %u, clipRect: (%u, %u, %u, %u)", (int)plugin->lastWindow.x, (int)plugin->lastWindow.y, (unsigned)plugin->lastWindow.width, (unsigned)plugin->lastWindow.height,
plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.top, plugin->lastWindow.clipRect.right - plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.bottom - plugin->lastWindow.clipRect.top);
STRINGZ_TO_NPVARIANT(buf, *result);
return true;
}
return false;
}
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
//kk
/*if (name == sBar_id) {
static int a = 17;
INT32_TO_NPVARIANT(a, *result);
a += 5;
return true;
}*/
char *pProp = NPN_UTF8FromIdentifier(name);
if( !strcmp( "Version", pProp ) )
{
char *p = (char*) NPN_MemAlloc( "Version 1.0" );//allocating Memory for the string with invocation of Browser-API
STRINGZ_TO_NPVARIANT( p, *result);
return true;
}
if( !strcmp( "Name", pProp ) )
{
char *p = (char*) NPN_MemAlloc( m_pszName );//allocating Memory for the string with invocation of Browser-API
STRINGZ_TO_NPVARIANT( p, *result);
return true;
}
if (name == sPluginType_id) {
NPObject *myobj =
NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
if (!myobj) {
return false;
}
OBJECT_TO_NPVARIANT(myobj, *result);
return true;
}
return true;
}
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
if (name == sPluginType_id) {
NPObject *myobj =
NPN_CreateObject(mNpp, GET_NPOBJECT_CLASS(ConstructablePluginObject));
if (!myobj) {
return false;
}
OBJECT_TO_NPVARIANT(myobj, *result);
return true;
}
return true;
}
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;
}
// Provide the appropriate value to JS.
bool BaseGetProperty(NPObject *obj, NPIdentifier name, NPVariant *result)
{
if (IS_IDENTIFIER("penAPI")) {
// The main part of the API is defined in the PenAPIObject.
// Retain and return this object.
NPObject *penObj = g_api.penAPI;
g_netscapeFuncs->retainobject(penObj);
OBJECT_TO_NPVARIANT(penObj, *result);
return true;
}
if (IS_IDENTIFIER("version")) {
// Return the PLUGIN_VERSION.
STRINGN_TO_NPVARIANT(strdup(PLUGIN_VERSION), sizeof(PLUGIN_VERSION), *result);
return true;
}
return false;
}
void ConvertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject *owner,
NPVariant* result) {
VOID_TO_NPVARIANT(*result);
// It is really the caller's responsibility to deal with the empty handle
// case because there could be different actions to take in different
// contexts.
ASSERT(!object.IsEmpty());
if (object.IsEmpty()) return;
if (object->IsNumber()) {
DOUBLE_TO_NPVARIANT(object->NumberValue(), *result);
} else if (object->IsBoolean()) {
BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result);
} else if (object->IsNull()) {
NULL_TO_NPVARIANT(*result);
} else if (object->IsUndefined()) {
VOID_TO_NPVARIANT(*result);
} else if (object->IsString()) {
v8::Handle<v8::String> str = object->ToString();
uint16_t *buf = new uint16_t[str->Length()+1];
str->Write(buf);
std::string utf8 = WideToUTF8(reinterpret_cast<wchar_t*>(buf));
char* utf8_chars = strdup(utf8.c_str());
STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result);
delete[] buf;
} else if (object->IsObject()) {
WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow();
NPObject* npobject = NPN_CreateScriptObject(
0, v8::Handle<v8::Object>::Cast(object), window);
if (npobject) {
_NPN_RegisterObject(npobject, owner);
}
OBJECT_TO_NPVARIANT(npobject, *result);
}
}
bool doGetCertificate(PluginInstance *obj, NPVariant *result) {
LOG_LOCATION;
FAIL_IF_NOT_ALLOWED_SITE;
char selectedCertID[33];
int dlg_result = 0;
#ifdef _WIN32
HWND ownerWindowHandle = (HWND)getNativeWindowHandle(obj);
EstEID_log("owner window handle passed to DialogBoxParam() = %08X", ownerWindowHandle);
dlg_result = (int)DialogBoxParam(pluginInstance, MAKEINTRESOURCE(IDD_CERTIFICATESELECTIONDLG), ownerWindowHandle, CertSelectionDialogProc, (LPARAM)selectedCertID);
#else
dlg_result = promptForCertificate(getNativeWindowHandle(obj), selectedCertID);
#endif
EstEID_log("Certificate selection dialog result = %i", dlg_result);
EstEID_log("Selected certificate ID = %s", selectedCertID);
if(dlg_result == IDCANCEL) {
sprintf(EstEID_error, "User canceled");
EstEID_errorCode = ESTEID_USER_CANCEL;
EstEID_log("EstEID_error = %s", EstEID_error);
browserFunctions->setexception(&obj->header, EstEID_error);
return false;
}
if(dlg_result == IDABORT) {
sprintf(EstEID_error, "No certificates");
EstEID_errorCode = ESTEID_CERT_NOT_FOUND_ERROR;
EstEID_log("EstEID_error = %s", EstEID_error);
browserFunctions->setexception(&obj->header, EstEID_error);
return false;
}
CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass());
certInstance->npp = obj->npp;
certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCertById(selectedCertID));
// certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCert());
EstEID_log("certObject=%p", certInstance);
OBJECT_TO_NPVARIANT((NPObject *)certInstance, *result);
EstEID_log("result=%p", result);
return true;
}
bool ObjectManager::Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) {
ScriptManager *obj = static_cast<ScriptManager*>(npobj);
if (name == NPNFuncs.getstringidentifier("CreateControlByProgId")) {
if (argCount != 1 || !NPVARIANT_IS_STRING(args[0])) {
NPNFuncs.setexception(npobj, "Invalid arguments");
return false;
}
CAxHost* host = new CAxHost(obj->instance);
CStringA str(NPVARIANT_TO_STRING(args[0]).UTF8Characters, NPVARIANT_TO_STRING(args[0]).UTF8Length);
host->setClsIDFromProgID(str.GetString());
if (!host->CreateControl(false)) {
NPNFuncs.setexception(npobj, "Error creating object");
return false;
}
ObjectManager *manager = static_cast<ObjectManager*>(obj->host);
manager->dynamic_hosts.push_back(host);
OBJECT_TO_NPVARIANT(host->CreateScriptableObject(), *result);
return true;
}
return false;
}
SEXP R_NP_GetGlobal(SEXP Rplug)
{
NPP inst = (NPP) R_ExternalPtrAddr(GET_SLOT( Rplug , Rf_install( "ref" ) ) );
NPNetscapeFuncs *funcs = (NPNetscapeFuncs *) R_ExternalPtrAddr(GET_SLOT( GET_SLOT(Rplug, Rf_install("funcs")), Rf_install("ref")));
NPObject *domwin = NULL;
NPVariant *toret = (NPVariant *) funcs->memalloc(sizeof(NPVariant));
//NPVariant vartmp2;
NPError res;
bool success;
res = funcs->getvalue(inst, NPNVWindowNPObject , &domwin);
funcs->retainobject(domwin);
OBJECT_TO_NPVARIANT(domwin, *toret);
SEXP ans;
PROTECT(ans = R_NilValue);
ConvertNPToR(toret, inst, funcs, CONV_REF, &ans);
UNPROTECT(1);
return ans;
}
void NPRuntimeObjectMap::convertJSValueToNPVariant(ExecState* exec, JSValue value, NPVariant& variant)
{
JSLockHolder lock(exec);
VOID_TO_NPVARIANT(variant);
if (value.isNull()) {
NULL_TO_NPVARIANT(variant);
return;
}
if (value.isUndefined()) {
VOID_TO_NPVARIANT(variant);
return;
}
if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), variant);
return;
}
if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), variant);
return;
}
if (value.isString()) {
NPString npString = createNPString(value.toString(exec)->value(exec).utf8());
STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, variant);
return;
}
if (value.isObject()) {
NPObject* npObject = getOrCreateNPObject(exec->vm(), asObject(value));
OBJECT_TO_NPVARIANT(npObject, variant);
return;
}
ASSERT_NOT_REACHED();
}
static mrb_value mrb_js_func_call(mrb_state *mrb, mrb_value self)
{
NPP npp = MRB_UD_NPP(mrb);
NPObject *func = (NPObject *)DATA_PTR(self);
if (!func){
return mrb_nil_value();
}
mrb_value *values;
int len;
mrb_get_args(mrb, "*", &values, &len);
NPVariant empty = { NPVariantType_Void, NULL };
std::vector< NPVariant > args(len + 1, empty);
bool success = true;
for (int i=0; i<len; i++){
if (!convert_mrb_to_js(mrb, values[i], npp, &args[i + 1])){
success = false;
break;
}
}
mrb_value ret = mrb_nil_value();
if (success){
NPObject *window;
NPN_GetValue(npp, NPNVWindowNPObject, &window);
NPVariant result;
OBJECT_TO_NPVARIANT(window, args[0]);
NPN_Invoke(npp, func, NPN_GetStringIdentifier("call"), &args[0], args.size(), &result);
convert_js_to_mrb(npp, result, mrb, &ret);
}
for (int i=0; i<len+1; i++){
NPN_ReleaseVariantValue(&args[i]);
}
return ret;
}
bool APPLICATION_GetProperty(NPObject* obj, NPIdentifier name, NPVariant* result)
{
TRACEINFO;
bool fctresult = false;
NPObj_Application* AppliObj = (NPObj_Application*)obj;
if (name == v_APPLICATIONPropertyIdentifiers[kAPPLICATION_ID_PROPERTY_PRIVATEDATA])
{
sBrowserFuncs->retainobject(AppliObj->privateData);
OBJECT_TO_NPVARIANT(AppliObj->privateData, *result);
fctresult = true;
}
else if (name == v_APPLICATIONPropertyIdentifiers[kAPPLICATION_ID_PROPERTY_VISIBLE])
{
BOOLEAN_TO_NPVARIANT(AppliObj->visible, *result);
fctresult = true;
}
else
return fctresult;
}
bool PluginControllerProxy::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups)
{
PluginDestructionProtector protector(this);
NPVariant npObjectAsNPVariant;
OBJECT_TO_NPVARIANT(npObject, npObjectAsNPVariant);
// Send the NPObject over as an NPVariantData.
NPVariantData npObjectAsNPVariantData = m_connection->npRemoteObjectMap()->npVariantToNPVariantData(npObjectAsNPVariant, m_plugin.get());
bool returnValue = false;
NPVariantData resultData;
if (!m_connection->connection()->sendSync(Messages::PluginProxy::Evaluate(npObjectAsNPVariantData, scriptString, allowPopups), Messages::PluginProxy::Evaluate::Reply(returnValue, resultData), m_pluginInstanceID))
return false;
if (!returnValue)
return false;
*result = m_connection->npRemoteObjectMap()->npVariantDataToNPVariant(resultData, m_plugin.get());
return true;
}
GenericNPObject::GenericNPObject(NPP instance, bool isMethodObj):
invalid(false), defInvoker(NULL), defInvokerObject(NULL) {
NPVariant val;
INT32_TO_NPVARIANT(0, val);
immutables["length"] = val;
if (!isMethodObj) {
NPObject *obj = NULL;
obj = NPNFuncs.createobject(instance, &MethodNPObjectClass);
if (NULL == obj) {
throw NULL;
}
((GenericNPObject *)obj)->SetDefaultInvoker(&toString, this);
OBJECT_TO_NPVARIANT(obj, val);
immutables["toString"] = val;
}
}
static Eina_Bool ewk_js_variant_to_npvariant(const Ewk_JS_Variant* data, NPVariant* result)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(data, false);
EINA_SAFETY_ON_NULL_RETURN_VAL(result, false);
const char* string_value;
switch (data->type) {
case EWK_JS_VARIANT_VOID:
VOID_TO_NPVARIANT(*result);
break;
case EWK_JS_VARIANT_NULL:
NULL_TO_NPVARIANT(*result);
break;
case EWK_JS_VARIANT_INT32:
INT32_TO_NPVARIANT(data->value.i, *result);
break;
case EWK_JS_VARIANT_DOUBLE:
DOUBLE_TO_NPVARIANT(data->value.d, *result);
break;
case EWK_JS_VARIANT_STRING:
string_value = eina_stringshare_add(data->value.s);
if (string_value)
STRINGZ_TO_NPVARIANT(string_value, *result);
else
return false;
break;
case EWK_JS_VARIANT_BOOL:
BOOLEAN_TO_NPVARIANT(data->value.b, *result);
break;
case EWK_JS_VARIANT_OBJECT:
OBJECT_TO_NPVARIANT(reinterpret_cast<NPObject*>(data->value.o), *result);
break;
default:
return false;
}
return true;
}
void testNPRuntime(NPP npp)
{
NPObject* windowScriptObject;
browser->getvalue(npp, NPNVWindowNPObject, &windowScriptObject);
// Invoke
NPIdentifier testNPInvoke = browser->getstringidentifier("testNPInvoke");
NPVariant args[7];
VOID_TO_NPVARIANT(args[0]);
NULL_TO_NPVARIANT(args[1]);
BOOLEAN_TO_NPVARIANT(true, args[2]);
INT32_TO_NPVARIANT(242, args[3]);
DOUBLE_TO_NPVARIANT(242.242, args[4]);
STRINGZ_TO_NPVARIANT("Hello, World", args[5]);
OBJECT_TO_NPVARIANT(windowScriptObject, args[6]);
NPVariant result;
if (browser->invoke(npp, windowScriptObject, testNPInvoke, args, 7, &result))
browser->releasevariantvalue(&result);
browser->releaseobject(windowScriptObject);
}
bool NPSafeArray::InvokeDefault(NPObject *npobj, const NPVariant *args, uint32_t argCount,
NPVariant *result) {
NPSafeArray *safe = static_cast<NPSafeArray*>(npobj);
if (safe->arr_.m_psa != NULL)
return false;
if (argCount < 1)
return false;
if (!NPVARIANT_IS_OBJECT(*args)) {
return false;
}
NPObject *obj = NPVARIANT_TO_OBJECT(*args);
if (obj->_class != &NPSafeArray::npClass) {
return false;
}
NPSafeArray *safe_original = static_cast<NPSafeArray*>(obj);
if (safe_original->arr_.m_psa == NULL) {
return false;
}
NPSafeArray *ret = CreateFromArray(safe->instance, safe_original->arr_);
OBJECT_TO_NPVARIANT(ret, *result);
return true;
}
static bool
invokeMethod(NPObject *obj, NPIdentifier identifier, const NPVariant *args, uint32_t argc, NPVariant *result)
{
char *argv[20];
int i;
char *ptr;
if (identifier == identifiers->start) {
DEBUG_STR("plugin->whois->invokeMethod(%s): true", DEBUG_IDENTIFIER(identifier));
/* Just the URL argument can be passed from JavaScript */
if (argc != 1 || args[0].type != NPVariantType_String)
return false;
/* First argument should be command path/name */
i = 0;
argv[i++] = ((shell_module *)whois)->path;
/* Set the URL as the last argument */
argv[i++] = (char *)STRING_UTF8CHARACTERS(args[0].value.stringValue);
/* Set NULL-terminating argument */
argv[i++] = NULL;
OBJECT_TO_NPVARIANT(browser->createobject(((object *)obj)->instance, &processClass), *result);
if (shell->run((process *)result->value.objectValue, ((shell_module *)whois)->path, argv))
return true;
else
return false;
}
DEBUG_STR("plugin->whois->invokeMethod(%s): false", DEBUG_IDENTIFIER(identifier));
return false;
}
CPlugin::CPlugin(NPP pNPInstance) :
m_pNPInstance(pNPInstance),
m_pNPStream(NULL),
m_bInitialized(FALSE),
m_pScriptableObject(NULL)
{
NPVariant v;
NPVariant rval;
NPObject *browserWndObj = NULL;
#ifdef XP_WIN
m_hWnd = NULL;
#endif
// setup the display string
const char *ua = NPN_UserAgent(m_pNPInstance);
strcpy(m_String, ua);
if ( NPERR_NO_ERROR == NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &browserWndObj))
{
// this is interesting.
// Here we are setting up an instance in JavaScript of the ScriptablePluginObject
// by inserting a new instance into the DOM. this will be referenced by document.pluginobj;
//
NPObject *myobj = NPN_CreateObject(m_pNPInstance, GET_NPOBJECT_CLASS(ScriptablePluginObject));
if ( myobj )
{
// create an identifier for the plugin object
NPIdentifier n = NPN_GetStringIdentifier("pluginobj");
// now insert into the DOM
OBJECT_TO_NPVARIANT(myobj, v);
if (NPN_SetProperty(m_pNPInstance, browserWndObj, n, &v))
{
// validate the object
if ( NPN_GetProperty(m_pNPInstance, browserWndObj, n, &rval) )
{
printf ("Object set/get test ");
if (NPVARIANT_IS_OBJECT(rval) && NPVARIANT_TO_OBJECT(rval) == myobj) {
printf ("succeeded!\n");
} else {
printf ("FAILED!\n");
}
}
else
{
printf("failed to get pluginobj");
}
NPN_ReleaseVariantValue(&rval);
}
else
{
printf("failed to set pluginobj");
}
NPN_ReleaseObject(myobj);
}
else
{
printf("failed to create pluginobj");
}
}
else
{
printf("failed to get browser window");
}
}
static bool
NPChewingInvoke(NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
uint8_t symbol = -1;
for (int i = 0; i < METHOD_LENGTH; ++i) {
if (sSymbolIdentifierMap[i].id == name) {
symbol = sSymbolIdentifierMap[i].symbol;
break;
}
}
bool rv = false;
NPChewingObject* obj = (NPChewingObject*)npobj;
if (!obj->ctx) {
return false;
}
switch (symbol) {
case HANDLE_DEFAULT:
{
if (argCount != 1) {
break;
}
if (!NPVARIANT_IS_INT32(args[0])) {
break;
}
int32_t key = NPVARIANT_TO_INT32(args[0]);
int32_t r = chewing.chewing_handle_Default(obj->ctx, key);
INT32_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case HANDLE_ENTER:
{
if (argCount != 0) {
break;
}
int32_t r = chewing.chewing_handle_Enter(obj->ctx);
INT32_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case BUFFER_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_buffer_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
char* str = chewing.chewing_buffer_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case COMMIT_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_commit_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
char* str = chewing.chewing_commit_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case ZHUYIN_STRING:
{
if (argCount != 0) {
break;
}
if (!chewing.chewing_zuin_Check(obj->ctx)) {
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
int count = 0;
char* str = chewing.chewing_zuin_String(obj->ctx, &count);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
STRINGZ_TO_NPVARIANT(r, *result);
rv = true;
break;
}
case CANDIDATES_LIST:
{
if (argCount != 0) {
break;
}
// open candidates list
chewing.chewing_handle_Down(obj->ctx);
// create a array object
NPObject* window = NULL;
npn_getValue(obj->npp, NPNVWindowNPObject, &window);
NPObject* array = NULL;
NPVariant arrayVar;
npn_invoke(obj->npp,
window,
npn_getStringIdentifier("Array"),
NULL,
0,
&arrayVar);
array = NPVARIANT_TO_OBJECT(arrayVar);
npn_releaseObject(window);
// Push all candidates to array
NPIdentifier push = npn_getStringIdentifier("push");
chewing.chewing_cand_Enumerate(obj->ctx);
bool hasCandidates = false;
while (chewing.chewing_cand_hasNext(obj->ctx)) {
hasCandidates = true;
char* str = chewing.chewing_cand_String(obj->ctx);
char* r = (char*)npn_malloc(strlen(str)+1);
strcpy(r, str);
chewing.chewing_free(str);
NPVariant item;
NPVariant unused;
STRINGZ_TO_NPVARIANT(r, item);
npn_invoke(obj->npp, array, push, &item, 1, &unused);
npn_releaseVariantValue(&unused);
}
OBJECT_TO_NPVARIANT(array, *result);
rv = true;
if (hasCandidates)
chewing.chewing_handle_Esc(obj->ctx);
break;
}
case SELECT_CANDIDATE:
{
if (argCount != 1) {
break;
}
if (!NPVARIANT_IS_INT32(args[0])) {
break;
}
int32_t n = NPVARIANT_TO_INT32(args[0]);
chewing.chewing_handle_Down(obj->ctx);
chewing.chewing_cand_Select(obj->ctx, n);
NULL_TO_NPVARIANT(*result);
rv = true;
break;
}
default:
break;
}
return rv;
}
static bool pluginInvoke(NPObject *header, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
PluginObject *obj = (PluginObject *)header;
if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) {
// call whatever method name we're given
if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult);
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) {
if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPUTF8* targetString = createCStringFromNPVariant(&args[1]);
browser->geturl(obj->npp, urlString, targetString);
free(urlString);
free(targetString);
VOID_TO_NPVARIANT(*result);
return true;
} else if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
browser->geturl(obj->npp, urlString, 0);
free(urlString);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_REMOVE_DEFAULT_METHOD]) {
pluginClass.invokeDefault = 0;
VOID_TO_NPVARIANT(*result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) {
testDOMAccess(obj);
VOID_TO_NPVARIANT(*result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY]) {
if (argCount == 3
&& NPVARIANT_IS_STRING(args[0])
&& (NPVARIANT_IS_STRING(args[1]) || NPVARIANT_IS_NULL(args[1]))
&& NPVARIANT_IS_STRING(args[2])) {
NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
NPUTF8* targetString = (NPVARIANT_IS_STRING(args[1]) ? createCStringFromNPVariant(&args[1]) : NULL);
NPUTF8* callbackString = createCStringFromNPVariant(&args[2]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
browser->geturlnotify(obj->npp, urlString, targetString, callbackIdentifier);
free(urlString);
free(targetString);
free(callbackString);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT] && NPVARIANT_IS_OBJECT(args[0])) {
NPObject *callback = NPVARIANT_TO_OBJECT(args[0]);
NPVariant args[1];
NPVariant browserResult;
STRINGZ_TO_NPVARIANT("test", args[0]);
bool retval = browser->invokeDefault(obj->npp, callback, args, 1, &browserResult);
if (retval)
browser->releasevariantvalue(&browserResult);
BOOLEAN_TO_NPVARIANT(retval, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE]) {
if (argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_OBJECT(args[1])) {
uint32_t count;
NPIdentifier* identifiers;
if (browser->enumerate(obj->npp, NPVARIANT_TO_OBJECT(args[0]), &identifiers, &count)) {
NPObject* outArray = NPVARIANT_TO_OBJECT(args[1]);
NPIdentifier pushIdentifier = browser->getstringidentifier("push");
for (uint32_t i = 0; i < count; i++) {
NPUTF8* string = browser->utf8fromidentifier(identifiers[i]);
if (!string)
continue;
NPVariant args[1];
STRINGZ_TO_NPVARIANT(string, args[0]);
NPVariant browserResult;
browser->invoke(obj->npp, outArray, pushIdentifier, args, 1, &browserResult);
browser->releasevariantvalue(&browserResult);
browser->memfree(string);
}
browser->memfree(identifiers);
}
VOID_TO_NPVARIANT(*result);
return true;
}
return false;
} else if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM]) {
NPError npError = browser->destroystream(obj->npp, obj->stream, NPRES_USER_BREAK);
INT32_TO_NPVARIANT(npError, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER]) {
if (argCount == 1) {
NPIdentifier identifier;
if (NPVARIANT_IS_DOUBLE(args[0])) {
identifier = browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0]));
INT32_TO_NPVARIANT((int32)identifier, *result);
return true;
} else if (NPVARIANT_IS_INT32(args[0])) {
identifier = browser->getintidentifier((int)NPVARIANT_TO_INT32(args[0]));
INT32_TO_NPVARIANT((int32)identifier, *result);
return true;
}
}
} else if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE] &&
argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPString s = NPVARIANT_TO_STRING(args[0]);
bool retval = browser->evaluate(obj->npp, windowScriptObject, &s, result);
browser->releaseobject(windowScriptObject);
return retval;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY] &&
argCount > 0) {
NPObject *object;
browser->getvalue(obj->npp, NPNVWindowNPObject, &object);
for (uint32_t i = 0; i < argCount; i++) {
//assert(NPVARIANT_IS_STRING(args[i]));
NPUTF8* propertyString = createCStringFromNPVariant(&args[i]);
NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
free(propertyString);
NPVariant variant;
bool retval = browser->getproperty(obj->npp, object, propertyIdentifier, &variant);
browser->releaseobject(object);
if (!retval)
break;
if (i + 1 < argCount) {
//assert(NPVARIANT_IS_OBJECT(variant));
object = NPVARIANT_TO_OBJECT(variant);
} else {
*result = variant;
return true;
}
}
VOID_TO_NPVARIANT(*result);
return false;
} else if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE] &&
argCount == 2 && NPVARIANT_IS_OBJECT(args[0]) && NPVARIANT_IS_STRING(args[1])) {
NPUTF8* propertyString = createCStringFromNPVariant(&args[1]);
NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
free(propertyString);
NPVariant variant;
bool retval = browser->getproperty(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier, &variant);
if (retval)
browser->releasevariantvalue(&variant);
BOOLEAN_TO_NPVARIANT(retval, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RET]) {
// call whatever method name we're given, and pass it the 'window' obj.
// we expect the function to return its argument.
if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant callbackArgs[1];
OBJECT_TO_NPVARIANT(windowScriptObject, callbackArgs[0]);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier,
callbackArgs, 1, &browserResult);
if (NPVARIANT_IS_OBJECT(browserResult)) {
// Now return the callbacks return value back to our caller.
// BUG 897451: This should be the same as the
// windowScriptObject, but its not (in Chrome) - or at least, it
// has a different refcount. This means Chrome will delete the
// object before returning it and the calling JS gets a garbage
// value. Firefox handles it fine.
OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(browserResult), *result);
} else {
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
}
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) {
NPObject *testObject = browser->createobject(obj->npp, getTestClass());
//assert(testObject->referenceCount == 1);
OBJECT_TO_NPVARIANT(testObject, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT]) {
// call whatever method name we're given, and pass it our second
// argument.
if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) {
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
free(callbackString);
NPVariant browserResult;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &browserResult);
browser->releasevariantvalue(&browserResult);
VOID_TO_NPVARIANT(*result);
return true;
}
} else if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) {
// Create another instance of the same class
NPObject *new_object = browser->createobject(obj->npp, &pluginClass);
//assert(new_object->referenceCount == 1);
OBJECT_TO_NPVARIANT(new_object, *result);
return true;
} else if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE]) {
if (argCount > 1 && NPVARIANT_IS_STRING(args[0])) {
// Invoke a script callback to get a script NPObject. Then call
// a method on the script NPObject passing it a freshly created
// NPObject.
// Arguments:
// arg1: Callback that returns a script object.
// arg2: Name of the method to call on the script object returned
// from the callback
NPObject *windowScriptObject;
browser->getvalue(obj->npp, NPNVWindowNPObject,
&windowScriptObject);
// Arg1 is the name of the callback
NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
NPIdentifier callbackIdentifier =
browser->getstringidentifier(callbackString);
free(callbackString);
// Invoke a callback that returns a script object
NPVariant object_result;
browser->invoke(obj->npp, windowScriptObject, callbackIdentifier,
&args[1], 1, &object_result);
// Script object returned
NPObject *script_object = object_result.value.objectValue;
// Arg2 is the name of the method to be called on the script object
NPUTF8* object_mehod_string = createCStringFromNPVariant(&args[1]);
NPIdentifier object_method =
browser->getstringidentifier(object_mehod_string);
free(object_mehod_string);
// Create a fresh NPObject to be passed as an argument
NPObject *object_arg = browser->createobject(obj->npp, &pluginClass);
NPVariant invoke_args[1];
OBJECT_TO_NPVARIANT(object_arg, invoke_args[0]);
// Invoke the script method
NPVariant object_method_result;
browser->invoke(obj->npp, script_object, object_method,
invoke_args, 1, &object_method_result);
browser->releasevariantvalue(&object_result);
VOID_TO_NPVARIANT(*result);
if (NPVARIANT_IS_OBJECT(object_method_result)) {
// Now return the callbacks return value back to our caller.
// BUG 897451: This should be the same as the
// windowScriptObject, but its not (in Chrome) - or at least, it
// has a different refcount. This means Chrome will delete the
// object before returning it and the calling JS gets a garbage
// value. Firefox handles it fine.
OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(object_method_result),
*result);
} else {
browser->releasevariantvalue(&object_method_result);
VOID_TO_NPVARIANT(*result);
}
return true;
}
}
return false;
}
CPlugin::CPlugin(NPP pNPInstance) :
m_pNPInstance(pNPInstance),
m_pNPStream(NULL),
m_bInitialized(false),
m_pScriptableObject(NULL)
{
#ifdef XP_WIN
m_hWnd = NULL;
#endif
NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &sWindowObj);
NPIdentifier n = NPN_GetStringIdentifier("foof");
sFoo_id = NPN_GetStringIdentifier("foo");
sBar_id = NPN_GetStringIdentifier("bar");
sDocument_id = NPN_GetStringIdentifier("document");
sBody_id = NPN_GetStringIdentifier("body");
sCreateElement_id = NPN_GetStringIdentifier("createElement");
sCreateTextNode_id = NPN_GetStringIdentifier("createTextNode");
sAppendChild_id = NPN_GetStringIdentifier("appendChild");
sPluginType_id = NPN_GetStringIdentifier("PluginType");
NPVariant v;
INT32_TO_NPVARIANT(46, v);
NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v);
NPVariant rval;
NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval);
if (NPVARIANT_IS_INT32(rval)) {
printf("rval = %d\n", NPVARIANT_TO_INT32(rval));
}
n = NPN_GetStringIdentifier("document");
if (!NPN_IdentifierIsString(n)) {
NPString str;
str.UTF8Characters = "alert('NPN_IdentifierIsString() test failed!');";
str.UTF8Length = strlen(str.UTF8Characters);
NPN_Evaluate(m_pNPInstance, sWindowObj, &str, NULL);
}
NPObject *doc;
NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval);
if (NPVARIANT_IS_OBJECT(rval) && (doc = NPVARIANT_TO_OBJECT(rval))) {
n = NPN_GetStringIdentifier("title");
NPN_GetProperty(m_pNPInstance, doc, n, &rval);
if (NPVARIANT_IS_STRING(rval)) {
printf ("title = %s\n", NPVARIANT_TO_STRING(rval).UTF8Characters);
NPN_ReleaseVariantValue(&rval);
}
n = NPN_GetStringIdentifier("plugindoc");
OBJECT_TO_NPVARIANT(doc, v);
NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v);
NPString str;
str.UTF8Characters = "document.getElementById('result').innerHTML += '<p>' + 'NPN_Evaluate() test, document = ' + this + '</p>';";
str.UTF8Length = strlen(str.UTF8Characters);
//NPN_Evaluate(m_pNPInstance, doc, &str, NULL);
NPN_ReleaseObject(doc);
}
NPVariant barval;
NPN_GetProperty(m_pNPInstance, sWindowObj, sBar_id, &barval);
NPVariant arg;
OBJECT_TO_NPVARIANT(sWindowObj, arg);
NPN_InvokeDefault(m_pNPInstance, NPVARIANT_TO_OBJECT(barval), &arg, 1,
&rval);
if (NPVARIANT_IS_INT32(rval) && NPVARIANT_TO_INT32(rval) == 4) {
printf ("Default function call SUCCEEDED!\n");
} else {
printf ("Default function call FAILED!\n");
}
NPN_ReleaseVariantValue(&barval);
NPN_ReleaseVariantValue(&rval);
#if 0
n = NPN_GetStringIdentifier("prompt");
NPVariant vars[3];
STRINGZ_TO_NPVARIANT("foo", vars[0]);
STRINGZ_TO_NPVARIANT("bar", vars[1]);
STRINGZ_TO_NPVARIANT("foof", vars[2]);
NPN_Invoke(sWindowObj, n, vars, 3, &rval);
if (NPVARIANT_IS_STRING(rval)) {
printf ("prompt returned '%s'\n", NPVARIANT_TO_STRING(rval).UTF8Characters);
}
NPN_ReleaseVariantValue(&rval);
#endif
NPObject *myobj =
NPN_CreateObject(m_pNPInstance,
GET_NPOBJECT_CLASS(ScriptablePluginObject));
n = NPN_GetStringIdentifier("pluginobj");
OBJECT_TO_NPVARIANT(myobj, v);
NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v);
NPN_GetProperty(m_pNPInstance, sWindowObj, n, &rval);
printf ("Object set/get test ");
if (NPVARIANT_IS_OBJECT(rval) && NPVARIANT_TO_OBJECT(rval) == myobj) {
printf ("succeeded!\n");
} else {
printf ("FAILED!\n");
}
NPN_ReleaseVariantValue(&rval);
NPN_ReleaseObject(myobj);
const char *ua = NPN_UserAgent(m_pNPInstance);
strcpy(m_String, ua);
}
CPlugin::CPlugin(NPP pNPInstance) :
m_pNPInstance(pNPInstance),
m_pNPStream(NULL),
m_bInitialized(FALSE),
m_pScriptableObject(NULL)
{
#ifdef XP_WIN
m_hWnd = NULL;
#endif
NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &sWindowObj);
NPIdentifier n = NPN_GetStringIdentifier("foof");
sendCmd_id = NPN_GetStringIdentifier("sendCmd");
NPVariant v;
INT32_TO_NPVARIANT(46, v);
NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v);
n = NPN_GetStringIdentifier("document");
NPVariant arg;
OBJECT_TO_NPVARIANT(sWindowObj, arg);
NPObject *myobj =
NPN_CreateObject(m_pNPInstance,
GET_NPOBJECT_CLASS(ScriptablePluginObject));
n = NPN_GetStringIdentifier("objJSExt");
OBJECT_TO_NPVARIANT(myobj, v);
NPN_SetProperty(m_pNPInstance, sWindowObj, n, &v);
NPN_ReleaseObject(myobj);
const char *ua = NPN_UserAgent(m_pNPInstance);
strcpy(m_String, ua);
// Create a "location" identifier.
NPIdentifier identifier = NPN_GetStringIdentifier( "location" );
// Declare a local variant value.
NPVariant variantValue;
// Get the location property from the window object (which is another object).
bool b1 = NPN_GetProperty( m_pNPInstance, sWindowObj, identifier, &variantValue );
// Get a pointer to the "location" object.
NPObject *locationObj = variantValue.value.objectValue;
// Create a "href" identifier.
identifier = NPN_GetStringIdentifier( "href" );
// Get the location property from the location object.
bool b2 = NPN_GetProperty( m_pNPInstance, locationObj, identifier, &variantValue );
g_strPageURL = "";
NPString npStr = NPVARIANT_TO_STRING( variantValue );
for (unsigned int i=0; i<npStr.utf8length; i++)
{
g_strPageURL += npStr.utf8characters[ i ];
}
NPN_ReleaseObject(locationObj);
}
void convertJValueToNPVariant(jvalue value, JNIType jniType, const char* javaTypeName, NPVariant* result)
{
switch (jniType) {
case void_type:
{
VOID_TO_NPVARIANT(*result);
}
break;
case object_type:
{
if (value.l) {
if (!strcmp(javaTypeName, "java.lang.String")) {
const char* v = getCharactersFromJString(static_cast<jstring>(value.l));
// s is freed in NPN_ReleaseVariantValue (see npruntime.cpp)
const char* s = strdup(v);
releaseCharactersForJString(static_cast<jstring>(value.l), v);
STRINGZ_TO_NPVARIANT(s, *result);
} else
OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(new JavaInstance(value.l)), *result);
} else
VOID_TO_NPVARIANT(*result);
}
break;
case boolean_type:
{
BOOLEAN_TO_NPVARIANT(value.z, *result);
}
break;
case byte_type:
{
INT32_TO_NPVARIANT(value.b, *result);
}
break;
case char_type:
{
INT32_TO_NPVARIANT(value.c, *result);
}
break;
case short_type:
{
INT32_TO_NPVARIANT(value.s, *result);
}
break;
case int_type:
{
INT32_TO_NPVARIANT(value.i, *result);
}
break;
// TODO: Check if cast to double is needed.
case long_type:
{
DOUBLE_TO_NPVARIANT(value.j, *result);
}
break;
case float_type:
{
DOUBLE_TO_NPVARIANT(value.f, *result);
}
break;
case double_type:
{
DOUBLE_TO_NPVARIANT(value.d, *result);
}
break;
case invalid_type:
default:
{
VOID_TO_NPVARIANT(*result);
}
break;
}
}
static bool pluginInvoke(NPObject* header, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
PluginObject* plugin = reinterpret_cast<PluginObject*>(header);
if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD])
return testCallback(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RETURN])
return testCallbackReturn(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_GETURL])
return getURL(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS])
return testDOMAccess(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY])
return getURLNotify(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT])
return testInvokeDefault(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE])
return testEnumerate(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM])
return destroyStream(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER])
return testGetIntIdentifier(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE])
return testEvaluate(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY])
return testGetProperty(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE])
return testGetPropertyReturnValue(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_HAS_PROPERTY])
return testHasProperty(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_HAS_METHOD])
return testHasMethod(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_STRING])
return testIdentifierToString(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_INT])
return testIdentifierToInt(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT])
return testPassTestObject(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_POSTURL_FILE])
return testPostURLFile(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_CONSTRUCT])
return testConstruct(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE])
return testScriptObjectInvoke(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_THROW_EXCEPTION_METHOD]) {
browser->setexception(header, "plugin object testThrowException SUCCESS");
return true;
}
if (name == pluginMethodIdentifiers[ID_TEST_FAIL_METHOD]) {
NPObject* windowScriptObject;
browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject);
browser->invoke(plugin->npp, windowScriptObject, name, args, argCount, result);
return false;
}
if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) {
NPObject* new_object = browser->createobject(plugin->npp, &pluginClass);
assert(new_object->referenceCount == 1);
OBJECT_TO_NPVARIANT(new_object, *result);
return true;
}
if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) {
NPObject* testObject = browser->createobject(plugin->npp, getTestClass());
assert(testObject->referenceCount == 1);
OBJECT_TO_NPVARIANT(testObject, *result);
return true;
}
if (name == pluginMethodIdentifiers[ID_DESTROY_NULL_STREAM])
return destroyNullStream(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_NO_PAGES]) {
browser->reloadplugins(false);
return true;
}
if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_AND_PAGES]) {
browser->reloadplugins(true);
return true;
}
if (name == pluginMethodIdentifiers[ID_TEST_GET_BROWSER_PROPERTY]) {
browser->getproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), result);
return true;
}
if (name == pluginMethodIdentifiers[ID_TEST_SET_BROWSER_PROPERTY]) {
browser->setproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), &args[2]);
return true;
}
if (name == pluginMethodIdentifiers[ID_REMEMBER]) {
if (plugin->rememberedObject)
browser->releaseobject(plugin->rememberedObject);
plugin->rememberedObject = NPVARIANT_TO_OBJECT(args[0]);
browser->retainobject(plugin->rememberedObject);
VOID_TO_NPVARIANT(*result);
return true;
}
if (name == pluginMethodIdentifiers[ID_GET_REMEMBERED_OBJECT]) {
assert(plugin->rememberedObject);
browser->retainobject(plugin->rememberedObject);
OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result);
return true;
}
if (name == pluginMethodIdentifiers[ID_GET_AND_FORGET_REMEMBERED_OBJECT]) {
assert(plugin->rememberedObject);
OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result);
plugin->rememberedObject = 0;
return true;
}
if (name == pluginMethodIdentifiers[ID_REF_COUNT]) {
uint32_t refCount = NPVARIANT_TO_OBJECT(args[0])->referenceCount;
INT32_TO_NPVARIANT(refCount, *result);
return true;
}
if (name == pluginMethodIdentifiers[ID_SET_STATUS])
return testSetStatus(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_RESIZE_TO])
return testResizeTo(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_NORMALIZE])
return normalizeOverride(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_INVALIDATE_RECT])
return invalidateRect(plugin, args, argCount, result);
if (name == pluginMethodIdentifiers[ID_OBJECTS_ARE_SAME])
return objectsAreSame(plugin, args, argCount, result);
return false;
}
/** implementation **/
void OAM_ObjectMain_Invoke_GetOwnerApplication(NPObj_OAM* obj,const NPVariant* args, uint32_t argCount, NPVariant* result)
{
TRACEINFO;
sBrowserFuncs->retainobject(obj->ownerApplication);
OBJECT_TO_NPVARIANT((NPObject*)(obj->ownerApplication), *result);
}
void convertJavaValueToNPVariant(JavaValue value, NPVariant* result)
{
switch (value.m_type) {
case JavaTypeVoid:
{
VOID_TO_NPVARIANT(*result);
}
break;
case JavaTypeObject:
{
// If the JavaValue is a String object, it should have type JavaTypeString.
if (value.m_objectValue)
OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(value.m_objectValue.get()), *result);
else
VOID_TO_NPVARIANT(*result);
}
break;
case JavaTypeString:
{
const char* utf8String = strdup(value.m_stringValue.utf8().data());
// The copied string is freed in NPN_ReleaseVariantValue (see npruntime.cpp)
STRINGZ_TO_NPVARIANT(utf8String, *result);
}
break;
case JavaTypeBoolean:
{
BOOLEAN_TO_NPVARIANT(value.m_booleanValue, *result);
}
break;
case JavaTypeByte:
{
INT32_TO_NPVARIANT(value.m_byteValue, *result);
}
break;
case JavaTypeChar:
{
INT32_TO_NPVARIANT(value.m_charValue, *result);
}
break;
case JavaTypeShort:
{
INT32_TO_NPVARIANT(value.m_shortValue, *result);
}
break;
case JavaTypeInt:
{
INT32_TO_NPVARIANT(value.m_intValue, *result);
}
break;
// TODO: Check if cast to double is needed.
case JavaTypeLong:
{
DOUBLE_TO_NPVARIANT(value.m_longValue, *result);
}
break;
case JavaTypeFloat:
{
DOUBLE_TO_NPVARIANT(value.m_floatValue, *result);
}
break;
case JavaTypeDouble:
{
DOUBLE_TO_NPVARIANT(value.m_doubleValue, *result);
}
break;
case JavaTypeInvalid:
default:
{
VOID_TO_NPVARIANT(*result);
}
break;
}
}
