C++ NPNetscapeFuncs::getvalue方法代码示例

static void
cloud_spy_log (const gchar * log_domain, GLogLevelFlags log_level, const gchar * message, gpointer user_data)
{
  NPNetscapeFuncs * browser = cloud_spy_nsfuncs;
  NPP instance = static_cast<NPP> (user_data);
  NPObject * window = NULL, * console = NULL;
  NPVariant variant, result;
  NPError error;

  (void) log_domain;
  (void) log_level;

  error = browser->getvalue (instance, NPNVWindowNPObject, &window);
  if (error != NPERR_NO_ERROR)
    goto beach;

  VOID_TO_NPVARIANT (variant);
  if (!browser->getproperty (instance, window, browser->getstringidentifier ("console"), &variant))
    goto beach;
  console = NPVARIANT_TO_OBJECT (variant);

  STRINGZ_TO_NPVARIANT (message, variant);
  VOID_TO_NPVARIANT (result);
  if (!browser->invoke (instance, console, browser->getstringidentifier ("log"), &variant, 1, &result))
    goto beach;
  browser->releasevariantvalue (&result);

beach:
  if (console != NULL)
    browser->releaseobject (console);
  if (window != NULL)
    browser->releaseobject (window);
}

NPError
NPP_New(NPMIMEType pluginType, NPP npp, uint16_t mode, int16_t argc, char *argn[],
        char *argv[], NPSavedData *saved)
{
    trace_info_f("%s\n", __func__);

    NPObject *np_plugin_element_obj;

    int err = npn.getvalue(npp, NPNVPluginElementNPObject, &np_plugin_element_obj);
    if (err != NPERR_NO_ERROR) {
        trace_warning("%s, NPN_GetValue returned %d\n", __func__, err);
        goto done;
    }

    NPVariant result;
    NPString script = {
        .UTF8Characters = resource_text_libpdf_frontend_js,
        .UTF8Length = strlen(resource_text_libpdf_frontend_js),
    };

    if (!npn.evaluate(npp, np_plugin_element_obj, &script, &result)) {
        trace_warning("%s, NPN_Evaluate failed\n", __func__);
    }

done:
    return NPERR_NO_ERROR;
}

NPError
NPN_GetValue(NPP instance, NPNVariable variable, void *value)
{
    NPError rv = NPERR_GENERIC_ERROR;
    if (NPNFuncs.getvalue) {
        rv = NPNFuncs.getvalue(instance, variable, value);
    }
    return rv;
}

static
NPError MyNPN_GetValue(NPP instance, NPNVariable variable,
               void *value)
{
	NPError ret;
	DEB(ef, "-> NPN_GetValue( %x, %d, 0x%x)\n", instance, variable, value);		
	ret = gNetscapeFuncs.getvalue( instance, variable, value );
	DEB(ef, "<- NPN_GetValue = %d\n", ret);
	return ret;
}

NPError NPN_GetValue(NPP instance, NPNVariable variable, void *value)
{
    NPError rv = NPERR_NO_ERROR;

    if(logger)
        logger->logCall(action_npn_get_value, (DWORD)instance, (DWORD)variable, (DWORD)value);

    rv = NPNFuncs.getvalue(instance, variable, value);

    if(logger)
        logger->logReturn(action_npn_get_value);

    return rv;
}

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

NPError NPN_GetValue(NPP instance, NPNVariable variable, void *value)
{
  return NPNFuncs.getvalue(instance, variable, value);
}

NPError
NPP_New(NPMIMEType    mimetype,
	NPP           instance,
	uint16_t      mode,
	int16_t       argc,
	char        **argn,
	char        **argv,
	NPSavedData  *saved)
{
  /* instance initialization function */
  NPError ret = NPERR_NO_ERROR;
  PluginData *data;
  GError *error = NULL;

  /* first, check if the location is what we expect */
  NPObject *window;
  NPVariant document;
  NPVariant location;
  NPVariant href;

  g_debug ("plugin created");

  funcs.getvalue (instance, NPNVWindowNPObject, &window);

  funcs.getproperty (instance, window,
		     funcs.getstringidentifier ("document"),
		     &document);
  g_assert (NPVARIANT_IS_OBJECT (document));

  funcs.getproperty (instance, NPVARIANT_TO_OBJECT (document),
		     funcs.getstringidentifier ("location"),
		     &location);
  g_assert (NPVARIANT_IS_OBJECT (location));

  funcs.getproperty (instance, NPVARIANT_TO_OBJECT (location),
		     funcs.getstringidentifier ("href"),
		     &href);
  g_assert (NPVARIANT_IS_STRING (href));

  if (strncmp (NPVARIANT_TO_STRING (href).UTF8Characters, ORIGIN, sizeof (ORIGIN)-1))
    {
      g_debug ("origin does not match, is %s", NPVARIANT_TO_STRING (href).UTF8Characters);

      if (!ALLOW_FOREIGN_ORIGIN)
	{
	  ret = NPERR_GENERIC_ERROR;
	  goto out;
	}
    }

  data = g_slice_new (PluginData);
  instance->pdata = data;

  data->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
					       G_DBUS_PROXY_FLAGS_NONE,
					       NULL, /* interface info */
					       "org.gnome.Shell",
					       "/org/gnome/Shell",
					       "org.gnome.Shell",
					       NULL, /* GCancellable */
					       &error);
  if (!data->proxy) {
    /* ignore error if the shell is not running, otherwise warn */
    if (error->domain != G_DBUS_ERROR ||
	error->code != G_DBUS_ERROR_NAME_HAS_NO_OWNER)
      {
	g_warning ("Failed to set up Shell proxy: %s", error->message);
	g_error_clear (&error);
      }
    ret = NPERR_GENERIC_ERROR;
  }

  g_debug ("plugin created successfully");

 out:
  funcs.releaseobject (window);
  funcs.releasevariantvalue (&document);
  funcs.releasevariantvalue (&location);
  funcs.releasevariantvalue (&href);

  return ret;
}

static gboolean
check_origin_and_protocol (NPP instance)
{
  gboolean ret = FALSE;
  NPError error;
  NPObject *window = NULL;
  NPVariant document = { NPVariantType_Void };
  NPVariant location = { NPVariantType_Void };
  gchar *hostname = NULL;
  gchar *protocol = NULL;

  error = funcs.getvalue (instance, NPNVWindowNPObject, &window);
  if (error != NPERR_NO_ERROR)
    goto out;

  if (!funcs.getproperty (instance, window,
                          funcs.getstringidentifier ("document"),
                          &document))
    goto out;

  if (!NPVARIANT_IS_OBJECT (document))
    goto out;

  if (!funcs.getproperty (instance, NPVARIANT_TO_OBJECT (document),
                          funcs.getstringidentifier ("location"),
                          &location))
    goto out;

  if (!NPVARIANT_IS_OBJECT (location))
    goto out;

  hostname = get_string_property (instance,
                                  NPVARIANT_TO_OBJECT (location),
                                  "hostname");

  if (g_strcmp0 (hostname, ORIGIN))
    {
      g_debug ("origin does not match, is %s",
               hostname);

      goto out;
    }

  protocol = get_string_property (instance,
                                  NPVARIANT_TO_OBJECT (location),
                                  "protocol");

  if (g_strcmp0 (protocol, "https:") != 0)
    {
      g_debug ("protocol does not match, is %s",
               protocol);

      goto out;
    }

  ret = TRUE;

 out:
  g_free (protocol);
  g_free (hostname);

  funcs.releasevariantvalue (&location);
  funcs.releasevariantvalue (&document);

  if (window != NULL)
    funcs.releaseobject (window);
  return ret;
}