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);
}
bool
xplayerNPObject::StringVariant (NPVariant* _result,
const char* value,
int32_t len)
{
if (!value) {
NULL_TO_NPVARIANT (*_result);
} else {
char *dup;
if (len < 0) {
len = strlen (value);
dup = (char*) NPN_MemDup (value, len + 1);
} else {
dup = (char*) NPN_MemDup (value, len);
}
if (dup) {
STRINGN_TO_NPVARIANT (dup, len, *_result);
} else {
NULL_TO_NPVARIANT (*_result);
}
}
return true;
}
static bool
plugin_object_get_property (NPObject *npobj,
NPIdentifier name,
NPVariant *result)
{
PluginObject *obj;
if (!plugin_object_has_property (npobj, name))
return FALSE;
obj = (PluginObject*) npobj;
if (name == api_version_id)
return plugin_get_api_version (obj, result);
else if (name == shell_version_id)
return plugin_get_shell_version (obj, result);
else if (name == onextension_changed_id)
{
if (obj->listener)
OBJECT_TO_NPVARIANT (obj->listener, *result);
else
NULL_TO_NPVARIANT (*result);
}
else if (name == onrestart_id)
{
if (obj->restart_listener)
OBJECT_TO_NPVARIANT (obj->restart_listener, *result);
else
NULL_TO_NPVARIANT (*result);
}
return TRUE;
}
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->IsInt32())
INT32_TO_NPVARIANT(object->NumberValue(), *result);
else 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::String::Utf8Value utf8(object);
char* utf8_chars = strdup(*utf8);
STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result);
} else if (object->IsObject()) {
WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(WebCore::V8Proxy::currentContext());
NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window);
if (npobject)
_NPN_RegisterObject(npobject, owner);
OBJECT_TO_NPVARIANT(npobject, *result);
}
}
void handleCallback(PluginObject* object, const char *url, NPReason reason, void *notifyData)
{
//assert(object);
NPVariant args[2];
NPObject *windowScriptObject;
browser->getvalue(object->npp, NPNVWindowNPObject, &windowScriptObject);
NPIdentifier callbackIdentifier = notifyData;
INT32_TO_NPVARIANT(reason, args[0]);
char *strHdr = NULL;
if (object->firstUrl && object->firstHeaders && object->lastUrl && object->lastHeaders) {
// Format expected by JavaScript validator: four fields separated by \n\n:
// First URL; first header block; last URL; last header block.
// Note that header blocks already end with \n due to how NPStream::headers works.
int len = strlen(object->firstUrl) + 2
+ strlen(object->firstHeaders) + 1
+ strlen(object->lastUrl) + 2
+ strlen(object->lastHeaders) + 1;
strHdr = (char*)malloc(len + 1);
snprintf(strHdr, len + 1, "%s\n\n%s\n%s\n\n%s\n",
object->firstUrl, object->firstHeaders, object->lastUrl, object->lastHeaders);
STRINGN_TO_NPVARIANT(strHdr, len, args[1]);
} else
NULL_TO_NPVARIANT(args[1]);
NPVariant browserResult;
browser->invoke(object->npp, windowScriptObject, callbackIdentifier, args, 2, &browserResult);
browser->releasevariantvalue(&browserResult);
free(strHdr);
}
static void
retrieve_highres_icon (WebappMonitor *monitor, const gchar *desktop_file)
{
GKeyFile *key_file;
gchar *s;
GError *error = NULL;
/* Get URL to get icon for */
key_file = g_key_file_new ();
if (!g_key_file_load_from_data (key_file, desktop_file, strlen (desktop_file), 0, &error)) {
g_warning ("Could not parse desktop file: %s", error->message);
g_error_free (error);
goto out;
}
if (get_icon_size (key_file) >= 64)
goto out;
s = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_EXEC, NULL);
if (s != NULL) {
gint n_args, i;
gchar **args, *url = NULL;
g_debug ("Parsing command line %s", s);
if (!g_shell_parse_argv (s, &n_args, &args, &error)) {
g_debug ("Failed parsing command line %s", s);
goto out;
}
for (i = 0; i < n_args && args[i] != NULL; i++) {
g_debug ("Processing argument %s", args[i]);
if (g_str_has_prefix (args[i], "--app=")) {
url = g_strdup (args[i] + 6);
g_debug ("Found URL %s", url);
break;
}
}
if (url != NULL) {
NPVariant url_varg, result;
STRINGZ_TO_NPVARIANT(url, url_varg);
NULL_TO_NPVARIANT(result);
if (!NPN_InvokeDefault (monitor->instance, monitor->icon_loader_callback, &url_varg, 1, &result))
g_debug ("Failed calling JS callback");
g_free (url);
NPN_ReleaseVariantValue (&result);
}
g_strfreev (args);
g_free (s);
}
out:
g_key_file_free (key_file);
}
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();
int length = str->Utf8Length() + 1;
char* utf8Chars = reinterpret_cast<char*>(malloc(length));
str->WriteUtf8(utf8Chars, length, 0, v8::String::HINT_MANY_WRITES_EXPECTED);
STRINGN_TO_NPVARIANT(utf8Chars, length-1, *result);
} else if (object->IsObject()) {
DOMWindow* window = V8Proxy::retrieveWindow(V8Proxy::currentContext());
NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window);
if (npobject)
_NPN_RegisterObject(npobject, owner);
OBJECT_TO_NPVARIANT(npobject, *result);
}
}
void convertToVariant(NPP npp, const Any& any, NPVariant* variant, bool result)
{
switch (any.getType())
{
case Any::Empty:
NULL_TO_NPVARIANT(*variant);
break;
case Any::Bool:
BOOLEAN_TO_NPVARIANT(any.toBoolean(), *variant);
break;
case Any::Int32:
case Any::Uint32:
INT32_TO_NPVARIANT(static_cast<int32_t>(any), *variant);
break;
case Any::Int64:
case Any::Uint64:
case Any::Float32:
case Any::Float64:
DOUBLE_TO_NPVARIANT(static_cast<double>(any), *variant);
break;
case Any::Dynamic:
if (any.isString())
{
std::string value = any.toString();
if (value.length() == 0)
{
STRINGN_TO_NPVARIANT(0, 0, *variant);
}
else if (!result)
{
STRINGN_TO_NPVARIANT(value.c_str(), static_cast<uint32_t>(value.length()), *variant);
}
else {
void* buffer = NPN_MemAlloc(value.length());
if (!buffer)
{
STRINGN_TO_NPVARIANT(0, 0, *variant);
}
else
{
memmove(buffer, value.c_str(), value.length());
STRINGN_TO_NPVARIANT(static_cast<NPUTF8*>(buffer), static_cast<uint32_t>(value.length()), *variant);
}
}
}
else
{
assert(any.isObject());
convertToVariant(npp, any.toObject(), variant, result);
}
break;
default:
VOID_TO_NPVARIANT(*variant);
break;
}
}
static mrb_value mrb_js_obj_method_missing(mrb_state *mrb, mrb_value self)
{
NPP npp = MRB_UD_NPP(mrb);
mrb_value name_sym, *args;
int len;
mrb_get_args(mrb, "o*", &name_sym, &args, &len);
if (mrb_type(name_sym) != MRB_TT_SYMBOL){
return mrb_nil_value();
}
bool success = true;
NPVariant empty;
NULL_TO_NPVARIANT(empty);
std::vector< NPVariant > var_args(len, empty);
for (int i=0; i<len; i++){
if (!convert_mrb_to_js(mrb, args[i], npp, &var_args[i])){
success = false;
break;
}
}
mrb_value ret = mrb_nil_value();
if (success){
int name_len;
const char *name_char = mrb_sym2name_len(mrb, SYM2ID(name_sym), &name_len);
std::string name(name_char, name_len);
NPIdentifier name_id = NPN_GetStringIdentifier(name.c_str());
NPObject *obj = (NPObject *)DATA_PTR(self);
if (NPN_HasMethod(npp, obj, name_id)){
NPVariant result;
NPN_Invoke(npp, obj, name_id, &var_args[0], len, &result);
convert_js_to_mrb(npp, result, mrb, &ret);
}else if (NPN_HasProperty(npp, obj, name_id)){
NPVariant result;
NPN_GetProperty(npp, obj, name_id, &result);
convert_js_to_mrb(npp, result, mrb, &ret);
}else if (name.size() > 1 && name[name.size() - 1] == '=' && var_args.size() == 1){
name.resize(name.size() - 1);
name_id = NPN_GetStringIdentifier(name.c_str());
if (NPN_HasProperty(npp, obj, name_id)){
NPN_SetProperty(npp, obj, name_id, &var_args[0]);
}
}
}
for (int i=0; i<len; i++){
NPN_ReleaseVariantValue(&var_args[i]);
}
return ret;
}
NPVariant NPRemoteObjectMap::npVariantDataToNPVariant(const NPVariantData& npVariantData, Plugin* plugin)
{
NPVariant npVariant;
switch (npVariantData.type()) {
case NPVariantData::Void:
VOID_TO_NPVARIANT(npVariant);
break;
case NPVariantData::Null:
NULL_TO_NPVARIANT(npVariant);
break;
case NPVariantData::Bool:
BOOLEAN_TO_NPVARIANT(npVariantData.boolValue(), npVariant);
break;
case NPVariantData::Int32:
INT32_TO_NPVARIANT(npVariantData.int32Value(), npVariant);
break;
case NPVariantData::Double:
DOUBLE_TO_NPVARIANT(npVariantData.doubleValue(), npVariant);
break;
case NPVariantData::String: {
NPString npString = createNPString(npVariantData.stringValue());
STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, npVariant);
break;
}
case NPVariantData::LocalNPObjectID: {
uint64_t npObjectID = npVariantData.localNPObjectIDValue();
ASSERT(npObjectID);
NPObjectMessageReceiver* npObjectMessageReceiver = m_registeredNPObjects.get(npObjectID);
if (!npObjectMessageReceiver) {
ASSERT_NOT_REACHED();
VOID_TO_NPVARIANT(npVariant);
break;
}
NPObject* npObject = npObjectMessageReceiver->npObject();
ASSERT(npObject);
retainNPObject(npObject);
OBJECT_TO_NPVARIANT(npObject, npVariant);
break;
}
case NPVariantData::RemoteNPObjectID: {
NPObject* npObjectProxy = createNPObjectProxy(npVariantData.remoteNPObjectIDValue(), plugin);
OBJECT_TO_NPVARIANT(npObjectProxy, npVariant);
break;
}
}
return npVariant;
}
bool
xplayerNPObject::ObjectVariant (NPVariant* _result,
NPObject* object)
{
if (object) {
NPN_RetainObject (object);
OBJECT_TO_NPVARIANT (object, *_result);
} else {
NULL_TO_NPVARIANT (*_result);
}
return true;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState *exec, JSValue *value, NPVariant *result)
{
JSLock lock;
JSType type = value->type();
VOID_TO_NPVARIANT(*result);
if (type == StringType) {
UString ustring = value->toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8 *)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (type == NumberType) {
DOUBLE_TO_NPVARIANT(value->toNumber(exec), *result);
} else if (type == BooleanType) {
BOOLEAN_TO_NPVARIANT(value->toBoolean(exec), *result);
} else if (type == UnspecifiedType) {
VOID_TO_NPVARIANT(*result);
} else if (type == NullType) {
NULL_TO_NPVARIANT(*result);
} else if (type == ObjectType) {
JSObject* object = static_cast<JSObject*>(value);
if (object->classInfo() == &RuntimeObjectImp::info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp *>(value);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
Interpreter* originInterpreter = exec->dynamicInterpreter();
RootObject* originRootObject = findRootObject(originInterpreter);
Interpreter* interpreter = 0;
if (originInterpreter->isGlobalObject(value)) {
interpreter = originInterpreter->interpreterForGlobalObject(value);
}
if (!interpreter)
interpreter = originInterpreter;
RootObject* rootObject = findRootObject(interpreter);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, originRootObject, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
void scrollTop(NPP instance, NPObject *scroller)
{
#if 1
scrollTo(instance, scroller, 0, false);
#else
//scroller.mojo.revealTop(0)
// TODO: test again with NULL_TO_NPVARIANT(args) and/or VOID_TO_NPVARIANT(args)
// as when OBJECT_TO_NPVARIANT(0, args) was used it crashed
NPVariant args;
NULL_TO_NPVARIANT(args);
//debug(DBG_MAIN, "scrollTop()");
NPVariant var;
scrollCommon(instance, scroller, "revealTop", args, 1, &var);
#endif
}
static bool do_exec(const NPVariant cmd, NPVariant *result)
{
bool ret = false;
const char *cmd_str;
char *out_str;
FILE *fp = NULL;
char buf[1024 * 1024];
/* set default return value */
NULL_TO_NPVARIANT(*result);
/* init algor */
if (!NPVARIANT_IS_STRING(cmd)) {
fprintf(stderr, "%s (%s %d): invalid argument type\n", prog, __FILE__, __LINE__);
goto end;
}
if (!(cmd_str = NPVARIANT_TO_STRING(cmd).UTF8Characters)) {
fprintf(stderr, "%s (%s %d): invalid argument value\n", prog, __FILE__, __LINE__);
goto end;
}
if (strlen(cmd_str) <= 0) {
fprintf(stderr, "%s (%s %d): invalid argument value\n", prog, __FILE__, __LINE__);
goto end;
}
if (!(fp = popen(cmd_str, "r"))) {
fprintf(stderr, "%s (%s %d): execute `%s' failed\n", prog, __FILE__, __LINE__, cmd_str);
goto end;
}
buf[0] = 0;
fread(buf, 1, sizeof(buf), fp);
if (!(out_str = strdup(buf))) {
fprintf(stderr, "%s (%s %d): inner error\n", prog, __FILE__, __LINE__);
goto end;
}
/* set output */
STRINGZ_TO_NPVARIANT(out_str, *result);
ret = true;
end:
if (fp) pclose(fp);
return ret;
}
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;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValue value, NPVariant* result)
{
JSLock lock(SilenceAssertionsOnly);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.utf8();
NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &CRuntimeObject::s_info) {
CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object);
CInstance* instance = runtimeObject->getInternalCInstance();
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
#ifdef ANDROID
RootObject* rootObject = findRootObject(exec->dynamicGlobalObject());
if (!rootObject)
rootObject = findRootObject(exec->lexicalGlobalObject());
#else
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
#endif
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
RuntimeNPObject::InvokeResult
RuntimeNPObject::invokeResultString(const char *psz, NPVariant &result)
{
if( !psz )
NULL_TO_NPVARIANT(result);
else
{
size_t len = strlen(psz);
NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
if( !retval )
return INVOKERESULT_OUT_OF_MEMORY;
else
{
memcpy(retval, psz, len);
STRINGN_TO_NPVARIANT(retval, len, result);
}
}
return INVOKERESULT_NO_ERROR;
}
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);
}
}
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();
}
// GetVariable sends a message to the player that looks like this:
// "Command Name\n", ie... "GetVariable var1\n". Then it waits
// for the response with the type and value.
GnashNPVariant
GnashPluginScriptObject::GetVariable(const std::string &name)
{
std::vector<std::string> iargs;
std::string str = plugin::ExternalInterface::makeString(name);
iargs.push_back(str);
str = plugin::ExternalInterface::makeInvoke("GetVariable", iargs);
log_debug("Trying to get a value for %s.", name);
size_t ret = writePlayer(str);
if (ret != str.size()) {
// If all the browser wants is the version, we don't need to
// ask the standalone player for this value. YouTube at
// least depends on this for some pages which want this to
// be greater than 8.0.0. This appears to potentially be
// Google's way of trying to revent downloaders, as this requires
// plugin support.
NPVariant value;
if (name == "$version") {
STRINGN_TO_NPVARIANT("LNX 10,0,r999", 13, value);
} else {
log_error("Couldn't send GetVariable request, network problems.");
NULL_TO_NPVARIANT(value);
}
return value;
}
// Have the read function allocate the memory
std::string data = readPlayer();
if (data.empty()) {
return GnashNPVariant();
}
GnashNPVariant parsed = plugin::ExternalInterface::parseXML(this, data);
printNPVariant(&parsed.get());
return parsed;
}
// GetVariable( Name )
//
// Sends something like this:
// <invoke name="GetVariable" returntype="xml">
// <arguments>
// <string>var1</string>
// </arguments>
// </invoke>
//
// Receives something like this:
// <number>123</number>
bool
GetVariableCallback (NPObject *npobj, NPIdentifier /* name */,
const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
log_debug(__PRETTY_FUNCTION__);
GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj;
std::string varname;
// This method only takes one argument
if (argCount == 1) {
varname = NPStringToString(NPVARIANT_TO_STRING(args[0]));
GnashNPVariant value = gpso->GetVariable(varname);
value.copy(*result);
return true;
}
NULL_TO_NPVARIANT(*result);
return false;
}
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;
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValuePtr value, NPVariant* result)
{
JSLock lock(false);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8*)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(object);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
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 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;
}
NPError
StatementObject::GetVariant(int index, NPVariant *value)
{
if (!m_hstmt) {
NPN_SetException(this, "Statement isn't initialized");
return NPERR_GENERIC_ERROR;
}
if (index < 0 || index >= m_columnCount) {
NPN_SetException(this, "Column index is out of range");
return NPERR_GENERIC_ERROR;
}
SQLLEN cbInd;
int type;
NPError rc;
GetColumnType(index, &type);
index++;
NULL_TO_NPVARIANT(*value);
switch (type) {
case VALUE_TYPE_BIT:
{
bool v_bool;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BIT, &v_bool, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
BOOLEAN_TO_NPVARIANT(v_bool, *value);
break;
}
case VALUE_TYPE_TINYINT:
case VALUE_TYPE_SMALLINT:
case VALUE_TYPE_BIGINT:
case VALUE_TYPE_INTEGER:
{
SQLINTEGER v_int32;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_LONG, &v_int32, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
INT32_TO_NPVARIANT(v_int32, *value);
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_REAL:
case VALUE_TYPE_DOUBLE:
{
double v_double;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_DOUBLE, &v_double, 0, &cbInd));
if (rc != NPERR_NO_ERROR)
return rc;
if (cbInd != SQL_NULL_DATA)
DOUBLE_TO_NPVARIANT(v_double, *value);
break;
}
/**
case VALUE_TYPE_BINARY:
case VALUE_TYPE_VARBINARY:
case VALUE_TYPE_LONGVARBINARY:
{
const char hexString[] = "0123456789ABCDEF";
SQLLEN len;
SQLWCHAR buf[32];
unsigned char *pin;
char *pout;
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, buf, 0, &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len == SQL_NO_TOTAL)
{
const SQLLEN dwUnit = 8192;
unsigned char *pBuff;
unsigned char *pData = NULL;
SQLLEN dwAvialable;
SQLLEN bufSize = dwUnit;
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
len = 0;
pBuff = pData;
while(1) {
SQLRETURN ret;
pBuff = pData + len;
ret = SQLGetData(m_hstmt, index, SQL_C_BINARY, pBuff, dwUnit, &dwAvialable);
if (ret == SQL_NO_DATA_FOUND)
break;
if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR)
return rc;
if (dwAvialable < dwUnit) {
len += dwAvialable;
break;
}
len += dwUnit;
bufSize += dwUnit;
unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize);
if (!pBuff) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
memcpy(pBuff, pData, len);
NPN_MemFree(pData);
pData = pBuff;
pBuff = pData + len;
}
data = (char*)NPN_MemAlloc(len*2+1);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
pout = data;
pin = pData;
while(len--) {
unsigned char binVal = *pin++;
*pout++ = hexString[(binVal >> 4) & 0xf];
*pout++ = hexString[binVal & 0xf];
}
*pout = 0;
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
else if (len != SQL_NULL_DATA)
{
unsigned char *pData;
SQLLEN bufSize = len + 1;
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_BINARY, pData, bufSize, &len));
if (rc != NPERR_NO_ERROR)
return rc;
data = (char*)NPN_MemAlloc(len*2+1);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
pout = data;
pin = pData;
while(len--) {
unsigned char binVal = *pin++;
*pout++ = hexString[(binVal >> 4) & 0xf];
*pout++ = hexString[binVal & 0xf];
}
*pout = 0;
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
break;
}
**/
case VALUE_TYPE_BINARY:
case VALUE_TYPE_VARBINARY:
case VALUE_TYPE_LONGVARBINARY:
case VALUE_TYPE_GUID:
case VALUE_TYPE_CHAR:
case VALUE_TYPE_VARCHAR:
case VALUE_TYPE_LONGVARCHAR:
case VALUE_TYPE_WCHAR:
case VALUE_TYPE_WVARCHAR:
case VALUE_TYPE_WLONGVARCHAR:
case VALUE_TYPE_UNKNOWN:
case VALUE_TYPE_NUMERIC:
case VALUE_TYPE_DECIMAL:
case VALUE_TYPE_DATE:
case VALUE_TYPE_TIME:
case VALUE_TYPE_TIMESTAMP:
default:
{
SQLLEN len;
SQLLEN dtype;
SQLWCHAR buf[32];
rc = CheckStmtRC(SQLColAttributesW (m_hstmt, index, SQL_COLUMN_TYPE, NULL, 0, NULL, &dtype));
if (rc != NPERR_NO_ERROR)
return rc;
if (dtype == SQL_LONGVARBINARY || dtype == SQL_VARBINARY || dtype == SQL_BINARY ||
dtype == SQL_LONGVARCHAR || dtype == SQL_VARCHAR || dtype == SQL_CHAR ||
dtype == SQL_WLONGVARCHAR || dtype == SQL_WVARCHAR || dtype == SQL_WCHAR)
{
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, 0, &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len == SQL_NO_TOTAL)
{
const SQLLEN dwUnit = 4096*sizeof(SQLWCHAR)+sizeof(SQLWCHAR);
unsigned char *pBuff = NULL;
unsigned char *pData = NULL;
SQLLEN dwAvialable;
SQLLEN bufSize = dwUnit;
char *data = NULL;
SQLRETURN ret;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
len = 0;
while(1) {
pBuff = pData + len;
ret = SQLGetData(m_hstmt, index, SQL_C_WCHAR, pBuff, dwUnit, &dwAvialable);
if (ret == SQL_NO_DATA_FOUND)
break;
if ((rc = CheckStmtRC(ret)) != NPERR_NO_ERROR)
return rc;
if (dwAvialable < dwUnit) {
len += dwAvialable;
break;
}
len += dwUnit - sizeof(SQLWCHAR);
bufSize += dwUnit - sizeof(SQLWCHAR);
unsigned char* tmp = (unsigned char*)NPN_MemAlloc(bufSize);
if (!tmp) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
memcpy(tmp, pData, len);
NPN_MemFree(pData);
pData = tmp;
}
data = strdup_WtoU8((SQLWCHAR *)pData);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
else if (len != SQL_NULL_DATA)
{
unsigned char *pData;
SQLLEN bufSize = len + sizeof(SQLWCHAR);
char *data = NULL;
pData = (unsigned char *)NPN_MemAlloc(bufSize);
if (!pData) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, pData, bufSize, &len));
if (rc != NPERR_NO_ERROR)
return rc;
data = strdup_WtoU8((SQLWCHAR *)pData);
if (!data) {
NPN_MemFree(pData);
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
NPN_MemFree(pData);
STRING_TO_NPVARIANT(data, *value);
}
} else {
rc = CheckStmtRC(SQLGetData(m_hstmt, index, SQL_C_WCHAR, buf, sizeof(buf), &len));
if (rc != NPERR_NO_ERROR)
return rc;
if (len != SQL_NULL_DATA) {
const char *data = strdup_WtoU8(buf);
if (!data) {
NPN_SetException(this, "Memory allocation error");
return NPERR_GENERIC_ERROR;
}
STRING_TO_NPVARIANT(data, *value);
}
}
break;
}
}
return NPERR_NO_ERROR;
}
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;
}
bool
xplayerNPObject::NullVariant (NPVariant* _result)
{
NULL_TO_NPVARIANT (*_result);
return true;
}
// Sends something like this:
// <invoke name="TestASMethod" returntype="xml">
// <arguments>
// <number>123</number>
// </arguments>
// </invoke>
//
// Receives:
// An XML response of one of the standard types like Number or String.
bool
remoteCallback (NPObject *npobj, NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
// log_debug(__PRETTY_FUNCTION__);
GnashPluginScriptObject *gpso = (GnashPluginScriptObject *)npobj;
std::string method;
#if 1
if (NPN_IdentifierIsString(name)) {
log_debug("Invoking remote Method \"%s\"...",
NPN_UTF8FromIdentifier(name));
method = NPN_UTF8FromIdentifier(name);
} else {
log_debug("Invoking remote Method: \"%d\"...",
NPN_IntFromIdentifier(name));
}
#endif
// Build the argument array
std::vector<std::string> fnargs;
for (uint32_t i=0; i<argCount; ++i) {
std::string xml = plugin::ExternalInterface::convertNPVariant(&args[i]);
fnargs.push_back(xml);
}
std::string str = plugin::ExternalInterface::makeInvoke(method, fnargs);
// Write the message to the Control FD.
size_t ret = gpso->writePlayer(str);
// Unless we wrote the same amount of data as the message contained,
// something went wrong.
if (ret != str.size()) {
log_error("Couldn't invoke %s, network problems.", method);
return false;
}
// Have the read function allocate the memory
std::string data = gpso->readPlayer();
if (data.empty()) {
log_error("Couldn't read a response for invoke, network problems.");
NULL_TO_NPVARIANT(*result);
return false;
}
std::string answer;
GnashNPVariant parsed = plugin::ExternalInterface::parseXML(data);
if (!NPVARIANT_IS_NULL(parsed.get())) {
answer = NPStringToString(NPVARIANT_TO_STRING(parsed.get()));
}
if (answer == "Error") {
NULL_TO_NPVARIANT(*result);
} else if (answer == "SecurityError") {
NULL_TO_NPVARIANT(*result);
} else {
parsed.copy(*result);
}
// printNPVariant(&parsed.get());
// Returning false makes Javascript stop executing the script.
return true;
}
