Changeset 429 for trunk/icedtea-web/plugin

trunk/icedtea-web/plugin/icedteanp/IcedTeaJavaRequestProcessor.cc

-              r418
+              r429
+                                }
                                 printf("Error on Java side: %s\n", result->error_msg->c_str());
+                                PLUGIN_ERROR("Error on Java side: %s\n", result->error_msg->c_str());
                                 result->error_occurred = true;
 …
+                        {
                             if (!message_parts->at(5)->find("literalreturn"))
+                            if (!message_parts->at(5)->find("literalreturn") || !message_parts->at(5)->find("jsobject"))
+                {
                                 // literal returns don't have a corresponding jni id
 …
                                   std::vector<std::string> args)
+{
+        JavaRequestProcessor* java_request;
+        std::string message = std::string();
+    std::string* signature;
+    signature = new std::string();
+    *signature += "(";
+        std::string message, signature = "(";
     // FIXME: Need to determine how to extract array types and complex java objects
     for (int i=0; i < args.size(); i++)
+    {
         *signature += args[i];
+        signature += args[i];
+    }
     *signature += ")";
+    signature += ")";
         this->instance = 0; // context is always 0 (needed for java-side backwards compat.)
 …
         IcedTeaPluginUtilities::constructMessagePrefix(0, reference, &message);
+        message += " GetMethodID ";
+        message += classID;
+        message += " ";
+        message += browser_functions.utf8fromidentifier(methodName);
+        message += " ";
+        message += *signature;
+        message += " GetMethodID " + classID + " ";
+        message += IcedTeaPluginUtilities::NPIdentifierAsString(methodName) + " ";
+        message += signature;
         postAndWaitForResponse(message);
         IcedTeaPluginUtilities::releaseReference();
-        delete signature;
         return result;
 …
                                   std::vector<std::string> args)
+{
+    JavaRequestProcessor* java_request;
+    std::string message = std::string();
+    std::string* signature;
+    signature = new std::string();
+    *signature += "(";
+    std::string message, signature = "(";
     // FIXME: Need to determine how to extract array types and complex java objects
     for (int i=0; i < args.size(); i++)
+    {
         *signature += args[i];
+        signature += args[i];
+    }
     *signature += ")";
+    signature += ")";
     this->instance = 0; // context is always 0 (needed for java-side backwards compat.)
 …
     IcedTeaPluginUtilities::constructMessagePrefix(0, reference, &message);
+    message += " GetStaticMethodID ";
+    message += classID;
+    message += " ";
+    message += browser_functions.utf8fromidentifier(methodName);
+    message += " ";
+    message += *signature;
+    postAndWaitForResponse(message);
+    IcedTeaPluginUtilities::releaseReference();
+    delete signature;
+    message += " GetStaticMethodID " + classID + " ";
+    message += IcedTeaPluginUtilities::NPIdentifierAsString(methodName) + " ";
+    message += signature;
+    postAndWaitForResponse(message);
+    IcedTeaPluginUtilities::releaseReference();
     return result;
 …
                 if (java_result->error_occurred) {
                     printf("Unable to create array\n");
+                    PLUGIN_ERROR("Unable to create array\n");
                     id->append("-1");
                     return;
 …
                     if (value_id == "-1") {
                         printf("Unable to populate array\n");
+                        PLUGIN_ERROR("Unable to populate array\n");
                         id->clear();
                         id->append("-1");
 …
                 if (java_result->error_occurred)
+                {
                     printf("Unable to get JSObject class id\n");
+                    PLUGIN_ERROR("Unable to get JSObject class id\n");
                     id->clear();
                     id->append("-1");
 …
                 if (java_result->error_occurred)
+                {
                     printf("Unable to get JSObject constructor id\n");
+                    PLUGIN_ERROR("Unable to get JSObject constructor id\n");
                     id->clear();
                     id->append("-1");
 …
                 if (java_result->error_occurred)
+                {
                     printf("Unable to create JSObject\n");
+                    PLUGIN_ERROR("Unable to create JSObject\n");
                     id->clear();
                     id->append("-1");
 …
                 // the result we want is in result_string (assuming there was no error)
                 if (java_result->error_occurred) {
                         printf("Unable to find classid for %s\n", className.c_str());
+                        PLUGIN_ERROR("Unable to find classid for %s\n", className.c_str());
                         id->append("-1");
                         return;
 …
                 // the result we want is in result_string (assuming there was no error)
                 if (java_result->error_occurred) {
                         printf("Unable to find string constructor for %s\n", className.c_str());
+                        PLUGIN_ERROR("Unable to find string constructor for %s\n", className.c_str());
                         id->append("-1");
             return;
 …
                 if (java_result->error_occurred) {
                         printf("Unable to create requested object\n");
+                        PLUGIN_ERROR("Unable to create requested object\n");
                         id->append("-1");
             return;
 …
         if (java_result->error_occurred) {
             printf("Unable to create requested object\n");
+            PLUGIN_ERROR("Unable to create requested object\n");
             id->append("-1");
             return;
 …
         JavaResultData* java_result;
         JavaRequestProcessor* java_request = new JavaRequestProcessor();
-        std::string message = std::string();
         std::string plugin_instance_id_str = std::string();
         IcedTeaPluginUtilities::itoa(plugin_instance_id, &plugin_instance_id_str);
 …
         this->reference = IcedTeaPluginUtilities::getReference();
+        std::string message;
         IcedTeaPluginUtilities::constructMessagePrefix(0, reference, &message);
+        message.append(" HasPackage ");
+    message.append(plugin_instance_id_str);
+    message.append(" ");
+        message.append(java_result->return_string->c_str());
+        message += " HasPackage " + plugin_instance_id_str + " " + *java_result->return_string;
         postAndWaitForResponse(message);

trunk/icedtea-web/plugin/icedteanp/IcedTeaJavaRequestProcessor.h

r348	r429
42	42	#include <errno.h>
43	43	#include <stdlib.h>
	44	#include <unistd.h>
44	45	#include <vector>
45	46

trunk/icedtea-web/plugin/icedteanp/IcedTeaNPPlugin.cc

-              r419
+              r429
 #include <sys/socket.h>
 #include <fcntl.h>
+#include <sstream>
 #include "OS_OS2.h"
 #endif
 …
 // System includes.
 #include <dlfcn.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
 #include <errno.h>
 #include <libgen.h>
 …
 #include <stdlib.h>
 #include <string.h>
+#include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <new>
+//IcedTea-plugin includes
+#include "IcedTeaPluginUtils.h"
+#include "IcedTeaParseProperties.h"
 // Liveconnect extension
 #include "IcedTeaScriptablePluginObject.h"
 …
 #define DT_SOCKET_DLL "dt_socket"
 #endif
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-// Documentbase retrieval includes.
-#include <nsIPluginInstance.h>
-#include <nsIPluginInstancePeer.h>
-#include <nsIPluginTagInfo2.h>
-// API's into Mozilla
-#include <nsCOMPtr.h>
-#include <nsICookieService.h>
-#include <nsIDNSRecord.h>
-#include <nsIDNSService.h>
-#include <nsINetUtil.h>
-#include <nsIProxyInfo.h>
-#include <nsIProtocolProxyService.h>
-#include <nsIScriptSecurityManager.h>
-#include <nsIIOService.h>
-#include <nsIURI.h>
-#include <nsNetCID.h>
-#include <nsStringAPI.h>
-#include <nsServiceManagerUtils.h>
-#endif
-// Error reporting macros.
-#define PLUGIN_ERROR(message)                                       \
-  g_printerr ("%s:%d: thread %p: Error: %s\n", __FILE__, __LINE__,  \
-              g_thread_self (), message)
-#define PLUGIN_ERROR_TWO(first, second)                                 \
-  g_printerr ("%s:%d: thread %p: Error: %s: %s\n", __FILE__, __LINE__,  \
-              g_thread_self (), first, second)
-#define PLUGIN_ERROR_THREE(first, second, third)                        \
-  g_printerr ("%s:%d: thread %p: Error: %s: %s: %s\n", __FILE__,        \
-              __LINE__, g_thread_self (), first, second, third)
 // Plugin information passed to about:plugins.
 …
   "  For more detail rerun \"firefox -g\" in a terminal window."
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-// Documentbase retrieval required definition.
-static NS_DEFINE_IID (kIPluginTagInfo2IID, NS_IPLUGINTAGINFO2_IID);
-#endif
 // Data directory for plugin.
+static gchar* data_directory = NULL;
+// Fully-qualified appletviewer executable.
+static gchar* appletviewer_executable = NULL;
+static std::string data_directory;
+static DIR *data_directory_descriptor;
+// Fully-qualified appletviewer default  executable and rt.jar
+static const char* appletviewer_default_executable = ICEDTEA_WEB_JRE "/bin/java";
+static const char* appletviewer_default_rtjar = ICEDTEA_WEB_JRE "/lib/rt.jar";
 // Applet viewer input channel (needs to be static because it is used in plugin_in_pipe_callback)
 …
 #endif
+// Applet viewer debug pipe name.
+gchar* debug_pipe_name = NULL;
 // Applet viewer output watch source.
 gint out_watch_source;
 …
 pthread_mutex_t pluginAsyncCallMutex;
+/*to sync pipe to apletviewer console*/
+pthread_mutex_t debug_pipe_lock = PTHREAD_MUTEX_INITIALIZER;
 // Applet viewer output channel.
 GIOChannel* out_to_appletviewer;
+// Applet viewer debug channel.
+GIOChannel* debug_to_appletviewer = NULL;
 // Tracks jvm status
 …
 JavaMessageSender* java_req_proc;
+#if MOZILLA_VERSION_COLLAPSED < 1090100
+// Documentbase retrieval type-punning union.
+typedef union
+{
+  void** void_field;
+  nsIPluginTagInfo2** info_field;
+} info_union;
+// Queue processing threads
+static pthread_t plugin_request_processor_thread1;
+static pthread_t plugin_request_processor_thread2;
+static pthread_t plugin_request_processor_thread3;
+#ifdef __OS2__
+struct QueueProcessorData
+{
+    PluginRequestProcessor *processor;
+    bool stopRequested;
+};
+static QueueProcessorData queue_processor_data1 = { NULL, false };
+static QueueProcessorData queue_processor_data2 = { NULL, false };
+static QueueProcessorData queue_processor_data3 = { NULL, false };
 #endif
 // Static instance helper functions.
-// Have the browser allocate a new ITNPPluginData structure.
-static void plugin_data_new (ITNPPluginData** data);
 // Retrieve the current document's documentbase.
+static gchar* plugin_get_documentbase (NPP instance);
+// Notify the user that the appletviewer is not installed correctly.
+static void plugin_display_failure_dialog ();
+static std::string plugin_get_documentbase (NPP instance);
 // Callback used to monitor input pipe status.
 static gboolean plugin_in_pipe_callback (GIOChannel* source,
 …
                                           GIOCondition condition,
                                           gpointer plugin_data);
+static NPError plugin_start_appletviewer (ITNPPluginData* data);
+static gchar* plugin_create_applet_tag (int16_t argc, char* argn[],
+                                        char* argv[]);
+std::string plugin_parameters_string (int argc, char* argn[], char* argv[]);
 static void plugin_stop_appletviewer ();
-// Uninitialize ITNPPluginData structure
-static void plugin_data_destroy (NPP instance);
 NPError get_cookie_info(const char* siteAddr, char** cookieString, uint32_t* len);
 NPError get_proxy_info(const char* siteAddr, char** proxy, uint32_t* len);
 void consume_message(gchar* message);
-void start_jvm_if_needed();
 static void appletviewer_monitor(GPid pid, gint status, gpointer data);
 void plugin_send_initialization_message(char* instance, gulong handle,
                                                int width, int height,
                                                char* url);
+/* Returns JVM options set in itw-settings */
+std::vector<std::string*>* get_jvm_args();
 // Global instance counter.
 …
 static guint appletviewer_watch_id = -1;
+bool debug_initiated = false;
 int plugin_debug = getenv ("ICEDTEAPLUGIN_DEBUG") != NULL;
+bool plugin_debug_headers = false;
+bool plugin_debug_to_file = false ;
+bool plugin_debug_to_streams = true ;
+bool plugin_debug_to_system = false;
+bool plugin_debug_to_console = true;
+FILE *  plugin_file_log;
+std::string plugin_file_log_name;
 int plugin_debug_suspend = (getenv("ICEDTEAPLUGIN_DEBUG") != NULL) &&
         (strcmp(getenv("ICEDTEAPLUGIN_DEBUG"), "suspend") == 0);
-pthread_cond_t cond_message_available = PTHREAD_COND_INITIALIZER;
 …
 #endif
+static std::string get_plugin_executable(){
+      std::string custom_jre;
+      bool custom_jre_defined = find_custom_jre(custom_jre);
+      if (custom_jre_defined) {
+            if (IcedTeaPluginUtilities::file_exists(custom_jre+"/bin/java")){
+                  return custom_jre+"/bin/java";
+            } else {
+                 PLUGIN_ERROR("Your custom jre (/bin/java check) %s is not valid. Please fix %s in your %s. In attempt to run using default one. \n", custom_jre.c_str(), custom_jre_key.c_str(), default_file_ITW_deploy_props_name.c_str());
+            }
+      }
+      return appletviewer_default_executable;
+}
+static std::string get_plugin_rt_jar(){
+      std::string custom_jre;
+      bool custom_jre_defined = find_custom_jre(custom_jre);
+      if (custom_jre_defined) {
+            if (IcedTeaPluginUtilities::file_exists(custom_jre+"/lib/rt.jar")){
+                  return custom_jre+"/lib/rt.jar";
+            } else {
+                  PLUGIN_ERROR("Your custom jre (/lib/rt.jar check) %s is not valid. Please fix %s in your %s. In attempt to run using default one. \n", custom_jre.c_str(), custom_jre_key.c_str(), default_file_ITW_deploy_props_name.c_str());
+            }
+      }
+      return appletviewer_default_rtjar;
+}
+static void cleanUpDir(){
+  //free data_directory descriptor
+  if (data_directory_descriptor != NULL) {
+    closedir(data_directory_descriptor);
+  }
+  //clean up pipes directory
+  PLUGIN_DEBUG ("Removing runtime directory %s \n", data_directory.c_str());
+  int removed = rmdir(data_directory.c_str());
+  if (removed != 0) {
+    PLUGIN_ERROR ("Failed to remove runtime directory %s, because of  %s \n", data_directory.c_str(), strerror(errno));
+  } else {
+    PLUGIN_DEBUG ("Removed runtime directory %s \n", data_directory.c_str());
+  }
+  data_directory_descriptor = NULL;
+}
 /*
  * Find first member in GHashTable* depending on version of glib
 …
 // Creates a new icedtea np plugin instance.  This function creates a
 // ITNPPluginData* and stores it in instance->pdata.  The following
 // ITNPPluginData fiels are initialized: instance_id, in_pipe_name,
+// ITNPPluginData fields are initialized: instance_id, in_pipe_name,
 // in_from_appletviewer, in_watch_source, out_pipe_name,
 // out_to_appletviewer, out_watch_source, appletviewer_mutex, owner,
 …
   if (!browser_functions.hasproperty(instance, window_ptr, identifier))
+  {
         printf("%s not found!\n", "document");
+        PLUGIN_ERROR("%s not found!\n", "document");
+  }
   browser_functions.getproperty(instance, window_ptr, identifier, &member_ptr);
 …
   PLUGIN_DEBUG("Got variant %p\n", &member_ptr);
-  NPError np_error = NPERR_NO_ERROR;
-  ITNPPluginData* data = NULL;
-  gchar* documentbase = NULL;
-  gchar* read_message = NULL;
-  gchar* applet_tag = NULL;
-  gchar* cookie_info = NULL;
-  NPObject* npPluginObj = NULL;
   if (!instance)
+    {
+      PLUGIN_ERROR ("Browser-provided instance pointer is NULL.");
+      np_error = NPERR_INVALID_INSTANCE_ERROR;
+      goto cleanup_done;
+    }
+  {
+      PLUGIN_ERROR ("Browser-provided instance pointer is NULL.\n");
+      return NPERR_INVALID_INSTANCE_ERROR;
+  }
   // data
   plugin_data_new (&data);
+  ITNPPluginData* data = plugin_data_new ();
   if (data == NULL)
+    {
+      PLUGIN_ERROR ("Failed to allocate plugin data.");
+      np_error = NPERR_OUT_OF_MEMORY_ERROR;
+      goto cleanup_done;
+  {
+      PLUGIN_ERROR ("Failed to allocate plugin data.\n");
+      return NPERR_OUT_OF_MEMORY_ERROR;
+    }
   // start the jvm if needed
+  start_jvm_if_needed();
+   NPError startup_error = start_jvm_if_needed();
+   if (startup_error != NPERR_NO_ERROR) {
+           PLUGIN_ERROR ("Failed to start JVM\n");
+           return startup_error;
+   }
   // Initialize data->instance_id.
 …
   g_mutex_lock (data->appletviewer_mutex);
+  std::string documentbase = plugin_get_documentbase (instance);
   // Documentbase retrieval.
+  documentbase = plugin_get_documentbase (instance);
+  if (documentbase && argc != 0)
+    {
+      // Send applet tag message to appletviewer.
+      applet_tag = plugin_create_applet_tag (argc, argn, argv);
+      data->applet_tag = (gchar*) malloc(strlen(applet_tag)*sizeof(gchar) + strlen(documentbase)*sizeof(gchar) + 32);
+      g_sprintf(data->applet_tag, "tag %s %s", documentbase, applet_tag);
+  if (argc != 0)
+  {
+      // Send parameters to appletviewer.
+      std::string params_string = plugin_parameters_string(argc, argn, argv);
+      data->parameters_string =  g_strdup_printf("tag %s %s", documentbase.c_str(), params_string.c_str());
       data->is_applet_instance = true;
+    }
+  if (argc == 0)
+    {
+  }
+  else
+  {
       data->is_applet_instance = false;
+    }
+  }
   g_mutex_unlock (data->appletviewer_mutex);
 …
   instance->pdata = data;
-  goto cleanup_done;
- cleanup_appletviewer_mutex:
-  g_mutex_free (data->appletviewer_mutex);
-  data->appletviewer_mutex = NULL;
-  // cleanup_instance_string:
-  g_free (data->instance_id);
-  data->instance_id = NULL;
-  // cleanup applet tag:
-  g_free (data->applet_tag);
-  data->applet_tag = NULL;
-  // cleanup_data:
-  // Eliminate back-pointer to plugin instance.
-  data->owner = NULL;
-  (*browser_functions.memfree) (data);
-  data = NULL;
-  // Initialization failed so return a NULL pointer for the browser
-  // data.
-  instance->pdata = NULL;
- cleanup_done:
-  g_free (applet_tag);
-  applet_tag = NULL;
-  g_free (read_message);
-  read_message = NULL;
-  g_free (documentbase);
-  documentbase = NULL;
   // store an identifier for this plugin
 …
   PLUGIN_DEBUG ("ITNP_New return\n");
   return np_error;
+  return NPERR_NO_ERROR;
+}
 // Starts the JVM if it is not already running
 void start_jvm_if_needed()
+NPError start_jvm_if_needed()
+{
 …
+  {
       PLUGIN_DEBUG("JVM is up. Returning.\n");
       return;
+      return  NPERR_NO_ERROR;
+  }
 …
   // in_pipe_name
   in_pipe_name = g_strdup_printf ("%s/%d-icedteanp-appletviewer-to-plugin",
                                          data_directory, getpid());
+                                         data_directory.c_str(), getpid());
   if (!in_pipe_name)
+    {
       PLUGIN_ERROR ("Failed to create input pipe name.");
+      PLUGIN_ERROR ("Failed to create input pipe name.\n");
       np_error = NPERR_OUT_OF_MEMORY_ERROR;
       // If in_pipe_name is NULL then the g_free at
 …
   if (mkfifo (in_pipe_name, 0600) == -1 && errno != EEXIST)
+    {
       PLUGIN_ERROR_TWO ("Failed to create input pipe", strerror (errno));
+      PLUGIN_ERROR ("Failed to create input pipe\n", strerror (errno));
       np_error = NPERR_GENERIC_ERROR;
       goto cleanup_in_pipe_name;
 …
   // out_pipe_name
   out_pipe_name = g_strdup_printf ("%s/%d-icedteanp-plugin-to-appletviewer",
                                          data_directory, getpid());
+                                         data_directory.c_str(), getpid());
   if (!out_pipe_name)
+    {
       PLUGIN_ERROR ("Failed to create output pipe name.");
+      PLUGIN_ERROR ("Failed to create output pipe name.\n");
       np_error = NPERR_OUT_OF_MEMORY_ERROR;
       goto cleanup_out_pipe_name;
 …
   if (mkfifo (out_pipe_name, 0600) == -1 && errno != EEXIST)
+    {
       PLUGIN_ERROR_TWO ("Failed to create output pipe", strerror (errno));
+      PLUGIN_ERROR ("Failed to create output pipe\n", strerror (errno));
       np_error = NPERR_GENERIC_ERROR;
       goto cleanup_out_pipe_name;
 …
   PLUGIN_DEBUG ("ITNP_New: created output fifo: %s\n", out_pipe_name);
 #endif
+  // Create plugin-debug-to-appletviewer pipe which we refer to as the
+  // debug pipe.
+  initialize_debug();//should be already initialized, but...
+  if (plugin_debug_to_console){
+    // debug_pipe_name
+    debug_pipe_name = g_strdup_printf ("%s/%d-icedteanp-plugin-debug-to-appletviewer",
+                                         data_directory.c_str(), getpid());
+    if (!debug_pipe_name)
+      {
+        PLUGIN_ERROR ("Failed to create debug pipe name.\n");
+        np_error = NPERR_OUT_OF_MEMORY_ERROR;
+        goto cleanup_debug_pipe_name;
+      }
+    // clean up any older pip
+    unlink (debug_pipe_name);
+    PLUGIN_DEBUG ("ITNP_New: creating debug fifo: %s\n", debug_pipe_name);
+    if (mkfifo (debug_pipe_name, 0600) == -1 && errno != EEXIST)
+      {
+        PLUGIN_ERROR ("Failed to create debug pipe\n", strerror (errno));
+        np_error = NPERR_GENERIC_ERROR;
+        goto cleanup_debug_pipe_name;
+      }
+    PLUGIN_DEBUG ("ITNP_New: created debug fifo: %s\n", debug_pipe_name);
+  }
   // Start a separate appletviewer process for each applet, even if
 …
       if (channel_error)
+        {
           PLUGIN_ERROR_TWO ("Failed to create output channel",
+          PLUGIN_ERROR ("Failed to create output channel, '%s'\n",
                             channel_error->message);
           g_error_free (channel_error);
 …
+        }
       else
         PLUGIN_ERROR ("Failed to create output channel");
+        PLUGIN_ERROR ("Failed to create output channel\n");
       np_error = NPERR_GENERIC_ERROR;
 …
       if (channel_error)
+        {
           PLUGIN_ERROR_TWO ("Failed to create input channel",
+          PLUGIN_ERROR ("Failed to create input channel, '%s'\n",
                             channel_error->message);
           g_error_free (channel_error);
 …
+        }
       else
         PLUGIN_ERROR ("Failed to create input channel");
+        PLUGIN_ERROR ("Failed to create input channel\n");
       np_error = NPERR_GENERIC_ERROR;
 …
                     (GIOCondition) (G_IO_IN | G_IO_ERR | G_IO_HUP),
                     plugin_in_pipe_callback, (gpointer) in_from_appletviewer);
+  // Create plugin-to-appletviewer console debug channel.  The default encoding for
+  // the file is UTF-8.
+  // debug_to_appletviewer
+  if (plugin_debug_to_console){
+    debug_to_appletviewer = g_io_channel_new_file (debug_pipe_name,
+                                                 "w", &channel_error);
+    if (!debug_to_appletviewer)
+      {
+        if (channel_error)
+          {
+            PLUGIN_ERROR ("Failed to debug output channel, '%s'\n",
+                              channel_error->message);
+            g_error_free (channel_error);
+            channel_error = NULL;
+          }
+        else
+          PLUGIN_ERROR ("Failed to create debug channel\n");
+        np_error = NPERR_GENERIC_ERROR;
+        goto cleanup_debug_to_appletviewer;
+     }
+  }
   jvm_up = TRUE;
+  if (plugin_debug_to_console){
+    //jvm is up, we can start console producer thread
+    pthread_t debug_to_console_consumer;
+    pthread_create(&debug_to_console_consumer,NULL,&flush_pre_init_messages,NULL);
+  }
   goto done;
+  // Free allocated data
+  // Free allocated data in case of error
+ cleanup_debug_to_appletviewer:
+  if (plugin_debug_to_console){
+    if (debug_to_appletviewer)
+      g_io_channel_unref (debug_to_appletviewer);
+    debug_to_appletviewer = NULL;
+  }
  cleanup_in_watch_source:
 …
     g_io_channel_unref (out_to_appletviewer);
   out_to_appletviewer = NULL;
+  if (plugin_debug_to_console){
+    // cleanup_debug_pipe:
+    // Delete output pipe.
+    PLUGIN_DEBUG ("ITNP_New: deleting debug fifo: %s\n", debug_pipe_name);
+    unlink (debug_pipe_name);
+    PLUGIN_DEBUG ("ITNP_New: deleted debug fifo: %s\n", debug_pipe_name);
+  }
+ cleanup_debug_pipe_name:
+  if (plugin_debug_to_console){
+    g_free (debug_pipe_name);
+    debug_pipe_name = NULL;
+  }
   // cleanup_out_pipe:
 …
 #endif
+  cleanUpDir();
  done:
+  IcedTeaPluginUtilities::printDebugStatus();
   // Now other threads may re-enter.. unlock the mutex
   g_mutex_unlock(vm_start_mutex);
+  return np_error;
+}
 …
       break;
     default:
       PLUGIN_ERROR ("Unknown plugin value requested.");
+      PLUGIN_ERROR ("Unknown plugin value requested.\n");
       np_error = NPERR_GENERIC_ERROR;
       break;
 …
   if (instance == NULL)
+    {
       PLUGIN_ERROR ("Invalid instance.");
+      PLUGIN_ERROR ("Invalid instance.\n");
       return NPERR_INVALID_INSTANCE_ERROR;
 …
       plugin_send_initialization_message(
                   data->instance_id, (gulong) data->window_handle,
                   data->window_width, data->window_height, data->applet_tag);
+                  data->window_width, data->window_height, data->parameters_string);
       g_mutex_unlock (data->appletviewer_mutex);
 …
     return NPERR_GENERIC_ERROR;
+  }
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-  nsresult rv;
-  nsCOMPtr<nsIScriptSecurityManager> sec_man =
-    do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
-  if (!sec_man) {
-    return NPERR_GENERIC_ERROR;
+  }
-  nsCOMPtr<nsIIOService> io_svc = do_GetService("@mozilla.org/network/io-service;1", &rv);
-  if (NS_FAILED(rv) || !io_svc) {
-    return NPERR_GENERIC_ERROR;
+  }
-  nsCOMPtr<nsIURI> uri;
-  io_svc->NewURI(nsCString(siteAddr), NULL, NULL, getter_AddRefs(uri));
-  nsCOMPtr<nsICookieService> cookie_svc = do_GetService("@mozilla.org/cookieService;1", &rv);
-  if (NS_FAILED(rv) || !cookie_svc) {
-    return NPERR_GENERIC_ERROR;
+  }
-  rv = cookie_svc->GetCookieString(uri, NULL, cookieString);
-  if (NS_FAILED(rv) || !*cookieString) {
-    return NPERR_GENERIC_ERROR;
+  }
-#else
   // getvalueforurl needs an NPP instance. Quite frankly, there is no easy way
   // to know which instance needs the information, as applets on Java side can
 …
+  }
-#endif
   return NPERR_NO_ERROR;
+}
 …
 // HELPER FUNCTIONS
+static void
 plugin_data_new (ITNPPluginData** data)
+ITNPPluginData*
+plugin_data_new ()
+{
   PLUGIN_DEBUG ("plugin_data_new\n");
   *data = (ITNPPluginData*)
+    (*browser_functions.memalloc) (sizeof (struct ITNPPluginData));
   // appletviewer_alive is false until the applet viewer is spawned.
   if (*data)
     memset (*data, 0, sizeof (struct ITNPPluginData));
+  ITNPPluginData* data = (ITNPPluginData*)browser_functions.memalloc(sizeof (struct ITNPPluginData));
+  if (data)
+  {
+      // Call constructor on allocated data
+      new (data) ITNPPluginData();
+  }
   PLUGIN_DEBUG ("plugin_data_new return\n");
+  return data;
+}
 …
 // documentbase.  This function relies on browser-private data so it
 // will only work when the plugin is loaded in a Mozilla-based
+// browser.  We could not find a way to retrieve the documentbase
+// using the original Netscape plugin API so we use the XPCOM API
+// instead.
+#if MOZILLA_VERSION_COLLAPSED < 1090100
+static gchar*
+// browser.
+static std::string
 plugin_get_documentbase (NPP instance)
+{
   PLUGIN_DEBUG ("plugin_get_documentbase\n");
-  nsIPluginInstance* xpcom_instance = NULL;
-  nsIPluginInstancePeer* peer = NULL;
-  nsresult result = 0;
-  nsIPluginTagInfo2* pluginTagInfo2 = NULL;
-  info_union u = { NULL };
-  char const* documentbase = NULL;
-  gchar* documentbase_copy = NULL;
-  xpcom_instance = (nsIPluginInstance*) (instance->ndata);
-  if (!xpcom_instance)
+    {
-      PLUGIN_ERROR ("xpcom_instance is NULL.");
-      goto cleanup_done;
+    }
-  xpcom_instance->GetPeer (&peer);
-  if (!peer)
+    {
-      PLUGIN_ERROR ("peer is NULL.");
-      goto cleanup_done;
+    }
-  u.info_field = &pluginTagInfo2;
-  result = peer->QueryInterface (kIPluginTagInfo2IID,
-                                 u.void_field);
-  if (result || !pluginTagInfo2)
+    {
-      PLUGIN_ERROR ("pluginTagInfo2 retrieval failed.");
-      goto cleanup_peer;
+    }
-  pluginTagInfo2->GetDocumentBase (&documentbase);
-  if (!documentbase)
+    {
-      // NULL => dummy instantiation for LiveConnect
-      goto cleanup_plugintaginfo2;
+    }
-  documentbase_copy = g_strdup (documentbase);
-  // Release references.
- cleanup_plugintaginfo2:
-  NS_RELEASE (pluginTagInfo2);
- cleanup_peer:
-  NS_RELEASE (peer);
- cleanup_done:
-  PLUGIN_DEBUG ("plugin_get_documentbase return\n");
-  PLUGIN_DEBUG("plugin_get_documentbase returning: %s\n", documentbase_copy);
-  return documentbase_copy;
+}
-#else
-static gchar*
-plugin_get_documentbase (NPP instance)
+{
-  PLUGIN_DEBUG ("plugin_get_documentbase\n");
-  char const* documentbase = NULL;
-  gchar* documentbase_copy = NULL;
   // FIXME: This method is not ideal, but there are no known NPAPI call
 …
   std::string href_str = IcedTeaPluginUtilities::NPVariantAsString(href);
-  documentbase_copy = g_strdup (href_str.c_str());
   // Release references.
   browser_functions.releasevariantvalue(&href);
   browser_functions.releasevariantvalue(&location);
+ cleanup_done:
   PLUGIN_DEBUG ("plugin_get_documentbase return\n");
+  PLUGIN_DEBUG("plugin_get_documentbase returning: %s\n", documentbase_copy);
+  return documentbase_copy;
+}
+#endif
+// This function displays an error message if the appletviewer has not
+// been installed correctly.
+static void
+plugin_display_failure_dialog ()
+{
+#ifdef __OS2__
+  gchar *msg = NULL;
+  PLUGIN_DEBUG ("plugin_display_failure_dialog\n");
+  msg = g_strdup_printf (FAILURE_MESSAGE, appletviewer_executable);
+  WinMessageBox (HWND_DESKTOP, HWND_DESKTOP,
+                 msg, "Error", 0, MB_ERROR | MB_OK | MB_MOVEABLE);
+  g_free(msg);
+#else
+  GtkWidget* dialog = NULL;
+  PLUGIN_DEBUG ("plugin_display_failure_dialog\n");
+  dialog = gtk_message_dialog_new (NULL,
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_MESSAGE_ERROR,
+                                   GTK_BUTTONS_CLOSE,
+                                   FAILURE_MESSAGE,
+                                   appletviewer_executable);
+  gtk_widget_show_all (dialog);
+  gtk_dialog_run (GTK_DIALOG (dialog));
+  gtk_widget_destroy (dialog);
+#endif
+  PLUGIN_DEBUG ("plugin_display_failure_dialog return\n");
+}
+  PLUGIN_DEBUG("plugin_get_documentbase returning: %s\n", href_str.c_str());
+  return href_str;
+}
 // plugin_in_pipe_callback is called when data is available on the
 …
           if (channel_error)
+            {
               PLUGIN_ERROR_TWO ("Failed to read line from input channel",
+              PLUGIN_ERROR ("Failed to read line from input channel, %s\n",
                                 channel_error->message);
               g_error_free (channel_error);
 …
+            }
           else
             PLUGIN_ERROR ("Failed to read line from input channel");
+            PLUGIN_ERROR ("Failed to read line from input channel\n");
 #ifdef __OS2__
           // G_IO_ERR/HUP is not reported on file/pipe handles, simulate it
 …
   if (g_str_has_prefix(parts[1], "PluginProxyInfo"))
+  {
     gchar* proxy;
+    gchar* proxy = NULL;
     uint32_t len;
 …
     gchar* proxy_info;
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-        proxy = (char*) malloc(sizeof(char)*2048);
-#endif
     proxy_info = g_strconcat ("plugin PluginProxyInfo reference ", parts[3], " ", NULL);
 …
     proxy_info = NULL;
+#if MOZILLA_VERSION_COLLAPSED < 1090100
+        g_free(proxy);
+        proxy = NULL;
+#endif
+    g_free(proxy);
+    proxy = NULL;
   } else if (g_str_has_prefix(parts[1], "PluginCookieInfo"))
 …
     gchar* cookie_info = g_strconcat ("plugin PluginCookieInfo reference ", parts[3], " ", NULL);
     gchar* cookie_string;
+    gchar* cookie_string = NULL;
     uint32_t len;
     if (get_cookie_info(decoded_url, &cookie_string, &len) == NPERR_NO_ERROR)
 …
     g_free(cookie_info);
     cookie_info = NULL;
+    g_free(cookie_string);
+    cookie_string = NULL;
   } else if (g_str_has_prefix(parts[1], "PluginSetCookie"))
+  {
 …
           return NPERR_GENERIC_ERROR;
+  }
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-  nsresult rv;
-  // Initialize service variables
-  nsCOMPtr<nsIProtocolProxyService> proxy_svc = do_GetService("@mozilla.org/network/protocol-proxy-service;1", &rv);
-  if (!proxy_svc) {
-      printf("Cannot initialize proxy service\n");
-      return NPERR_GENERIC_ERROR;
+  }
-  nsCOMPtr<nsIIOService> io_svc = do_GetService("@mozilla.org/network/io-service;1", &rv);
-  if (NS_FAILED(rv) || !io_svc) {
-    printf("Cannot initialize io service\n");
-    return NPERR_GENERIC_ERROR;
+  }
-  // uri which needs to be accessed
-  nsCOMPtr<nsIURI> uri;
-  io_svc->NewURI(nsCString(siteAddr), NULL, NULL, getter_AddRefs(uri));
-  // find the proxy address if any
-  nsCOMPtr<nsIProxyInfo> info;
-  proxy_svc->Resolve(uri, 0, getter_AddRefs(info));
-  // if there is no proxy found, return immediately
-  if (!info) {
-     PLUGIN_DEBUG("%s does not need a proxy\n", siteAddr);
-     return NPERR_GENERIC_ERROR;
+  }
-  // if proxy info is available, extract it
-  nsCString phost;
-  PRInt32 pport;
-  nsCString ptype;
-  info->GetHost(phost);
-  info->GetPort(&pport);
-  info->GetType(ptype);
-  // resolve the proxy address to an IP
-  nsCOMPtr<nsIDNSService> dns_svc = do_GetService("@mozilla.org/network/dns-service;1", &rv);
-  if (!dns_svc) {
-      printf("Cannot initialize DNS service\n");
-      return NPERR_GENERIC_ERROR;
+  }
-  nsCOMPtr<nsIDNSRecord> record;
-  dns_svc->Resolve(phost, 0U, getter_AddRefs(record));
-  // TODO: Add support for multiple ips
-  nsDependentCString ipAddr;
-  record->GetNextAddrAsString(ipAddr);
-  if (!strcmp(ptype.get(), "http"))
+  {
-      snprintf(*proxy, sizeof(char)*1024, "%s %s:%d", "PROXY", ipAddr.get(), pport);
-  } else
+  {
-      snprintf(*proxy, sizeof(char)*1024, "%s %s:%d", "SOCKS", ipAddr.get(), pport);
+  }
-  *len = strlen(*proxy);
-  PLUGIN_DEBUG("Proxy info for %s: %s\n", siteAddr, *proxy);
-#else
   if (browser_functions.getvalueforurl)
+  {
 …
       return NPERR_GENERIC_ERROR;
+  }
-#endif
   return NPERR_NO_ERROR;
 …
 plugin_test_appletviewer ()
+{
+  PLUGIN_DEBUG ("plugin_test_appletviewer: %s\n", appletviewer_executable);
+  PLUGIN_DEBUG ("plugin_test_appletviewer: %s\n", get_plugin_executable().c_str());
   NPError error = NPERR_NO_ERROR;
 …
   gchar** environment;
   command_line[0] = g_strdup (appletviewer_executable);
+  command_line[0] = g_strdup (get_plugin_executable().c_str());
   command_line[1] = g_strdup("-version");
   command_line[2] = NULL;
 …
       if (channel_error)
+        {
           PLUGIN_ERROR_TWO ("Failed to spawn applet viewer",
+          PLUGIN_ERROR ("Failed to spawn applet viewer %s\n",
                             channel_error->message);
           g_error_free (channel_error);
 …
+        }
       else
         PLUGIN_ERROR ("Failed to spawn applet viewer");
+        PLUGIN_ERROR ("Failed to spawn applet viewer\n");
       error = NPERR_GENERIC_ERROR;
+    }
 …
+}
 static NPError
+NPError
 plugin_start_appletviewer (ITNPPluginData* data)
+{
 …
   NPError error = NPERR_NO_ERROR;
+  gchar** command_line;
+  gchar** environment;
+  int cmd_num = 0;
+  std::vector<std::string> command_line;
+  gchar** environment = NULL;
+  std::vector<std::string*>* jvm_args = get_jvm_args();
+  // Construct command line parameters
+  command_line.push_back(get_plugin_executable());
+  //Add JVM args to command_line
+  for (int i = 0; i < jvm_args->size(); i++)
+  {
+    command_line.push_back(*jvm_args->at(i));
+  }
+  command_line.push_back(PLUGIN_BOOTCLASSPATH);
+  // set the classpath to avoid using the default (cwd).
+  command_line.push_back("-classpath");
+  command_line.push_back(get_plugin_rt_jar());
+  // Enable coverage agent if we are running instrumented plugin
+#ifdef COVERAGE_AGENT
+  command_line.push_back(COVERAGE_AGENT);
+#endif
   if (plugin_debug)
+  {
+      command_line = (gchar**) malloc(sizeof(gchar*)*11);
+      command_line[cmd_num++] = g_strdup(appletviewer_executable);
+      command_line[cmd_num++] = g_strdup_printf(PLUGIN_BOOTCLASSPATH);
+      // set the classpath to avoid using the default (cwd).
+      command_line[cmd_num++] = g_strdup("-classpath");
+      command_line[cmd_num++] = g_strdup_printf("%s/lib/rt.jar", ICEDTEA_WEB_JRE);
+      command_line[cmd_num++] = g_strdup("-Xdebug");
+      command_line[cmd_num++] = g_strdup("-Xnoagent");
+      if (plugin_debug_suspend)
+      {
+          command_line[cmd_num++] = g_strdup("-Xrunjdwp:transport="DT_SOCKET_DLL",address=8787,server=y,suspend=y");
+      } else
+      {
+          command_line[cmd_num++] = g_strdup("-Xrunjdwp:transport="DT_SOCKET_DLL",address=8787,server=y,suspend=n");
+      }
+      command_line[cmd_num++] = g_strdup("sun.applet.PluginMain");
+#ifdef __OS2__
+      command_line[cmd_num++] = g_strdup_printf("%d", out_pipe [1]);
+      command_line[cmd_num++] = g_strdup_printf("%d", in_pipe [1]);
+    command_line.push_back("-Xdebug");
+    command_line.push_back("-Xnoagent");
+    //Debug flags
+    std::string debug_flags = "-Xrunjdwp:transport="DT_SOCKET_DLL",address=8787,server=y,";
+    debug_flags += plugin_debug_suspend ? "suspend=y" : "suspend=n";
+    command_line.push_back(debug_flags);
+  }
+  command_line.push_back("sun.applet.PluginMain");
+#ifdef __OS2__
+  command_line.push_back((std::ostrstream() << out_pipe[1]).str());
+  command_line.push_back((std::ostrstream() << in_pipe[1]).str());
 #else
+      command_line[cmd_num++] = g_strdup(out_pipe_name);
+      command_line[cmd_num++] = g_strdup(in_pipe_name);
+#endif
+      command_line[cmd_num] = NULL;
+  } else
+  {
+      command_line = (gchar**) malloc(sizeof(gchar*)*8);
+      command_line[cmd_num++] = g_strdup(appletviewer_executable);
+      command_line[cmd_num++] = g_strdup_printf(PLUGIN_BOOTCLASSPATH);
+      command_line[cmd_num++] = g_strdup("-classpath");
+      command_line[cmd_num++] = g_strdup_printf("%s/lib/rt.jar", ICEDTEA_WEB_JRE);
+      command_line[cmd_num++] = g_strdup("sun.applet.PluginMain");
+#ifdef __OS2__
+      command_line[cmd_num++] = g_strdup_printf("%d", out_pipe [1]);
+      command_line[cmd_num++] = g_strdup_printf("%d", in_pipe [1]);
+  command_line.push_back(out_pipe_name);
+  command_line.push_back(in_pipe_name);
+#endif
+  if (plugin_debug_to_console){
+      command_line.push_back(debug_pipe_name);
+  }
+  // Finished command line parameters
+  environment = plugin_filter_environment();
+  std::vector<gchar*> vector_gchar = IcedTeaPluginUtilities::vectorStringToVectorGchar(&command_line);
+  gchar **command_line_args = &vector_gchar[0];
+  if (!g_spawn_async (NULL, command_line_args, environment,
+#ifdef __OS2__
+                      (GSpawnFlags) (G_SPAWN_LEAVE_DESCRIPTORS_OPEN | G_SPAWN_DO_NOT_REAP_CHILD),
 #else
+      command_line[cmd_num++] = g_strdup(out_pipe_name);
+      command_line[cmd_num++] = g_strdup(in_pipe_name);
+#endif
+      command_line[cmd_num] = NULL;
+  }
+  environment = plugin_filter_environment();
+#ifdef __OS2__
+  int flags = G_SPAWN_LEAVE_DESCRIPTORS_OPEN | G_SPAWN_DO_NOT_REAP_CHILD;
+#else
+  int flags = G_SPAWN_DO_NOT_REAP_CHILD;
+#endif
+  if (!g_spawn_async (NULL, command_line, environment,
+                      (GSpawnFlags) flags,
+                      (GSpawnFlags) G_SPAWN_DO_NOT_REAP_CHILD,
+#endif
                       NULL, NULL, &appletviewer_pid, &channel_error))
+    {
       if (channel_error)
+        {
           PLUGIN_ERROR_TWO ("Failed to spawn applet viewer",
+          PLUGIN_ERROR ("Failed to spawn applet viewer %s\n",
                             channel_error->message);
           g_error_free (channel_error);
 …
+        }
       else
         PLUGIN_ERROR ("Failed to spawn applet viewer");
+        PLUGIN_ERROR ("Failed to spawn applet viewer\n");
       error = NPERR_GENERIC_ERROR;
+    }
 …
   signal (SIGPIPE, SIG_IGN);
+  g_strfreev (environment);
+  for (int i = 0; i < cmd_num; i++) {
+    g_free (command_line[i]);
+    command_line[i] = NULL;
+  }
+  g_free(command_line);
+  command_line = NULL;
+  //Free memory
+  g_strfreev(environment);
+  IcedTeaPluginUtilities::freeStringPtrVector(jvm_args);
+  jvm_args = NULL;
+  command_line_args = NULL;
   if (appletviewer_pid)
 …
 /*
+ * Replaces certain characters (\r, \n, etc) with HTML escape equivalents.
+ *
+ * Return string is allocated on the heap. Caller assumes responsibility
+ * for freeing the memory via free()
+ * Returns JVM options set in itw-settings
  */
+static char*
+encode_string(char* to_encode)
+{
+  // Do nothing for an empty string
+  if (to_encode == '\0')
+      return to_encode;
+  // worst case scenario -> all characters are newlines or
+  // returns, each of which translates to 5 substitutions
+  char* encoded = (char*) calloc(((strlen(to_encode)*5)+1), sizeof(char));
+  strcpy(encoded, "");
+  for (int i=0; i < strlen(to_encode); i++)
+  {
+      if (to_encode[i] == '\r')
+          encoded = strcat(encoded, "&#13;");
+      else if (to_encode[i] == '\n')
+          encoded = strcat(encoded, "&#10;");
+      else if (to_encode[i] == '>')
+          encoded = strcat(encoded, "&gt;");
+      else if (to_encode[i] == '<')
+          encoded = strcat(encoded, "&lt;");
+      else if (to_encode[i] == '&')
+          encoded = strcat(encoded, "&amp;");
+      else if (to_encode[i] == '"')
+          encoded = strcat(encoded, "&quot;");
+std::vector<std::string*>*
+get_jvm_args()
+{
+  std::string output;
+  std::vector<std::string*>* tokenOutput = NULL;
+  bool args_defined = read_deploy_property_value("deployment.plugin.jvm.arguments", output);
+  if (!args_defined){
+    return new std::vector<std::string*>();
+  }
+  tokenOutput = IcedTeaPluginUtilities::strSplit(output.c_str(), " \n");
+  return tokenOutput;
+}
+/*
+ * Escape characters for passing to Java.
+ * "\n" for new line, "\\" for "\", "\:" for ";"
+ */
+std::string
+escape_parameter_string(const char* to_encode) {
+  std::string encoded;
+  if (to_encode == NULL)
+  {
+      return encoded;
+  }
+  size_t length = strlen(to_encode);
+  for (int i = 0; i < length; i++)
+  {
+      if (to_encode[i] == '\n')
+          encoded += "\\n";
+      else if (to_encode[i] == '\\')
+          encoded += "\\\\";
+      else if (to_encode[i] == ';')
+          encoded += "\\:";
       else
+      {
+           char* orig_char = (char*) calloc(2, sizeof(char));
+           orig_char[0] = to_encode[i];
+           orig_char[1] = '\0';
+           strcat(encoded, orig_char);
+           free(orig_char);
+           orig_char = NULL;
+      }
+          encoded += to_encode[i];
+  }
 …
+}
+// Build up the applet tag string that we'll send to the applet
+// viewer.
+static gchar*
+plugin_create_applet_tag (int16_t argc, char* argn[], char* argv[])
+{
+  PLUGIN_DEBUG ("plugin_create_applet_tag\n");
+  gchar* applet_tag = g_strdup ("<EMBED ");
+  gchar* parameters = g_strdup ("");
+  for (int16_t i = 0; i < argc; i++)
+    {
+      gchar* argn_escaped = encode_string(argn[i]);
+      gchar* argv_escaped = encode_string(argv[i]);
+      if (!g_ascii_strcasecmp (argn_escaped, "code"))
+        {
+          gchar* code = g_strdup_printf ("CODE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, code, NULL);
+          g_free (code);
+          code = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "java_code"))
+    {
+          gchar* java_code = g_strdup_printf ("JAVA_CODE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, java_code, NULL);
+          g_free (java_code);
+          java_code = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "codebase"))
+    {
+          gchar* codebase = g_strdup_printf ("CODEBASE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, codebase, NULL);
+          g_free (codebase);
+          codebase = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "java_codebase"))
+    {
+          gchar* java_codebase = g_strdup_printf ("JAVA_CODEBASE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, java_codebase, NULL);
+          g_free (java_codebase);
+          java_codebase = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "classid"))
+    {
+          gchar* classid = g_strdup_printf ("CLASSID=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, classid, NULL);
+          g_free (classid);
+          classid = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "archive"))
+    {
+          gchar* archive = g_strdup_printf ("ARCHIVE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, archive, NULL);
+          g_free (archive);
+          archive = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "java_archive"))
+    {
+          gchar* java_archive = g_strdup_printf ("JAVA_ARCHIVE=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, java_archive, NULL);
+          g_free (java_archive);
+          java_archive = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "width"))
+    {
+          gchar* width = g_strdup_printf ("width=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, width, NULL);
+          g_free (width);
+          width = NULL;
+    }
+      else if (!g_ascii_strcasecmp (argn_escaped, "height"))
+    {
+          gchar* height = g_strdup_printf ("height=\"%s\" ", argv_escaped);
+          applet_tag = g_strconcat (applet_tag, height, NULL);
+          g_free (height);
+          height = NULL;
+    }
+      else
+        {
+          if (argv_escaped != '\0')
+            {
+              parameters = g_strconcat (parameters, "<PARAM NAME=\"", argn_escaped,
+                                        "\" VALUE=\"", argv_escaped, "\">", NULL);
+            }
+        }
+      free(argn_escaped);
+      free(argv_escaped);
+      argn_escaped = NULL;
+      argv_escaped = NULL;
+    }
+  applet_tag = g_strconcat (applet_tag, ">", parameters, "</EMBED>", NULL);
+  g_free (parameters);
+  parameters = NULL;
+  PLUGIN_DEBUG ("plugin_create_applet_tag return\n");
+  return applet_tag;
+/*
+ * Build a string containing an encoded list of parameters to send to the applet viewer.
+ * The parameters are separated as 'key1;value1;key2;value2;'. As well, they are
+ * separated and escaped as:
+ * "\n" for new line, "\\" for "\", "\:" for ";"
+ */
+std::string
+plugin_parameters_string (int argc, char* argn[], char* argv[])
+{
+  PLUGIN_DEBUG ("plugin_parameters_string\n");
+  std::string parameters;
+  for (int i = 0; i < argc; i++)
+  {
+    if (argv[i] != NULL)
+    {
+        std::string name_escaped = escape_parameter_string(argn[i]);
+        std::string value_escaped = escape_parameter_string(argv[i]);
+        //Encode parameters and send as 'key1;value1;key2;value2;' etc
+        parameters += name_escaped;
+        parameters += ';';
+        parameters += value_escaped;
+        parameters += ';';
+    }
+  }
+  PLUGIN_DEBUG ("plugin_parameters_string return\n");
+  return parameters;
+}
 …
           if (channel_error)
+            {
               PLUGIN_ERROR_TWO ("Failed to write bytes to output channel",
+              PLUGIN_ERROR ("Failed to write bytes to output channel '%s' \n",
                                 channel_error->message);
               g_error_free (channel_error);
 …
+            }
           else
             PLUGIN_ERROR ("Failed to write bytes to output channel");
+            PLUGIN_ERROR ("Failed to write bytes to output channel for %s", newline_message);
+        }
 …
           if (channel_error)
+            {
               PLUGIN_ERROR_TWO ("Failed to flush bytes to output channel",
+              PLUGIN_ERROR ("Failed to flush bytes to output channel '%s'\n",
                                 channel_error->message);
               g_error_free (channel_error);
 …
+            }
           else
             PLUGIN_ERROR ("Failed to flush bytes to output channel");
+            PLUGIN_ERROR ("Failed to flush bytes to output channel for %s", newline_message);
+        }
       g_free (newline_message);
       newline_message = NULL;
       PLUGIN_DEBUG ("  PIPE: plugin wrote: %s\n", message);
+      PLUGIN_DEBUG ("  PIPE: plugin wrote(?): %s\n", message);
+    }
   PLUGIN_DEBUG ("plugin_send_message_to_appletviewer return\n");
+}
+// unlike like  plugin_send_message_to_appletviewer
+// do not debug
+// do not error
+// do not have its own line end
+// is accesed by only one thread
+// have own pipe
+// jvm must be up
+void
+plugin_send_message_to_appletviewer_console (gchar const* newline_message)
+{
+  gsize bytes_written = 0;
+  if (g_io_channel_write_chars (debug_to_appletviewer,
+                                newline_message, -1, &bytes_written,
+                                &channel_error) != G_IO_STATUS_NORMAL)  {
+          if (channel_error) {
+              //error must be freed
+              g_error_free (channel_error);
+              channel_error = NULL;
+            }
+        }
+}
+//flush only when its full
+void flush_plugin_send_message_to_appletviewer_console (){
+  if (g_io_channel_flush (debug_to_appletviewer, &channel_error)
+                                                 != G_IO_STATUS_NORMAL) {
+          if (channel_error) {
+              g_error_free (channel_error);
+              channel_error = NULL;
+            }
+        }
+}
 …
               if (channel_error)
+                {
                   PLUGIN_ERROR_TWO ("Failed to write shutdown message to"
                                     " appletviewer", channel_error->message);
+                  PLUGIN_ERROR ("Failed to write shutdown message to "
+                                    " appletviewer, %s \n", channel_error->message);
                   g_error_free (channel_error);
                   channel_error = NULL;
+                }
               else
                 PLUGIN_ERROR ("Failed to write shutdown message to");
+                PLUGIN_ERROR ("Failed to write shutdown message to\n");
+            }
 …
               if (channel_error)
+                {
                   PLUGIN_ERROR_TWO ("Failed to write shutdown message to"
                                     " appletviewer", channel_error->message);
+                  PLUGIN_ERROR ("Failed to write shutdown message to"
+                                    " appletviewer %s \n", channel_error->message);
                   g_error_free (channel_error);
                   channel_error = NULL;
+                }
               else
                 PLUGIN_ERROR ("Failed to write shutdown message to");
+                PLUGIN_ERROR ("Failed to write shutdown message to\n");
+            }
 …
               if (channel_error)
+                {
                   PLUGIN_ERROR_TWO ("Failed to shut down appletviewer"
                                     " output channel", channel_error->message);
+                  PLUGIN_ERROR ("Failed to shut down appletviewer"
+                                    " output channel %s \n", channel_error->message);
                   g_error_free (channel_error);
                   channel_error = NULL;
+                }
               else
                 PLUGIN_ERROR ("Failed to shut down appletviewer");
+                PLUGIN_ERROR ("Failed to shut down appletviewer\n");
+            }
+        }
 …
               if (channel_error)
+                {
                   PLUGIN_ERROR_TWO ("Failed to shut down appletviewer"
                                     " input channel", channel_error->message);
+                  PLUGIN_ERROR ("Failed to shut down appletviewer"
+                                    " input channel %s \n", channel_error->message);
                   g_error_free (channel_error);
                   channel_error = NULL;
+                }
               else
                 PLUGIN_ERROR ("Failed to shut down appletviewer");
+                PLUGIN_ERROR ("Failed to shut down appletviewer\n");
+            }
+        }
 …
+}
 static void
+void
 plugin_data_destroy (NPP instance)
+{
 …
+    }
+  tofree->window_handle = NULL;
+  tofree->window_height = 0;
+  tofree->window_width = 0;
+  // cleanup_appletviewer_mutex:
+  g_mutex_free (tofree->appletviewer_mutex);
+  tofree->appletviewer_mutex = NULL;
+  // cleanup_instance_string:
+  g_free (tofree->instance_id);
+  tofree->instance_id = NULL;
+  // cleanup applet tag
+  g_free (tofree->applet_tag);
+  tofree->applet_tag = NULL;
+  g_free(tofree->source);
+  tofree->source = NULL;
+  // cleanup_data:
+  // Eliminate back-pointer to plugin instance.
+  tofree->owner = NULL;
+  /* Explicitly call destructor */
+  tofree->~ITNPPluginData();
   (*browser_functions.memfree) (tofree);
-  tofree = NULL;
   PLUGIN_DEBUG ("plugin_data_destroy return\n");
 …
 initialize_browser_functions(const NPNetscapeFuncs* browserTable)
+{
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-#define NPNETSCAPEFUNCS_LAST_FIELD_USED (browserTable->pluginthreadasynccall)
-#else
 #define NPNETSCAPEFUNCS_LAST_FIELD_USED (browserTable->setvalueforurl)
-#endif
   //Determine the size in bytes, as a difference of the address past the last used field
 …
   pluginTable->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
   pluginTable->size = sizeof (NPPluginFuncs);
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-  pluginTable->newp = NewNPP_NewProc (ITNP_New);
-  pluginTable->destroy = NewNPP_DestroyProc (ITNP_Destroy);
-  pluginTable->setwindow = NewNPP_SetWindowProc (ITNP_SetWindow);
-  pluginTable->newstream = NewNPP_NewStreamProc (ITNP_NewStream);
-  pluginTable->destroystream = NewNPP_DestroyStreamProc (ITNP_DestroyStream);
-  pluginTable->asfile = NewNPP_StreamAsFileProc (ITNP_StreamAsFile);
-  pluginTable->writeready = NewNPP_WriteReadyProc (ITNP_WriteReady);
-  pluginTable->write = NewNPP_WriteProc (ITNP_Write);
-  pluginTable->print = NewNPP_PrintProc (ITNP_Print);
-  pluginTable->urlnotify = NewNPP_URLNotifyProc (ITNP_URLNotify);
-  pluginTable->getvalue = NewNPP_GetValueProc (ITNP_GetValue);
-#else
   pluginTable->newp = NPP_NewProcPtr (ITNP_New);
   pluginTable->destroy = NPP_DestroyProcPtr (ITNP_Destroy);
 …
   pluginTable->urlnotify = NPP_URLNotifyProcPtr (ITNP_URLNotify);
   pluginTable->getvalue = NPP_GetValueProcPtr (ITNP_GetValue);
-#endif
   return true;
+}
+// Make sure the plugin data directory exists, creating it if necessary.
+NPError
+initialize_data_directory()
+{
+  data_directory = IcedTeaPluginUtilities::getRuntimePath() + "/icedteaplugin-";
+  if (getenv("USER") != NULL) {
+    data_directory = data_directory + getenv("USER") + "-";
+  }
+  data_directory += "XXXXXX";
+  // Now create a icedteaplugin subdir
+  char fileNameX[data_directory.length()+1];
+  std::strcpy (fileNameX, data_directory.c_str());
+  char * fileName = mkdtemp(fileNameX);
+  if (fileName == NULL) {
+    PLUGIN_ERROR ("Failed to create data directory %s, %s\n",
+                        data_directory.c_str(),
+                        strerror (errno));
+    return NPERR_GENERIC_ERROR;
+  }
+  data_directory = std::string(fileName);
+  //open uniques icedteaplugin subdir for one single run
+  data_directory_descriptor = opendir(data_directory.c_str());
+  if (data_directory_descriptor == NULL) {
+      PLUGIN_ERROR ("Failed to open data directory %s %s\n",
+                      data_directory.c_str(), strerror (errno));
+      return NPERR_GENERIC_ERROR;
+  }
+  return NPERR_NO_ERROR;
+}
 …
 // been called. There is no need to call this function more than once and
 // this workaround avoids any duplicate calls.
+__attribute__ ((visibility ("default")))
 NPError
 #if defined(_WIN32) || defined (__OS2__)
 …
   if ((browserTable == NULL) || (pluginTable == NULL))
+  {
     PLUGIN_ERROR ("Browser or plugin function table is NULL.");
+    PLUGIN_ERROR ("Browser or plugin function table is NULL.\n");
     return NPERR_INVALID_FUNCTABLE_ERROR;
 …
   if ((browserTable->version >> 8) > NP_VERSION_MAJOR)
+    {
       PLUGIN_ERROR ("Incompatible version.");
+      PLUGIN_ERROR ("Incompatible version.\n");
       return NPERR_INCOMPATIBLE_VERSION_ERROR;
 …
   if ( !browser_functions_supported )
+  {
         PLUGIN_ERROR ("Invalid browser function table.");
+        PLUGIN_ERROR ("Invalid browser function table.\n");
         return NPERR_INVALID_FUNCTABLE_ERROR;
 …
   if ( !plugin_functions_supported )
+  {
     PLUGIN_ERROR ("Invalid plugin function table.");
+    PLUGIN_ERROR ("Invalid plugin function table.\n");
     return NPERR_INVALID_FUNCTABLE_ERROR;
 …
   NPError np_error = NPERR_NO_ERROR;
 #ifndef __OS2__
+  // Make sure the plugin data directory exists, creating it if
+  // necessary.
+  data_directory = g_strconcat (P_tmpdir, NULL);
+  if (!data_directory)
+    {
+      PLUGIN_ERROR ("Failed to create data directory name.");
+      return NPERR_OUT_OF_MEMORY_ERROR;
+    }
+  // If P_tmpdir does not exist, try /tmp directly
+  if (!g_file_test (data_directory,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+    {
+      int file_error = 0;
+      data_directory = g_strconcat ("/tmp", NULL);
+        if (!data_directory)
+          {
+            PLUGIN_ERROR ("Failed to create data directory name.");
+            return NPERR_OUT_OF_MEMORY_ERROR;
+          }
+    }
+  data_directory = g_strconcat (data_directory, "/icedteaplugin-", getenv("USER"), NULL);
+  if (!data_directory)
+  {
+      PLUGIN_ERROR ("Failed to create data directory name.");
+      return NPERR_OUT_OF_MEMORY_ERROR;
+  }
+  // Now create a icedteaplugin subdir
+  if (!g_file_test (data_directory,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+    {
+      int file_error = 0;
+      file_error = g_mkdir (data_directory, 0700);
+      if (file_error != 0)
+        {
+          PLUGIN_ERROR_THREE ("Failed to create data directory",
+                          data_directory,
+                          strerror (errno));
+          np_error = NPERR_GENERIC_ERROR;
+          goto cleanup_data_directory;
+        }
+    }
+  // If data directory doesn't exit by this point, bail
+  if (!g_file_test (data_directory,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+    {
+      PLUGIN_ERROR_THREE ("Temp directory does not exist: ",
+                          data_directory,
+                          strerror (errno));
+      np_error = NPERR_GENERIC_ERROR;
+            goto cleanup_data_directory;
+  // create directory for pipes
+  np_error =  initialize_data_directory();
+  if (np_error != NPERR_NO_ERROR)
+    {
+      PLUGIN_ERROR("Unable to create data directory %s\n", data_directory.c_str());
+      return np_error;
+    }
 #endif
   // Set appletviewer_executable.
+  gchar* filename = g_strdup(ICEDTEA_WEB_JRE);
+  appletviewer_executable = g_strdup_printf ("%s/bin/java",
+                                             filename);
+  PLUGIN_DEBUG("Executing java at %s\n", appletviewer_executable);
+  if (!appletviewer_executable)
+    {
+      PLUGIN_ERROR ("Failed to create appletviewer executable name.");
+      np_error = NPERR_OUT_OF_MEMORY_ERROR;
+      goto cleanup_filename;
+    }
+  PLUGIN_DEBUG("Executing java at %s\n", get_plugin_executable().c_str());
   np_error = plugin_test_appletviewer ();
   if (np_error != NPERR_NO_ERROR)
+    {
+      plugin_display_failure_dialog ();
+      goto cleanup_appletviewer_executable;
+    }
+  g_free (filename);
+      PLUGIN_ERROR("Unable to find java executable %s\n", get_plugin_executable().c_str());
+      return np_error;
+    }
   // Initialize threads (needed for mutexes).
 …
+  {
     PLUGIN_DEBUG ("Failed to integrate with PM");
+    np_error = NPERR_GENERIC_ERROR;
+    goto cleanup_appletviewer_executable;
+    return NPERR_GENERIC_ERROR;
+  }
 #endif
 …
   plugin_instance_mutex = g_mutex_new ();
   PLUGIN_DEBUG ("NP_Initialize: using %s\n", appletviewer_executable);
+  PLUGIN_DEBUG ("NP_Initialize: using %s\n", get_plugin_executable().c_str());
   plugin_req_proc = new PluginRequestProcessor();
 …
   return NPERR_NO_ERROR;
- cleanup_appletviewer_executable:
-  if (appletviewer_executable)
+    {
-      g_free (appletviewer_executable);
-      appletviewer_executable = NULL;
+    }
- cleanup_filename:
-  if (filename)
+    {
-      g_free (filename);
-      filename = NULL;
+    }
- cleanup_data_directory:
-  if (data_directory)
+    {
-      g_free (data_directory);
-      data_directory = NULL;
+    }
-  return np_error;
+}
 …
 // Returns a string describing the MIME type that this plugin
 // handles.
+__attribute__ ((visibility ("default")))
 #ifdef LEGACY_XULRUNNERAPI
   char*
 …
 OSCALL NP_GetMIMEDescription ()
+{
+  //this function is called severaltimes between lunches
   PLUGIN_DEBUG ("NP_GetMIMEDescription\n");
 …
 // Returns a value relevant to the plugin as a whole.  The browser
 // calls this function to obtain information about the plugin.
+__attribute__ ((visibility ("default")))
 NPError
 OSCALL NP_GetValue (void* future, NPPVariable variable, void* value)
 …
     default:
       PLUGIN_ERROR ("Unknown plugin value requested.");
+      PLUGIN_ERROR ("Unknown plugin value requested.\n");
       result = NPERR_GENERIC_ERROR;
       break;
 …
 // Shuts down the plugin.  Called after the last plugin instance is
 // destroyed.
+__attribute__ ((visibility ("default")))
 NPError
 OSCALL NP_Shutdown (void)
 …
       g_mutex_free (plugin_instance_mutex);
       plugin_instance_mutex = NULL;
+    }
-  if (data_directory)
+    {
-      g_free (data_directory);
-      data_directory = NULL;
+    }
-  if (appletviewer_executable)
+    {
-      g_free (appletviewer_executable);
-      appletviewer_executable = NULL;
+    }
 …
 #endif
+  if (plugin_debug_to_console){
+    //jvm_up is now false
+    if (g_io_channel_shutdown (debug_to_appletviewer,
+                                     TRUE, &channel_error)
+              != G_IO_STATUS_NORMAL)
+            {
+              if (channel_error)
+                {
+                  PLUGIN_ERROR ("Failed to shut down appletviewer"
+                                    " debug channel\n", channel_error->message);
+                  g_error_free (channel_error);
+                  channel_error = NULL;
+                }
+              else
+                PLUGIN_ERROR ("Failed to shut down debug to appletviewer\n");
+            }
+    // cleanup_out_to_appletviewer:
+    if (debug_to_appletviewer)
+     g_io_channel_unref (debug_to_appletviewer);
+    out_to_appletviewer = NULL;
+    // cleanup_debug_pipe:
+    // Delete debug pipe.
+    PLUGIN_DEBUG ("NP_Shutdown: deleting debug fifo: %s\n", debug_pipe_name);
+    unlink (debug_pipe_name);
+    PLUGIN_DEBUG ("NP_Shutdown: deleted debug fifo: %s\n", debug_pipe_name);
+    // cleanup_out_pipe_name:
+    g_free (debug_pipe_name);
+    debug_pipe_name = NULL;
+  }
   // Destroy the call queue mutex
   pthread_mutex_destroy(&pluginAsyncCallMutex);
 …
   //delete internal_bus;
+  cleanUpDir();
   PLUGIN_DEBUG ("NP_Shutdown return\n");
+  if (plugin_debug_to_file){
+    fflush (plugin_file_log);
+    //fclose (plugin_file_log);
+    //keep writing untill possible!
+  }
   return NPERR_NO_ERROR;
 …
         if (!data->window_handle)
+        {
             plugin_send_initialization_message(data->instance_id, 0, 0, 0, data->applet_tag);
+            plugin_send_initialization_message(data->instance_id, 0, 0, 0, data->parameters_string);
+        }
 …
         if (java_result->error_occurred)
+        {
             printf("Error: Unable to fetch applet instance id from Java side.\n");
+            PLUGIN_ERROR("Error: Unable to fetch applet instance id from Java side.\n");
             return NULL;
+        }
 …
         if (java_result->error_occurred)
+        {
             printf("Error: Unable to fetch applet instance id from Java side.\n");
+            PLUGIN_ERROR("Error: Unable to fetch applet instance id from Java side.\n");
             return NULL;
+        }
 …
         applet_class_id.append(*(java_result->return_string));
         obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(instance, applet_class_id, instance_id, false);
+        obj = IcedTeaScriptableJavaObject::get_scriptable_java_object(instance, applet_class_id, instance_id, false);
     } else
+    {
         obj = IcedTeaScriptablePluginObject::get_scriptable_java_package_object(instance, "");
+        obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_package_object(instance, "");
+    }

trunk/icedtea-web/plugin/icedteanp/IcedTeaNPPlugin.h

-              r369
+              r429
 #define __ICEDTEANPPLUGIN_H__
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-#include <nsThreadUtils.h>
-#else
 #include <npapi.h>
 #include <npruntime.h>
 #include <npfunctions.h>
-#endif
 // GLib includes.
 #include <glib.h>
 #include <glib/gstdio.h>
-#ifndef __OS2__
-// GTK includes.
-#include <gtk/gtk.h>
-#endif
 #include "IcedTeaPluginUtils.h"
 …
   // A unique identifier for this plugin window.
   gchar* instance_id;
   // The applet tag sent to Java side
   gchar* applet_tag;
+  // The parameter list string sent to Java side
+  gchar* parameters_string;
   // Mutex to protect appletviewer_alive.
   GMutex* appletviewer_mutex;
 …
   guint32 window_height;
   // The source location for this instance
   gchar* source;
+  std::string source;
   // If this is an actual applet instance, or a dummy instance for static calls
   bool is_applet_instance;
+  ITNPPluginData() {
+      instance_id = NULL;
+      parameters_string = NULL;
+      appletviewer_mutex = NULL;
+      owner = (NPP)NULL;
+      window_handle = NULL;
+      window_width = 0;
+      window_height = 0;
+      is_applet_instance = false;
+  }
+  ~ITNPPluginData() {
+      if (appletviewer_mutex) {
+        g_mutex_free (appletviewer_mutex);
+      }
+      // cleanup_instance_string:
+      g_free (instance_id);
+      // cleanup applet tag
+      g_free (parameters_string);
+  }
 };
+// Queue processing threads
+static pthread_t plugin_request_processor_thread1;
+static pthread_t plugin_request_processor_thread2;
+static pthread_t plugin_request_processor_thread3;
+// Have the browser allocate a new ITNPPluginData structure.
+ITNPPluginData* plugin_data_new ();
+void plugin_data_destroy (NPP instance);
+#ifdef __OS2__
+struct QueueProcessorData
+{
+    PluginRequestProcessor *processor;
+    bool stopRequested;
+};
+static QueueProcessorData queue_processor_data1 = { NULL, false };
+static QueueProcessorData queue_processor_data2 = { NULL, false };
+static QueueProcessorData queue_processor_data3 = { NULL, false };
+#endif
+// Condition on which the queue processor waits
+extern pthread_cond_t cond_message_available;
+NPError initialize_data_directory();
+NPError start_jvm_if_needed();
 // ID of plug-in thread
 …
 extern pthread_mutex_t pluginAsyncCallMutex;
+// debug switch
+/*to sync pipe to apletviewer console*/
+extern pthread_mutex_t debug_pipe_lock;
+// debug switches
+extern bool debug_initiated;
 extern int plugin_debug;
+extern bool plugin_debug_headers;
+extern bool plugin_debug_to_file;
+extern bool plugin_debug_to_streams;
+extern bool plugin_debug_to_system;
+extern bool plugin_debug_to_console;
+extern FILE * plugin_file_log;
+extern std::string plugin_file_log_name;
+extern gchar* debug_pipe_name;
+extern gboolean jvm_up;
 // Browser function table.
 …
 /* Sends a message to the appletviewer */
 void plugin_send_message_to_appletviewer(gchar const* message);
+/*this method is not logging, do not add \n and is using different pipe*/
+void plugin_send_message_to_appletviewer_console(gchar const* message);
+void flush_plugin_send_message_to_appletviewer_console();
 /* Returns an appropriate (package/object) scriptable npobject */
 …
 NPObject* allocate_scriptable_object(NPP npp, NPClass *aClass);
+NPError plugin_start_appletviewer (ITNPPluginData* data);
 #endif  /* __ICEDTEANPPLUGIN_H__ */

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc

-              r418
+              r429
  */
-// Initialize static members used by the queue processing framework
-pthread_mutex_t message_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
-pthread_mutex_t syn_write_mutex = PTHREAD_MUTEX_INITIALIZER;
-std::vector< std::vector<std::string*>* >* message_queue = new std::vector< std::vector<std::string*>* >();
 /**
  * PluginRequestProcessor constructor.
 …
 PluginRequestProcessor::PluginRequestProcessor()
+{
     this->pendingRequests = new std::map<pthread_t, uintmax_t>();
+    this->message_queue = new std::vector< std::vector<std::string*>* >();
     internal_req_ref_counter = 0;
+    pthread_mutex_init(&message_queue_mutex, NULL);
+    pthread_mutex_init(&syn_write_mutex, NULL);
+    pthread_cond_init(&cond_message_available, NULL);
+    pthread_mutex_init(&this->message_queue_mutex, NULL);
+    pthread_mutex_init(&this->syn_write_mutex, NULL);
+    pthread_cond_init(&this->cond_message_available, NULL);
+}
 …
     PLUGIN_DEBUG("PluginRequestProcessor::~PluginRequestProcessor\n");
     if (pendingRequests)
         delete pendingRequests;
+    if (message_queue)
+        delete message_queue;
     pthread_mutex_destroy(&message_queue_mutex);
     pthread_mutex_destroy(&syn_write_mutex);
     pthread_cond_destroy(&cond_message_available);
+}
 …
             pthread_mutex_lock(&message_queue_mutex);
             message_queue->push_back(message_parts);
+            pthread_cond_signal(&cond_message_available);
             pthread_mutex_unlock(&message_queue_mutex);
-            // Broadcast that a message is now available
-            pthread_cond_broadcast(&cond_message_available);
             return true;
 …
     propertyNameID = *(message_parts->at(6));
     if (*(message_parts->at(7)) == "literalreturn")
+    if (*(message_parts->at(7)) == "literalreturn" || *(message_parts->at(7)) == "jsobject" )
+    {
         value.append(*(message_parts->at(7)));
 …
         if (java_result->error_occurred)
+        {
             printf("Unable to get member name for setMember. Error occurred: %s\n", java_result->error_msg->c_str());
+            PLUGIN_ERROR("Unable to get member name for setMember. Error occurred: %s\n", java_result->error_msg->c_str());
             //goto cleanup;
+        }
 …
  * This is a static function, called in another thread. Since certain data
  * can only be requested from the main thread in Mozilla, this function
  * does whatever it can seperately, and then makes an internal request that
+ * does whatever it can separately, and then makes an internal request that
  * causes _getMember to do the rest of the work.
+ *
 …
         if (java_result->error_occurred)
+        {
             printf("Unable to process getMember request. Error occurred: %s\n", java_result->error_msg->c_str());
+            PLUGIN_ERROR("Unable to process getMember request. Error occurred: %s\n", java_result->error_msg->c_str());
             //goto cleanup;
+        }
 …
 queue_cleanup(void* data)
+{
-    pthread_mutex_destroy((pthread_mutex_t*) data);
     PLUGIN_DEBUG("Queue processing stopped.\n");
+}
+static void
+queue_wait_cleanup(void* data)
+{
+    pthread_mutex_unlock((pthread_mutex_t*) data);
+}
 …
     PluginRequestProcessor* processor = (PluginRequestProcessor*) data;
 #endif
+    processor->queueProcessorThread();
+    return NULL;
+}
+void
+PluginRequestProcessor::queueProcessorThread()
+{
     std::vector<std::string*>* message_parts = NULL;
     std::string command;
-    pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
     PLUGIN_DEBUG("Queue processor initialized. Queue = %p\n", message_queue);
-    pthread_mutex_init(&wait_mutex, NULL);
 #ifdef __OS2__
     queue_processor_data->stopRequested = false;
 #else
     pthread_cleanup_push(queue_cleanup, (void*) &wait_mutex);
+    pthread_cleanup_push(queue_cleanup, NULL);
 #endif
 …
             if (command == "GetMember")
+            {
                 processor->sendMember(message_parts);
+                sendMember(message_parts);
             } else if (command == "ToString")
+            {
                 processor->sendString(message_parts);
+                sendString(message_parts);
             } else if (command == "SetMember")
+            {
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->setMember(message_parts);
+                setMember(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else if (command == "Call")
 …
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->call(message_parts);
+                call(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else if (command == "Eval")
 …
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->eval(message_parts);
+                eval(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else if (command == "GetSlot")
 …
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->sendMember(message_parts);
+                sendMember(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else if (command == "SetSlot")
 …
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->setMember(message_parts);
+                setMember(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else if (command == "LoadURL") // For instance X url <url> <target>
 …
                 // write methods are synchronized
                 pthread_mutex_lock(&syn_write_mutex);
                 processor->loadURL(message_parts);
+                loadURL(message_parts);
                 pthread_mutex_unlock(&syn_write_mutex);
             } else
 …
         } else
+        {
+            pthread_mutex_lock(&wait_mutex);
+            pthread_cond_wait(&cond_message_available, &wait_mutex);
+            pthread_mutex_unlock(&wait_mutex);
+            pthread_mutex_lock(&message_queue_mutex);
+            if (message_queue->size() == 0)
+            {
+#ifndef __OS2__
+                pthread_cleanup_push(queue_wait_cleanup, &message_queue_mutex);
+#endif
+                pthread_cond_wait(&cond_message_available, &message_queue_mutex);
+#ifndef __OS2__
+                pthread_cleanup_pop(0);
+#endif
+            }
+            pthread_mutex_unlock(&message_queue_mutex);
+        }
 …
 #ifdef __OS2__
+    queue_cleanup((void*) &wait_mutex);
+    queue_cleanup(NULL);
+    queue_wait_cleanup(&message_queue_mutex);
 #else
     pthread_cleanup_pop(1);
 …
         property_identifier = browser_functions.getstringidentifier(property_id->c_str());
     PLUGIN_DEBUG("Setting %s on instance %p, object %p to value %s\n", browser_functions.utf8fromidentifier(property_identifier), instance, member, value->c_str());
+    PLUGIN_DEBUG("Setting %s on instance %p, object %p to value %s\n", IcedTeaPluginUtilities::NPIdentifierAsString(property_identifier).c_str(), instance, member, value->c_str());
     IcedTeaPluginUtilities::javaResultToNPVariant(instance, value, &value_variant);
 …
     instance = (NPP) parameters.at(0);
     parent_ptr = (NPObject*) parameters.at(1);
     std::string*  member_id = (std::string*) parameters.at(2);
 …
     // Get the NPVariant corresponding to this member
     PLUGIN_DEBUG("Looking for %p %p %p (%s)\n", instance, parent_ptr, member_identifier, browser_functions.utf8fromidentifier(member_identifier));
+    PLUGIN_DEBUG("Looking for %p %p %p (%s)\n", instance, parent_ptr, member_identifier, IcedTeaPluginUtilities::NPIdentifierAsString(member_identifier).c_str());
     if (!browser_functions.hasproperty(instance, parent_ptr, member_identifier))
+    {
         printf("%s not found!\n", browser_functions.utf8fromidentifier(member_identifier));
+        PLUGIN_ERROR("%s not found!\n", IcedTeaPluginUtilities::NPIdentifierAsString(member_identifier).c_str());
+    }
     ((AsyncCallThreadData*) data)->call_successful = browser_functions.getproperty(instance, parent_ptr, member_identifier, member_ptr);
 …
         createJavaObjectFromVariant(instance, *member_ptr, &member_ptr_str);
         ((AsyncCallThreadData*) data)->result.append(member_ptr_str);
+    } else
+    {
+        ((AsyncCallThreadData*) data)->result.append("null");
+    }
     ((AsyncCallThreadData*) data)->result_ready = true;
 …
     script_str = (std::string*) call_data->at(2);
-#if MOZILLA_VERSION_COLLAPSED < 1090200
-    script.utf8characters = script_str->c_str();
-    script.utf8length = script_str->size();
-    PLUGIN_DEBUG("Evaluating: %s\n", script_str->c_str());
-#else
     script.UTF8Characters = script_str->c_str();
     script.UTF8Length = script_str->size();
     PLUGIN_DEBUG("Evaluating: %s\n", script_str->c_str());
-#endif
     ((AsyncCallThreadData*) data)->call_successful = browser_functions.evaluate(instance, window_ptr, &script, eval_variant);
 …
+    {
         createJavaObjectFromVariant(instance, tostring_result, &(((AsyncCallThreadData*) data)->result));
+    } else
+    {
+        ((AsyncCallThreadData*) data)->result.append("null");
+    }
     ((AsyncCallThreadData*) data)->result_ready = true;

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginRequestProcessor.h

-              r348
+              r429
 #include <npapi.h>
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-#include <npupp.h>
-#else
-#include <npapi.h>
 #include <npruntime.h>
-#endif
 #include "IcedTeaPluginUtils.h"
 …
 void* queue_processor(void* data);
-/* Mutex to ensure that the request queue is accessed synchronously */
-extern pthread_mutex_t message_queue_mutex;
-/* Mutex to ensure synchronized writes */
-extern pthread_mutex_t syn_write_mutex;
-/* Queue for holding messages that get processed in a separate thread */
-extern std::vector< std::vector<std::string*>* >* message_queue;
 /**
  * Processes requests made TO the plugin (by java or anyone else)
 …
     private:
+        /* Requests that are still pending */
+        std::map<pthread_t, uintmax_t>* pendingRequests;
+        /* Mutex to ensure that the request queue is accessed synchronously */
+        pthread_mutex_t message_queue_mutex;
+        /* Condition on which the queue processor waits */
+        pthread_cond_t cond_message_available;
+        /* Queue for holding messages that get processed in a separate thread */
+        std::vector< std::vector<std::string*>* >* message_queue;
+        /* Mutex to ensure synchronized writes */
+        pthread_mutex_t syn_write_mutex;
         /* Dispatch request processing to a new thread for asynch. processing */
 …
         /* Stores the variant on java side */
         void storeVariantInJava(NPVariant variant, std::string* result);
-    public:
-        PluginRequestProcessor(); /* Constructor */
-        ~PluginRequestProcessor(); /* Destructor */
-        /* Process new requests (if applicable) */
-        virtual bool newMessageOnBus(const char* message);
         /* Send member ID to Java */
 …
         /* Loads a URL into the specified target */
         void loadURL(std::vector<std::string*>* message_parts);
+    public:
+        PluginRequestProcessor(); /* Constructor */
+        ~PluginRequestProcessor(); /* Destructor */
+        /* Process new requests (if applicable) */
+        virtual bool newMessageOnBus(const char* message);
+        /* Thread run method for processing queued messages */
+        void queueProcessorThread();
 };

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginUtils.cc

-              r418
+              r429
 #include "IcedTeaScriptablePluginObject.h"
 #include "IcedTeaPluginUtils.h"
+#include <fstream>
 /**
 …
 std::map<void*, NPP>* IcedTeaPluginUtilities::instance_map = new std::map<void*, NPP>();
 std::map<std::string, NPObject*>* IcedTeaPluginUtilities::object_map = new std::map<std::string, NPObject*>();
+std::queue<std::string> pre_jvm_message;
 /* Plugin async call queue */
 static std::vector< PluginThreadCall* >* pendingPluginThreadRequests = new std::vector< PluginThreadCall* >();
+void *flush_pre_init_messages(void* data) {
+  while (true){
+    struct timespec ts;
+    ts.tv_sec = 1;
+    ts.tv_nsec = 0;
+    nanosleep(&ts ,0);
+    if (jvm_up) {
+      while (!pre_jvm_message.empty()) {
+        pthread_mutex_lock(&debug_pipe_lock);
+        std::string message = pre_jvm_message.front();
+        pre_jvm_message.pop();
+        pthread_mutex_unlock(&debug_pipe_lock);
+        plugin_send_message_to_appletviewer_console(message.c_str());
+      }
+      flush_plugin_send_message_to_appletviewer_console();
+    }
+  }
+  return NULL;
+}
+void push_pre_init_messages(char * ldm){
+  pthread_mutex_lock(&debug_pipe_lock);
+  pre_jvm_message.push(std::string(ldm));
+  pthread_mutex_unlock(&debug_pipe_lock);
+}
+void reset_pre_init_messages(){
+    pre_jvm_message = std::queue<std::string>();
+  }
 /**
 …
         wchar_t c;
         if (plugin_debug) printf("Converted UTF-16LE string: ");
+        PLUGIN_DEBUG("Converted UTF-16LE string: \n");
         result_unicode_str->clear();
 …
                 (c >= '0' && c <= '9'))
+        {
                 if (plugin_debug) printf("%c", c);
+                PLUGIN_DEBUG("%c\n", c);
+        }
 …
         // not routing via debug print macros due to wide-string issues
         if (plugin_debug) printf(". Length=%d\n", result_unicode_str->length());
+        PLUGIN_DEBUG(". Length=%d\n", result_unicode_str->length());
+}
 …
+}
+/* Clear instance_map. Useful for tests. */
+void
+IcedTeaPluginUtilities::clearInstanceIDs()
+{
+    delete instance_map;
+    instance_map = new std::map<void*, NPP>();
+}
 /**
  * Removes all mappings to a given instance, and all associated objects
 …
     PLUGIN_DEBUG("Removing key %s from object map\n", key.c_str());
     object_map->erase(key);
+}
+/* Clear object_map. Useful for tests. */
+void
+IcedTeaPluginUtilities::clearObjectMapping()
+{
+    std::map<std::string, NPObject*>::iterator iter = object_map->begin();
+    for (; iter != object_map->end(); ++iter) {
+        browser_functions.releaseobject(iter->second);
+    }
+    delete object_map;
+    object_map = new std::map<std::string, NPObject*>();
+}
 …
+}
+/**
+ * Convert either a void, boolean, or a number
+ */
+static void
+javaPrimitiveResultToNPVariant(const std::string& value, NPVariant* variant)
+{
+    if (value == "void")
+    {
+        PLUGIN_DEBUG("Method call returned void\n");
+        VOID_TO_NPVARIANT(*variant);
+    } else if (value == "null")
+    {
+        PLUGIN_DEBUG("Method call returned null\n");
+        NULL_TO_NPVARIANT(*variant);
+    } else if (value == "true")
+    {
+        PLUGIN_DEBUG("Method call returned a boolean (true)\n");
+        BOOLEAN_TO_NPVARIANT(true, *variant);
+    } else if (value == "false")
+    {
+        PLUGIN_DEBUG("Method call returned a boolean (false)\n");
+        BOOLEAN_TO_NPVARIANT(false, *variant);
+    } else
+    {
+        double d = strtod(value.c_str(), NULL);
+        // See if it is convertible to int
+        if (value.find(".") != std::string::npos || d < -(0x7fffffffL - 1L) || d > 0x7fffffffL)
+        {
+            PLUGIN_DEBUG("Method call returned a double %f\n", d);
+            DOUBLE_TO_NPVARIANT(d, *variant);
+        } else
+        {
+            int32_t i = (int32_t) d;
+            PLUGIN_DEBUG("Method call returned an int %d\n", i);
+            INT32_TO_NPVARIANT(i, *variant);
+        }
+    }
+}
+static bool
+javaStringResultToNPVariant(const std::string& jobject_id, NPVariant* variant)
+{
+    JavaRequestProcessor jrequest_processor;
+    JavaResultData* jstring_result = jrequest_processor.getString(jobject_id);
+    if (jstring_result->error_occurred)
+    {
+        return false;
+    }
+    std::string str = *jstring_result->return_string;
+    PLUGIN_DEBUG( "Method call returned a string:\"%s\"\n", str.c_str());
+    *variant = IcedTeaPluginUtilities::NPVariantStringCopy(str);
+    return true;
+}
+static bool
+javaJSObjectResultToNPVariant(const std::string& js_id, NPVariant* variant)
+{
+    NPVariant* result_variant = (NPVariant*) IcedTeaPluginUtilities::stringToJSID(js_id);
+    *variant = *result_variant;
+    return true;
+}
+static bool
+javaObjectResultToNPVariant(NPP instance, const std::string& jobject_id, NPVariant* variant)
+{
+    // Reference the class object so we can construct an NPObject with it and the instance
+    JavaRequestProcessor jrequest_processor;
+    JavaResultData* jclass_result = jrequest_processor.getClassID(jobject_id);
+    if (jclass_result->error_occurred)
+    {
+        return false;
+    }
+    std::string jclass_id = *jclass_result->return_string;
+    NPObject* obj;
+    if (jclass_id.at(0) == '[') // array
+    {
+        obj = IcedTeaScriptableJavaObject::get_scriptable_java_object(instance, jclass_id,
+                jobject_id, true);
+    } else
+    {
+        obj = IcedTeaScriptableJavaObject::get_scriptable_java_object(instance, jclass_id,
+                jobject_id, false);
+    }
+    OBJECT_TO_NPVARIANT(obj, *variant);
+    return true;
+}
 bool
 IcedTeaPluginUtilities::javaResultToNPVariant(NPP instance,
+                                              std::string* java_value,
+                                              NPVariant* variant)
+{
+    JavaRequestProcessor java_request = JavaRequestProcessor();
+    JavaResultData* java_result;
+    if (java_value->find("literalreturn") == 0)
+    {
+        // 'literalreturn ' == 14 to skip
+        std::string value = java_value->substr(14);
+        // VOID/BOOLEAN/NUMBER
+        if (value == "void")
+        {
+            PLUGIN_DEBUG("Method call returned void\n");
+            VOID_TO_NPVARIANT(*variant);
+        } else if (value == "null")
+        {
+            PLUGIN_DEBUG("Method call returned null\n");
+            NULL_TO_NPVARIANT(*variant);
+        }else if (value == "true")
+        {
+            PLUGIN_DEBUG("Method call returned a boolean (true)\n");
+            BOOLEAN_TO_NPVARIANT(true, *variant);
+        } else if (value == "false")
+        {
+            PLUGIN_DEBUG("Method call returned a boolean (false)\n");
+            BOOLEAN_TO_NPVARIANT(false, *variant);
+        } else
+        {
+            double d = strtod(value.c_str(), NULL);
+            // See if it is convertible to int
+            if (value.find(".") != std::string::npos ||
+                d < -(0x7fffffffL - 1L) ||
+                d > 0x7fffffffL)
+            {
+                PLUGIN_DEBUG("Method call returned a double %f\n", d);
+                DOUBLE_TO_NPVARIANT(d, *variant);
+            } else
+            {
+                int32_t i = (int32_t) d;
+                PLUGIN_DEBUG("Method call returned an int %d\n", i);
+                INT32_TO_NPVARIANT(i, *variant);
+            }
+        }
+    } else {
+        // Else this is a complex java object
+        // To keep code a little bit cleaner, we create variables with proper descriptive names
+        std::string return_obj_instance_id = std::string();
+        std::string return_obj_class_id = std::string();
+        std::string return_obj_class_name = std::string();
+        return_obj_instance_id.append(*java_value);
+        // Find out the class name first, because string is a special case
+        java_result = java_request.getClassName(return_obj_instance_id);
+        if (java_result->error_occurred)
+        std::string* java_value, NPVariant* variant)
+{
+    int literal_n = sizeof("literalreturn"); // Accounts for one space char
+    int jsobject_n = sizeof("jsobject"); // Accounts for one space char
+    if (strncmp("literalreturn ", java_value->c_str(), literal_n) == 0)
+    {
+        javaPrimitiveResultToNPVariant(java_value->substr(literal_n), variant);
+    } else if (strncmp("jsobject ", java_value->c_str(), jsobject_n) == 0)
+    {
+        javaJSObjectResultToNPVariant(java_value->substr(jsobject_n), variant);
+    } else
+    {
+        std::string jobject_id = *java_value;
+        JavaRequestProcessor jrequest_processor;
+        JavaResultData* jclassname_result = jrequest_processor.getClassName(jobject_id);
+        if (jclassname_result->error_occurred)
+        {
             return false;
+        }
+        return_obj_class_name.append(*(java_result->return_string));
+        if (return_obj_class_name == "java.lang.String")
+        {
+            // String is a special case as NPVariant can handle it directly
+            java_result = java_request.getString(return_obj_instance_id);
+            if (java_result->error_occurred)
+            {
+                return false;
+            }
+            // needs to be on the heap
+            NPUTF8* return_str = (NPUTF8*) malloc(sizeof(NPUTF8)*java_result->return_string->size() + 1);
+            strcpy(return_str, java_result->return_string->c_str());
+            PLUGIN_DEBUG("Method call returned a string: \"%s\"\n", return_str);
+            STRINGZ_TO_NPVARIANT(return_str, *variant);
+        } else {
+            // Else this is a regular class. Reference the class object so
+            // we can construct an NPObject with it and the instance
+            java_result = java_request.getClassID(return_obj_instance_id);
+            if (java_result->error_occurred)
+            {
+                return false;
+            }
+            return_obj_class_id.append(*(java_result->return_string));
+            NPObject* obj;
+            if (return_obj_class_name.find('[') == 0) // array
+                obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(
+                                instance,
+                                return_obj_class_id, return_obj_instance_id, true);
+            else
+                obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(
+                                                instance,
+                                                return_obj_class_id, return_obj_instance_id, false);
+            OBJECT_TO_NPVARIANT(obj, *variant);
+        // Special-case for NPString if string
+        if (*jclassname_result->return_string == "java.lang.String")
+        {
+            return javaStringResultToNPVariant(jobject_id, variant);
+        } else // Else this needs a java object wrapper
+        {
+            return javaObjectResultToNPVariant(instance, jobject_id, variant);
+        }
+    }
 …
 IcedTeaPluginUtilities::NPVariantAsString(NPVariant variant)
+{
-#if MOZILLA_VERSION_COLLAPSED < 1090200
-  return std::string(
-    NPVARIANT_TO_STRING(variant).utf8characters,
-    NPVARIANT_TO_STRING(variant).utf8length);
-#else
   return std::string(
     NPVARIANT_TO_STRING(variant).UTF8Characters,
     NPVARIANT_TO_STRING(variant).UTF8Length);
-#endif
+}
 …
  * @param data Arguments to *func
  */
+NPString IcedTeaPluginUtilities::NPStringCopy(const std::string& result) {
+    char* utf8 = (char*)browser_functions.memalloc(result.size() + 1);
+    strncpy(utf8, result.c_str(), result.size() + 1);
+    NPString npstr = {utf8, result.size()};
+    return npstr;
+}
+NPVariant IcedTeaPluginUtilities::NPVariantStringCopy(const std::string& result) {
+    NPString npstr = NPStringCopy(result);
+    NPVariant npvar;
+    STRINGN_TO_NPVARIANT(npstr.UTF8Characters, npstr.UTF8Length, npvar);
+    return npvar;
+}
 void
 IcedTeaPluginUtilities::callAndWaitForResult(NPP instance, void (*func) (void *), AsyncCallThreadData* data)
 …
 /**
+ * Returns a vector of gchar* pointing to the elements of the vector string passed in.
+ * @param stringVec The vector of strings reference.
+ */
+std::vector<gchar*>
+IcedTeaPluginUtilities::vectorStringToVectorGchar(const std::vector<std::string>* stringVec)
+{
+  std::vector<gchar*> charVec;
+  for (int i = 0; i < stringVec->size(); i++)
+  {
+    gchar* element = (gchar*) stringVec->at(i).c_str(); //cast from const char
+    charVec.push_back(element);
+  }
+  charVec.push_back(NULL);
+  return charVec;
+}
+/**
  * Runs through the async call wait queue and executes all calls
+ *
 …
+}
+void IcedTeaPluginUtilities::trim(std::string& str) {
+        size_t start = str.find_first_not_of(" \t\n"), end = str.find_last_not_of(" \t\n");
+        if (start == std::string::npos) {
+                return;
+        }
+        str = str.substr(start, end - start + 1);
+}
+std::string IcedTeaPluginUtilities::NPIdentifierAsString(NPIdentifier id) {
+    NPUTF8* cstr = browser_functions.utf8fromidentifier(id);
+    if (cstr == NULL) {
+        /* Treat not-existing strings as empty. To tell if it was a valid string,
+         * use browser_functions.identifierisstring. */
+        return std::string();
+    }
+    std::string str = cstr;
+    browser_functions.memfree(cstr);
+    return str;
+}
+bool IcedTeaPluginUtilities::file_exists(std::string filename)
+{
+    std::ifstream infile(filename.c_str());
+    return infile.good();
+}
+void IcedTeaPluginUtilities::initFileLog(){
+    if (plugin_file_log != NULL ) {
+        //reusing
+        return;
+    }
+    plugin_file_log_name = get_log_dir() + "/" + IcedTeaPluginUtilities::generateLogFileName();
+    int plugin_file_log_fd = open(plugin_file_log_name.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0600);
+    if (plugin_file_log_fd <=0 ) {
+        plugin_debug_to_file = false;
+    } else {
+        plugin_file_log = fdopen(plugin_file_log_fd, "w");
+    }
+    if (plugin_file_log == NULL ) {
+        plugin_debug_to_file = false;
+    }
+}
+std::string IcedTeaPluginUtilities::generateLogFileName(){
+    char times[96];
+    char result[100];
+    time_t t = time(NULL);
+    struct tm  p;
+    localtime_r(&t, &p);
+    struct timeval current_time;   \
+    gettimeofday (&current_time, NULL);\
+    strftime(times, 96, "%Y-%m-%d_%H:%M:%S", &p);
+    snprintf(result, 100, "%s.%i",times, current_time.tv_usec/1000);
+    return "itw-cplugin-"+std::string(result)+".log";
+}
+void IcedTeaPluginUtilities::printDebugStatus(){
+      if (plugin_debug){
+        PLUGIN_DEBUG("plugin_debug: true, initialised\n");
+        if (plugin_debug_headers){
+          PLUGIN_DEBUG("plugin_debug_headers: true\n");
+        } else {
+          PLUGIN_DEBUG("plugin_debug_headers: false\n");
+        }
+        if (plugin_debug_to_file){
+          PLUGIN_DEBUG("plugin_debug_to_file: true, using %s\n", plugin_file_log_name.c_str());
+        } else {
+          PLUGIN_DEBUG("plugin_debug_to_file: false\n");
+        }
+        if (plugin_debug_to_streams){
+          PLUGIN_DEBUG("plugin_debug_to_streams: true\n");
+        } else {
+          PLUGIN_DEBUG("plugin_debug_to_streams: false\n");
+        }
+        if (plugin_debug_to_system){
+          PLUGIN_DEBUG("plugin_debug_to_system: true\n");
+        } else {
+          PLUGIN_DEBUG("plugin_debug_to_system: false\n");
+        }
+        if (plugin_debug_to_console){
+          if (debug_pipe_name){
+            PLUGIN_DEBUG("plugin_debug_to_console: true, pipe %s\n", debug_pipe_name);
+          } else {
+            PLUGIN_DEBUG("plugin_debug_to_console: true, pipe not yet known or broken\n");
+          }
+        } else {
+          PLUGIN_DEBUG("plugin_debug_to_console: false\n");
+        }
+      }
+    }
+std::string IcedTeaPluginUtilities::getTmpPath(){
+  const char* tmpdir_env = getenv("TMPDIR");
+  if (tmpdir_env != NULL && g_file_test (tmpdir_env,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+  {
+    return std::string(tmpdir_env);
+  }
+  else if (g_file_test (P_tmpdir,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+  {
+    return std::string(P_tmpdir);
+  }
+  else
+  {
+    // If TMPDIR and P_tmpdir do not exist, try /tmp directly
+    return "/tmp";
+  }
+}
+std::string IcedTeaPluginUtilities::getRuntimePath(){
+ const char* rntdir_env = getenv("XDG_RUNTIME_DIR");
+  if (rntdir_env != NULL && g_file_test (rntdir_env,
+                    (GFileTest) (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
+  {
+    return std::string(rntdir_env);
+  }
+  return IcedTeaPluginUtilities::getTmpPath();
+}
 /******************************************
  * Begin JavaMessageSender implementation *
 …
     PLUGIN_DEBUG("%p unlocked...\n", &msg_queue_mutex);
+}

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginUtils.h

-              r418
+              r429
 #include <pthread.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <syslog.h>
+#include <sys/time.h>
+#include <fcntl.h>
 #include <cstring>
 #include <iostream>
 …
 #include <string>
 #include <vector>
+#include <queue>
 #include <npapi.h>
+#if MOZILLA_VERSION_COLLAPSED < 1090100
+#include <npupp.h>
+#else
+#include <npapi.h>
+#include <glib.h>
 #include <npruntime.h>
+#endif
+extern int plugin_debug; // defined in IcedTeaNPPlugin.cc
+#define PLUGIN_DEBUG(...) \
+  do                                                          \
+  {                                                           \
+    if (plugin_debug)                                         \
+    {                                                         \
+      fprintf (stderr, "ITNPP Thread# %ld: ", pthread_self()); \
+      fprintf (stderr, __VA_ARGS__);                          \
+    }                                                         \
+#include "IcedTeaParseProperties.h"
+void *flush_pre_init_messages(void* data);
+void push_pre_init_messages(char * ldm);
+void reset_pre_init_messages();
+// debugging macro.
+#define initialize_debug()                                                    \
+  do                                                                          \
+  {                                                                           \
+    if (!debug_initiated) {                                                   \
+      debug_initiated = true;                                                 \
+      plugin_debug = getenv ("ICEDTEAPLUGIN_DEBUG") != NULL || is_debug_on(); \
+      plugin_debug_headers = is_debug_header_on();                            \
+      plugin_debug_to_file = is_logging_to_file();                            \
+      plugin_debug_to_streams = is_logging_to_stds();                         \
+      plugin_debug_to_system = is_logging_to_system();                        \
+      plugin_debug_to_console = is_java_console_enabled();                    \
+      if (plugin_debug_to_file) {                                             \
+           IcedTeaPluginUtilities::initFileLog();                             \
+      }                                                                       \
+      if (plugin_debug_to_console) {                                          \
+          /*initialisation done during jvm startup*/                          \
+      }                                                                       \
+      IcedTeaPluginUtilities::printDebugStatus();                             \
+    }                                                                         \
+  } while (0)
+#define  HEADER_SIZE  500
+#define  BODY_SIZE  500
+#define  MESSAGE_SIZE  HEADER_SIZE + BODY_SIZE
+#define  LDEBUG_MESSAGE_SIZE MESSAGE_SIZE+50
+//header is destination char array
+#define CREATE_HEADER(ldebug_header)                   \
+  do                                                   \
+  {                                                    \
+    char times[100];                                   \
+    time_t t = time(NULL);                             \
+    struct tm  p;                                      \
+    localtime_r(&t, &p);                               \
+    strftime(times, 100, "%a %b %d %H:%M:%S %Z %Y", &p);\
+    const char *userNameforDebug = (getenv("USERNAME") == NULL) ? "unknown user" : getenv("USERNAME");  \
+    /*this message is parsed in JavaConsole*/          \
+    snprintf(ldebug_header, HEADER_SIZE, "[%s][ITW-C-PLUGIN][MESSAGE_DEBUG][%s][%s:%d] ITNPP Thread# %ld, gthread %p: ",        \
+    userNameforDebug, times, __FILE__, __LINE__,  pthread_self(), g_thread_self ());                        \
   } while (0)
+#define PLUGIN_DEBUG(...)              \
+  do                                   \
+  {                                    \
+    initialize_debug();                \
+    if (plugin_debug)  {               \
+      char ldebug_header[HEADER_SIZE]; \
+      char ldebug_body[BODY_SIZE];     \
+      char ldebug_message[MESSAGE_SIZE];\
+      if (plugin_debug_headers) {      \
+        CREATE_HEADER(ldebug_header);  \
+      } else {                         \
+        sprintf(ldebug_header,"");     \
+      }                                \
+      snprintf(ldebug_body, BODY_SIZE,  __VA_ARGS__);                               \
+      if (plugin_debug_to_streams) {   \
+        snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body); \
+        fprintf  (stdout, "%s", ldebug_message);\
+      }                                \
+      if (plugin_debug_to_file) {      \
+        snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body);   \
+        fprintf (plugin_file_log, "%s", ldebug_message);   \
+        fflush(plugin_file_log);       \
+      }                                \
+      if (plugin_debug_to_console) {   \
+        /*headers are always going to console*/            \
+        if (!plugin_debug_headers){      \
+          CREATE_HEADER(ldebug_header);  \
+        }                                \
+        snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body); \
+        char ldebug_channel_message[LDEBUG_MESSAGE_SIZE];                               \
+        struct timeval current_time;   \
+        gettimeofday (&current_time, NULL);\
+        if (jvm_up) {                  \
+          snprintf(ldebug_channel_message, LDEBUG_MESSAGE_SIZE, "%s %ld %s", "plugindebug", current_time.tv_sec*1000000L+current_time.tv_usec, ldebug_message);   \
+          push_pre_init_messages(ldebug_channel_message);                           \
+        } else {                       \
+          snprintf(ldebug_channel_message, LDEBUG_MESSAGE_SIZE, "%s %ld %s", "preinit_plugindebug", current_time.tv_sec*1000000L+current_time.tv_usec, ldebug_message);   \
+          push_pre_init_messages(ldebug_channel_message);                            \
+        }                              \
+      }                                \
+     if (plugin_debug_to_system){      \
+     /*no debug messages to systemlog*/\
+     }                                 \
+    }                                  \
+  } while (0)
+#define PLUGIN_ERROR(...)              \
+  do                                   \
+  {                                    \
+    initialize_debug();                \
+    char ldebug_header[HEADER_SIZE];   \
+    char ldebug_body[BODY_SIZE];       \
+    char ldebug_message[MESSAGE_SIZE]; \
+    if (plugin_debug_headers) {        \
+      CREATE_HEADER(ldebug_header);    \
+    } else {                           \
+      sprintf(ldebug_header,"");       \
+    }                                  \
+    snprintf(ldebug_body, BODY_SIZE,  __VA_ARGS__);   \
+    if (plugin_debug_to_streams) {     \
+      snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body); \
+      fprintf  (stderr, "%s", ldebug_message);                                    \
+    }                                  \
+    if (plugin_debug_to_file) {        \
+      snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body); \
+      fprintf (plugin_file_log, "%s", ldebug_message);   \
+      fflush(plugin_file_log);         \
+    }                                  \
+    if (plugin_debug_to_console) {     \
+      /*headers are always going to console*/            \
+      if (!plugin_debug_headers){            \
+        CREATE_HEADER(ldebug_header);  \
+      }                                \
+      snprintf(ldebug_message, MESSAGE_SIZE, "%s%s", ldebug_header, ldebug_body); \
+      char ldebug_channel_message[LDEBUG_MESSAGE_SIZE];                               \
+      struct timeval current_time;     \
+      gettimeofday (&current_time, NULL);\
+        if (jvm_up) {                  \
+          snprintf(ldebug_channel_message, LDEBUG_MESSAGE_SIZE, "%s %ld %s", "pluginerror", current_time.tv_sec*1000000L+current_time.tv_usec, ldebug_message);   \
+          push_pre_init_messages(ldebug_channel_message);                         \
+        } else {                       \
+          snprintf(ldebug_channel_message, LDEBUG_MESSAGE_SIZE, "%s %ld %s", "preinit_pluginerror", current_time.tv_sec*1000000L+current_time.tv_usec, ldebug_message);   \
+          push_pre_init_messages(ldebug_channel_message);                         \
+        }                              \
+    }                                  \
+    if (plugin_debug_to_system){      \
+      /*java can not have prefix*/    \
+      openlog("", LOG_NDELAY, LOG_USER);\
+      syslog(LOG_ERR, "%s", "IcedTea-Web c-plugin - for more info see itweb-settings debug options or console. See http://icedtea.classpath.org/wiki/IcedTea-Web#Filing_bugs for help.");\
+      syslog(LOG_ERR, "%s", "IcedTea-Web c-plugin error manual log:");\
+      /*no headers to syslog*/        \
+      syslog(LOG_ERR, "%s", ldebug_body);   \
+      closelog();                     \
+    }                                 \
+   } while (0)
 #define CHECK_JAVA_RESULT(result_data)                               \
 …
     if (((JavaResultData*) result_data)->error_occurred)             \
     {                                                                \
         printf("Error: Error occurred on Java side: %s.\n",          \
+        PLUGIN_ERROR("Error: Error occurred on Java side: %s.\n",    \
                ((JavaResultData*) result_data)->error_msg->c_str()); \
         return;                                                      \
 …
         static std::string NPVariantAsString(NPVariant variant);
+        /* This must be freed with browserfunctions.memfree */
+        static NPString NPStringCopy(const std::string& result);
+        /* This must be freed with browserfunctions.releasevariantvalue */
+        static NPVariant NPVariantStringCopy(const std::string& result);
+        /* Returns an std::string represented by the given identifier. */
+        static std::string NPIdentifierAsString(NPIdentifier id);
         /* Frees the given vector and the strings that its contents point to */
         static void freeStringPtrVector(std::vector<std::string*>* v);
 …
         static void printNPVariant(NPVariant variant);
         static void NPVariantToString(NPVariant variant, std::string* result);
+        static void NPVariantToString(NPVariant variant, std::string* result);
         static bool javaResultToNPVariant(NPP instance,
 …
         static void storeInstanceID(void* member_ptr, NPP instance);
+        static void     removeInstanceID(void* member_ptr);
+        static NPP getInstanceFromMemberPtr(void* member_ptr);
+        static void removeInstanceID(void* member_ptr);
+        /* Clear object_map. Useful for tests. */
+        static void clearInstanceIDs();
+        static NPP getInstanceFromMemberPtr(void* member_ptr);
         static NPObject* getNPObjectFromJavaKey(std::string key);
 …
         static void removeObjectMapping(std::string key);
+        /* Clear object_map. Useful for tests. */
+        static void clearObjectMapping();
         static void invalidateInstance(NPP instance);
 …
         static void decodeURL(const char* url, char** decoded_url);
+        /* Returns a vector of gchar* pointing to the elements of the vector string passed in*/
+        static std::vector<gchar*> vectorStringToVectorGchar(const std::vector<std::string>* stringVec);
         /* Posts call in async queue and waits till execution completes */
         static void callAndWaitForResult(NPP instance, void (*func) (void *), AsyncCallThreadData* data);
+        /*cutting whitespaces from end and start of string*/
+        static void trim(std::string& str);
+        static bool file_exists(std::string filename);
+        //file-loggers helpers
+        static std::string generateLogFileName();
+        static void initFileLog();
+        static void printDebugStatus();
+        static std::string getTmpPath();
+        static std::string getRuntimePath();
 };
 …
 };
 #endif // __ICEDTEAPLUGINUTILS_H__

trunk/icedtea-web/plugin/icedteanp/IcedTeaScriptablePluginObject.cc

-              r348
+              r429
 IcedTeaScriptablePluginObject::deAllocate(NPObject *npobj)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::deAllocate %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::deAllocate %p\n", npobj);
+}
 …
 IcedTeaScriptablePluginObject::invalidate(NPObject *npobj)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::invalidate %p\n", npobj);
+}
 bool
 IcedTeaScriptablePluginObject::hasMethod(NPObject *npobj, NPIdentifier name)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::hasMethod %p\n", npobj);
         return false;
+}
 bool
 IcedTeaScriptablePluginObject::invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args,
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::invalidate %p\n", npobj);
+}
+bool
+IcedTeaScriptablePluginObject::hasMethod(NPObject *npobj, NPIdentifier name_id)
+{
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::hasMethod %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptablePluginObject::invoke(NPObject *npobj, NPIdentifier name_id, const NPVariant *args,
                         uint32_t argCount,NPVariant *result)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::invoke %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::invoke %p\n", npobj);
         return false;
+}
 …
                                uint32_t argCount, NPVariant *result)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::invokeDefault %p\n", npobj);
         return false;
+}
 bool
 IcedTeaScriptablePluginObject::hasProperty(NPObject *npobj, NPIdentifier name)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::hasProperty %p\n", npobj);
         return false;
+}
 bool
 IcedTeaScriptablePluginObject::getProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::invokeDefault %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptablePluginObject::hasProperty(NPObject *npobj, NPIdentifier name_id)
+{
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::hasProperty %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptablePluginObject::getProperty(NPObject *npobj, NPIdentifier name_id, NPVariant *result)
+{
         // Package request?
         if (!strcmp(browser_functions.utf8fromidentifier(name), "java"))
+        if (IcedTeaPluginUtilities::NPIdentifierAsString(name_id) == "java")
+        {
                 //NPObject* obj = IcedTeaScriptablePluginObject::get_scriptable_java_package_object(getInstanceFromMemberPtr(npobj), name);
+                //NPObject* obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_package_object(getInstanceFromMemberPtr(npobj), name);
                 //OBJECT_TO_NPVARIANT(obj, *result);
                 //printf ("Filling variant %p with object %p\n", result);
+                //PLUGIN_ERROR ("Filling variant %p with object %p\n", result);
+        }
 …
 bool
 IcedTeaScriptablePluginObject::setProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::setProperty %p\n", npobj);
         return false;
+}
 bool
 IcedTeaScriptablePluginObject::removeProperty(NPObject *npobj, NPIdentifier name)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::removeProperty %p\n", npobj);
+IcedTeaScriptablePluginObject::setProperty(NPObject *npobj, NPIdentifier name_id, const NPVariant *value)
+{
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::setProperty %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptablePluginObject::removeProperty(NPObject *npobj, NPIdentifier name_id)
+{
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::removeProperty %p\n", npobj);
         return false;
+}
 …
 IcedTeaScriptablePluginObject::enumerate(NPObject *npobj, NPIdentifier **value, uint32_t *count)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::enumerate %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::enumerate %p\n", npobj);
         return false;
+}
 …
                    NPVariant *result)
+{
         printf ("** Unimplemented: IcedTeaScriptablePluginObject::construct %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptablePluginObject::construct %p\n", npobj);
         return false;
+}
 …
+}
+static NPClass
+scriptable_plugin_object_class() {
+    NPClass np_class;
+    np_class.structVersion = NP_CLASS_STRUCT_VERSION;
+    np_class.allocate = allocate_scriptable_jp_object;
+    np_class.deallocate = IcedTeaScriptableJavaPackageObject::deAllocate;
+    np_class.invalidate = IcedTeaScriptableJavaPackageObject::invalidate;
+    np_class.hasMethod = IcedTeaScriptableJavaPackageObject::hasMethod;
+    np_class.invoke = IcedTeaScriptableJavaPackageObject::invoke;
+    np_class.invokeDefault = IcedTeaScriptableJavaPackageObject::invokeDefault;
+    np_class.hasProperty = IcedTeaScriptableJavaPackageObject::hasProperty;
+    np_class.getProperty = IcedTeaScriptableJavaPackageObject::getProperty;
+    np_class.setProperty = IcedTeaScriptableJavaPackageObject::setProperty;
+    np_class.removeProperty = IcedTeaScriptableJavaPackageObject::removeProperty;
+    np_class.enumerate = IcedTeaScriptableJavaPackageObject::enumerate;
+    np_class.construct = IcedTeaScriptableJavaPackageObject::construct;
+    return np_class;
+}
 NPObject*
+IcedTeaScriptablePluginObject::get_scriptable_java_package_object(NPP instance, const NPUTF8* name)
+{
+        NPObject* scriptable_object;
+        NPClass* np_class = new NPClass();
+        np_class->structVersion = NP_CLASS_STRUCT_VERSION;
+        np_class->allocate = allocate_scriptable_jp_object;
+        np_class->deallocate = IcedTeaScriptableJavaPackageObject::deAllocate;
+        np_class->invalidate = IcedTeaScriptableJavaPackageObject::invalidate;
+        np_class->hasMethod = IcedTeaScriptableJavaPackageObject::hasMethod;
+        np_class->invoke = IcedTeaScriptableJavaPackageObject::invoke;
+        np_class->invokeDefault = IcedTeaScriptableJavaPackageObject::invokeDefault;
+        np_class->hasProperty = IcedTeaScriptableJavaPackageObject::hasProperty;
+        np_class->getProperty = IcedTeaScriptableJavaPackageObject::getProperty;
+        np_class->setProperty = IcedTeaScriptableJavaPackageObject::setProperty;
+        np_class->removeProperty = IcedTeaScriptableJavaPackageObject::removeProperty;
+        np_class->enumerate = IcedTeaScriptableJavaPackageObject::enumerate;
+        np_class->construct = IcedTeaScriptableJavaPackageObject::construct;
+        scriptable_object = browser_functions.createobject(instance, np_class);
+        PLUGIN_DEBUG("Returning new scriptable package class: %p from instance %p with name %s\n", scriptable_object, instance, name);
+IcedTeaScriptableJavaPackageObject::get_scriptable_java_package_object(NPP instance, const NPUTF8* name)
+{
+    /* Shared NPClass instance for IcedTeaScriptablePluginObject */
+    static NPClass np_class = scriptable_plugin_object_class();
+    NPObject* scriptable_object = browser_functions.createobject(instance, &np_class);
+    PLUGIN_DEBUG("Returning new scriptable package class: %p from instance %p with name %s\n", scriptable_object, instance, name);
     ((IcedTeaScriptableJavaPackageObject*) scriptable_object)->setPackageName(name);
 …
     IcedTeaPluginUtilities::storeInstanceID(scriptable_object, instance);
         return scriptable_object;
+    return scriptable_object;
+}
 …
 IcedTeaScriptableJavaPackageObject::setPackageName(const NPUTF8* name)
+{
     this->package_name->append(name);
+    this->package_name->assign(name);
+}
 …
 IcedTeaScriptableJavaPackageObject::getPackageName()
+{
     return this->package_name->c_str();
+    return *this->package_name;
+}
 …
 IcedTeaScriptableJavaPackageObject::deAllocate(NPObject *npobj)
+{
     browser_functions.releaseobject(npobj);
+    delete (IcedTeaScriptableJavaPackageObject*)npobj;
+}
 …
 bool
 IcedTeaScriptableJavaPackageObject::hasMethod(NPObject *npobj, NPIdentifier name)
+IcedTeaScriptableJavaPackageObject::hasMethod(NPObject *npobj, NPIdentifier name_id)
+{
     // Silly caller. Methods are for objects!
 …
 bool
 IcedTeaScriptableJavaPackageObject::invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args,
+IcedTeaScriptableJavaPackageObject::invoke(NPObject *npobj, NPIdentifier name_id, const NPVariant *args,
                         uint32_t argCount,NPVariant *result)
+{
         printf ("** Unimplemented: IcedTeaScriptableJavaPackageObject::invoke %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaPackageObject::invoke %p\n", npobj);
         return false;
+}
 …
                                uint32_t argCount, NPVariant *result)
+{
+        printf ("** Unimplemented: IcedTeaScriptableJavaPackageObject::invokeDefault %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptableJavaPackageObject::hasProperty(NPObject *npobj, NPIdentifier name)
+{
+        PLUGIN_DEBUG("IcedTeaScriptableJavaPackageObject::hasProperty %s\n", browser_functions.utf8fromidentifier(name));
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaPackageObject::invokeDefault %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptableJavaPackageObject::hasProperty(NPObject *npobj, NPIdentifier name_id)
+{
+        std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+        PLUGIN_DEBUG("IcedTeaScriptableJavaPackageObject::hasProperty %s\n", name.c_str());
         bool hasProperty = false;
 …
     NPP instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj);
     int plugin_instance_id = get_id_from_instance(instance);
+        PLUGIN_DEBUG("Object package name: \"%s\"\n", ((IcedTeaScriptableJavaPackageObject*) npobj)->getPackageName().c_str());
+        IcedTeaScriptableJavaPackageObject* scriptable_obj = (IcedTeaScriptableJavaPackageObject*)npobj;
+        PLUGIN_DEBUG("Object package name: \"%s\"\n", scriptable_obj->getPackageName().c_str());
         // "^java" is always a package
+        if (((IcedTeaScriptableJavaPackageObject*) npobj)->getPackageName().length() == 0 &&
+            (  !strcmp(browser_functions.utf8fromidentifier(name), "java") ||
+               !strcmp(browser_functions.utf8fromidentifier(name), "javax")))
+        if (scriptable_obj->getPackageName().empty() && (name == "java" || name == "javax"))
+        {
             return true;
+        }
         std::string property_name = ((IcedTeaScriptableJavaPackageObject*) npobj)->getPackageName();
         if (property_name.length() > 0)
+        std::string property_name = scriptable_obj->getPackageName();
+        if (!property_name.empty())
             property_name += ".";
         property_name += browser_functions.utf8fromidentifier(name);
+        property_name += name;
         PLUGIN_DEBUG("Looking for name \"%s\"\n", property_name.c_str());
 …
 bool
+IcedTeaScriptableJavaPackageObject::getProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
+{
+        PLUGIN_DEBUG("IcedTeaScriptableJavaPackageObject::getProperty %s\n", browser_functions.utf8fromidentifier(name));
+        if (!browser_functions.utf8fromidentifier(name))
+IcedTeaScriptableJavaPackageObject::getProperty(NPObject *npobj, NPIdentifier name_id, NPVariant *result)
+{
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+        PLUGIN_DEBUG("IcedTeaScriptableJavaPackageObject::getProperty %s\n", name.c_str());
+        if (!browser_functions.identifierisstring(name_id))
             return false;
 …
     NPP instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj);
     int plugin_instance_id = get_id_from_instance(instance);
+        std::string property_name = ((IcedTeaScriptableJavaPackageObject*) npobj)->getPackageName();
+        if (property_name.length() > 0)
+            property_name += ".";
+        property_name += browser_functions.utf8fromidentifier(name);
+    IcedTeaScriptableJavaPackageObject* scriptable_obj = (IcedTeaScriptableJavaPackageObject*)npobj;
+    std::string property_name = scriptable_obj->getPackageName();
+    if (!property_name.empty())
+        property_name += ".";
+    property_name += name;
         java_result = java_request.findClass(plugin_instance_id, property_name);
 …
+        {
                 PLUGIN_DEBUG("Returning package object\n");
                 obj = IcedTeaScriptablePluginObject::get_scriptable_java_package_object(
+                obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_package_object(
                                   IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj),
                                   property_name.c_str());
 …
+        {
                 PLUGIN_DEBUG("Returning Java object\n");
                 obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(
+                obj = IcedTeaScriptableJavaObject::get_scriptable_java_object(
                                 IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj),
                                 *(java_result->return_string), "0", false);
 …
 bool
 IcedTeaScriptableJavaPackageObject::setProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
+IcedTeaScriptableJavaPackageObject::setProperty(NPObject *npobj, NPIdentifier name_id, const NPVariant *value)
+{
         // Can't be going around setting properties on namespaces.. that's madness!
 …
 bool
 IcedTeaScriptableJavaPackageObject::removeProperty(NPObject *npobj, NPIdentifier name)
+{
         printf ("** Unimplemented: IcedTeaScriptableJavaPackageObject::removeProperty %p\n", npobj);
+IcedTeaScriptableJavaPackageObject::removeProperty(NPObject *npobj, NPIdentifier name_id)
+{
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaPackageObject::removeProperty %p\n", npobj);
         return false;
+}
 …
 IcedTeaScriptableJavaPackageObject::enumerate(NPObject *npobj, NPIdentifier **value, uint32_t *count)
+{
         printf ("** Unimplemented: IcedTeaScriptableJavaPackageObject::enumerate %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaPackageObject::enumerate %p\n", npobj);
         return false;
+}
 …
                    NPVariant *result)
+{
         printf ("** Unimplemented: IcedTeaScriptableJavaPackageObject::construct %p\n", npobj);
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaPackageObject::construct %p\n", npobj);
         return false;
+}
 …
+}
+static NPClass
+scriptable_java_package_object_class() {
+    NPClass np_class;
+    np_class.structVersion = NP_CLASS_STRUCT_VERSION;
+    np_class.allocate = allocate_scriptable_java_object;
+    np_class.deallocate = IcedTeaScriptableJavaObject::deAllocate;
+    np_class.invalidate = IcedTeaScriptableJavaObject::invalidate;
+    np_class.hasMethod = IcedTeaScriptableJavaObject::hasMethod;
+    np_class.invoke = IcedTeaScriptableJavaObject::invoke;
+    np_class.invokeDefault = IcedTeaScriptableJavaObject::invokeDefault;
+    np_class.hasProperty = IcedTeaScriptableJavaObject::hasProperty;
+    np_class.getProperty = IcedTeaScriptableJavaObject::getProperty;
+    np_class.setProperty = IcedTeaScriptableJavaObject::setProperty;
+    np_class.removeProperty = IcedTeaScriptableJavaObject::removeProperty;
+    np_class.enumerate = IcedTeaScriptableJavaObject::enumerate;
+    np_class.construct = IcedTeaScriptableJavaObject::construct;
+    return np_class;
+}
 NPObject*
 IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(NPP instance,
+IcedTeaScriptableJavaObject::get_scriptable_java_object(NPP instance,
                                     std::string class_id,
                                     std::string instance_id,
                                     bool isArray)
+{
+    NPObject* scriptable_object;
+    std::string obj_key = std::string();
+    obj_key += class_id;
+    obj_key += ":";
+    obj_key += instance_id;
+    /* Shared NPClass instance for IcedTeaScriptablePluginObject */
+    static NPClass np_class = scriptable_java_package_object_class();
+    std::string obj_key = class_id + ":" + instance_id;
     PLUGIN_DEBUG("get_scriptable_java_object searching for %s...\n", obj_key.c_str());
     scriptable_object = IcedTeaPluginUtilities::getNPObjectFromJavaKey(obj_key);
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*) IcedTeaPluginUtilities::getNPObjectFromJavaKey(obj_key);
     if (scriptable_object != NULL)
 …
+    }
+        NPClass* np_class = new NPClass();
+        np_class->structVersion = NP_CLASS_STRUCT_VERSION;
+        np_class->allocate = allocate_scriptable_java_object;
+        np_class->deallocate = IcedTeaScriptableJavaObject::deAllocate;
+        np_class->invalidate = IcedTeaScriptableJavaObject::invalidate;
+        np_class->hasMethod = IcedTeaScriptableJavaObject::hasMethod;
+        np_class->invoke = IcedTeaScriptableJavaObject::invoke;
+        np_class->invokeDefault = IcedTeaScriptableJavaObject::invokeDefault;
+        np_class->hasProperty = IcedTeaScriptableJavaObject::hasProperty;
+        np_class->getProperty = IcedTeaScriptableJavaObject::getProperty;
+        np_class->setProperty = IcedTeaScriptableJavaObject::setProperty;
+        np_class->removeProperty = IcedTeaScriptableJavaObject::removeProperty;
+        np_class->enumerate = IcedTeaScriptableJavaObject::enumerate;
+        np_class->construct = IcedTeaScriptableJavaObject::construct;
+        // try to create normally
+    scriptable_object =  browser_functions.createobject(instance, np_class);
+    // try to create normally
+    scriptable_object = (IcedTeaScriptableJavaObject*)browser_functions.createobject(instance, &np_class);
     // didn't work? try creating asynch
 …
         thread_data.parameters.push_back(instance);
         thread_data.parameters.push_back(np_class);
+        thread_data.parameters.push_back(&np_class);
         thread_data.parameters.push_back(&scriptable_object);
 …
     PLUGIN_DEBUG("Constructed new Java Object with classid=%s, instanceid=%s, isArray=%d and scriptable_object=%p\n", class_id.c_str(), instance_id.c_str(), isArray, scriptable_object);
         ((IcedTeaScriptableJavaObject*) scriptable_object)->setClassIdentifier(class_id);
     ((IcedTeaScriptableJavaObject*) scriptable_object)->setIsArray(isArray);
+    scriptable_object->class_id = class_id;
+    scriptable_object->is_object_array = isArray;
         if (instance_id != "0")
             ((IcedTeaScriptableJavaObject*) scriptable_object)->setInstanceIdentifier(instance_id);
+            scriptable_object->instance_id = instance_id;
         IcedTeaPluginUtilities::storeInstanceID(scriptable_object, instance);
 …
+}
+IcedTeaScriptableJavaObject::IcedTeaScriptableJavaObject(NPP instance)
+{
+        this->instance = instance;
+        this->class_id = new std::string();
+        this->instance_id = new std::string();
+}
+IcedTeaScriptableJavaObject::~IcedTeaScriptableJavaObject()
+{
+        delete this->class_id;
+        delete this->instance_id;
+}
+void
+IcedTeaScriptableJavaObject::setClassIdentifier(std::string class_id)
+{
+        this->class_id->append(class_id);
+}
+void
+IcedTeaScriptableJavaObject::setInstanceIdentifier(std::string instance_id)
+{
+        this->instance_id->append(instance_id);
+}
+void
+IcedTeaScriptableJavaObject::setIsArray(bool isArray)
+{
+    this->isObjectArray = isArray;
+}
+void
+IcedTeaScriptableJavaObject::deAllocate(NPObject *npobj)
+{
+        browser_functions.releaseobject(npobj);
+}
+void
+IcedTeaScriptableJavaObject::invalidate(NPObject *npobj)
+{
+        IcedTeaPluginUtilities::removeInstanceID(npobj);
+        std::string obj_key = std::string();
+        obj_key += ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
+        obj_key += ":";
+        obj_key += ((IcedTeaScriptableJavaObject*) npobj)->getInstanceID();
+        IcedTeaPluginUtilities::removeObjectMapping(obj_key);
+}
+bool
+IcedTeaScriptableJavaObject::hasMethod(NPObject *npobj, NPIdentifier name)
+{
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::hasMethod %s (ival=%d)\n", browser_functions.utf8fromidentifier(name), browser_functions.intfromidentifier(name));
+bool
+IcedTeaScriptableJavaObject::hasMethod(NPObject *npobj, NPIdentifier name_id)
+{
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*) npobj;
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::hasMethod %s (ival=%d)\n", name.c_str(), browser_functions.intfromidentifier(name_id));
     bool hasMethod = false;
     // If object is an array and requested "method" may be a number, check for it first
     if ( !((IcedTeaScriptableJavaObject*) npobj)->isArray()  ||
          (browser_functions.intfromidentifier(name) < 0))
+    {
         if (!browser_functions.utf8fromidentifier(name))
+    if ( !scriptable_object->is_object_array  ||
+         (browser_functions.intfromidentifier(name_id) < 0))
+    {
+        if (!browser_functions.identifierisstring(name_id))
             return false;
 …
         JavaRequestProcessor java_request = JavaRequestProcessor();
+        std::string classId = std::string(((IcedTeaScriptableJavaObject*) npobj)->getClassID());
+        std::string methodName = browser_functions.utf8fromidentifier(name);
+        java_result = java_request.hasMethod(classId, methodName);
+        java_result = java_request.hasMethod(scriptable_object->class_id, name);
         hasMethod = java_result->return_identifier != 0;
+    }
 …
 bool
 IcedTeaScriptableJavaObject::invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args,
+IcedTeaScriptableJavaObject::invoke(NPObject *npobj, NPIdentifier name_id, const NPVariant *args,
                         uint32_t argCount, NPVariant *result)
+{
     NPUTF8* method_name = browser_functions.utf8fromidentifier(name);
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
     // Extract arg type array
     PLUGIN_DEBUG("IcedTeaScriptableJavaObject::invoke %s. Args follow.\n", method_name);
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::invoke %s. Args follow.\n", name.c_str());
     for (int i=0; i < argCount; i++)
+    {
 …
     JavaRequestProcessor java_request = JavaRequestProcessor();
+    NPObject* obj;
+    std::string instance_id = ((IcedTeaScriptableJavaObject*) npobj)->getInstanceID();
+    std::string class_id = ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
+    std::string callee;
+    std::string source;
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*)npobj;
+    std::string instance_id = scriptable_object->instance_id;
+    std::string class_id = scriptable_object->class_id;
     NPP instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj);
 …
         if (id == "-1")
+        {
             printf("Unable to create arguments on Java side\n");
+            PLUGIN_ERROR("Unable to create arguments on Java side\n");
             return false;
+        }
 …
+    {
         PLUGIN_DEBUG("Calling static method\n");
-        callee = ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
         java_result = java_request.callStaticMethod(
                         IcedTeaPluginUtilities::getSourceFromInstance(instance),
                         callee, browser_functions.utf8fromidentifier(name), arg_ids);
+                        scriptable_object->class_id, name, arg_ids);
     } else
+    {
         PLUGIN_DEBUG("Calling method normally\n");
-        callee = ((IcedTeaScriptableJavaObject*) npobj)->getInstanceID();
         java_result = java_request.callMethod(
                         IcedTeaPluginUtilities::getSourceFromInstance(instance),
                         callee, browser_functions.utf8fromidentifier(name), arg_ids);
+                        scriptable_object->instance_id, name, arg_ids);
+    }
     if (java_result->error_occurred)
+    {
+        // error message must be allocated on heap
+        char* error_msg = (char*) malloc(java_result->error_msg->length()*sizeof(char));
+        strcpy(error_msg, java_result->error_msg->c_str());
+        browser_functions.setexception(npobj, error_msg);
+        browser_functions.setexception(npobj, java_result->error_msg->c_str());
         return false;
+    }
 …
 bool
+IcedTeaScriptableJavaObject::invokeDefault(NPObject *npobj, const NPVariant *args,
+                               uint32_t argCount, NPVariant *result)
+{
+        printf ("** Unimplemented: IcedTeaScriptableJavaObject::invokeDefault %p\n", npobj);
+        return false;
+}
+bool
+IcedTeaScriptableJavaObject::hasProperty(NPObject *npobj, NPIdentifier name)
+{
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::hasProperty %s (ival=%d)\n", browser_functions.utf8fromidentifier(name), browser_functions.intfromidentifier(name));
+IcedTeaScriptableJavaObject::hasProperty(NPObject *npobj, NPIdentifier name_id)
+{
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::hasProperty %s (ival=%d)\n", name.c_str(), browser_functions.intfromidentifier(name_id));
     bool hasProperty = false;
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*)npobj;
     // If it is an array, only length and indexes are valid
+    if (((IcedTeaScriptableJavaObject*) npobj)->isArray())
+    {
+        if (browser_functions.intfromidentifier(name) >= 0 ||
+            !strcmp(browser_functions.utf8fromidentifier(name), "length"))
+    if (scriptable_object->is_object_array)
+    {
+        if (browser_functions.intfromidentifier(name_id) >= 0 || name == "length")
             hasProperty = true;
     } else
+    {
+        if (!browser_functions.utf8fromidentifier(name))
+        if (!browser_functions.identifierisstring(name_id))
             return false;
         if (!strcmp(browser_functions.utf8fromidentifier(name), "Packages"))
+        if (name == "Packages")
+        {
             hasProperty = true;
 …
             JavaRequestProcessor java_request = JavaRequestProcessor();
+            std::string class_id = std::string(((IcedTeaScriptableJavaObject*) npobj)->getClassID());
+            std::string fieldName = browser_functions.utf8fromidentifier(name);
+            java_result = java_request.hasField(class_id, fieldName);
+            java_result = java_request.hasField(scriptable_object->class_id, name);
             hasProperty = java_result->return_identifier != 0;
 …
 bool
+IcedTeaScriptableJavaObject::getProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
+{
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::getProperty %s (ival=%d)\n", browser_functions.utf8fromidentifier(name), browser_functions.intfromidentifier(name));
+    bool isPropertyClass = false;
+IcedTeaScriptableJavaObject::getProperty(NPObject *npobj, NPIdentifier name_id, NPVariant *result)
+{
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+    bool is_string_id = browser_functions.identifierisstring(name_id);
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::getProperty %s (ival=%d)\n", name.c_str(), browser_functions.intfromidentifier(name_id));
     JavaResultData* java_result;
     JavaRequestProcessor java_request = JavaRequestProcessor();
+    NPObject* obj;
+    std::string instance_id = ((IcedTeaScriptableJavaObject*) npobj)->getInstanceID();
+    std::string class_id = ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
+    NPP instance = ((IcedTeaScriptableJavaObject*) npobj)->getInstance();
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*)npobj;
+    std::string instance_id = scriptable_object->getInstanceID();
+    std::string class_id = scriptable_object->getClassID();
+    NPP instance = scriptable_object->instance;
     if (instance_id.length() > 0) // Could be an array or a simple object
+    {
         // If array and requesting length
+        if ( ((IcedTeaScriptableJavaObject*) npobj)->isArray() &&
+             browser_functions.utf8fromidentifier(name) &&
+             !strcmp(browser_functions.utf8fromidentifier(name), "length"))
+        if ( scriptable_object->is_object_array && name == "length")
+        {
             java_result = java_request.getArrayLength(instance_id);
         } else if ( ((IcedTeaScriptableJavaObject*) npobj)->isArray() &&
                     browser_functions.intfromidentifier(name) >= 0) // else if array and requesting index
+        } else if ( scriptable_object->is_object_array &&
+                    browser_functions.intfromidentifier(name_id) >= 0) // else if array and requesting index
+        {
 …
             if (java_result->error_occurred)
+            {
                 printf("ERROR: Couldn't fetch array length\n");
+                PLUGIN_ERROR("ERROR: Couldn't fetch array length\n");
                 return false;
+            }
 …
             // Access beyond size?
             if (browser_functions.intfromidentifier(name) >= length)
+            if (browser_functions.intfromidentifier(name_id) >= length)
+            {
                 VOID_TO_NPVARIANT(*result);
 …
             std::string index = std::string();
             IcedTeaPluginUtilities::itoa(browser_functions.intfromidentifier(name), &index);
+            IcedTeaPluginUtilities::itoa(browser_functions.intfromidentifier(name_id), &index);
             java_result = java_request.getSlot(instance_id, index);
         } else // Everything else
+        {
             if (!browser_functions.utf8fromidentifier(name))
+            if (!is_string_id) {
                 return false;
+            if (!strcmp(browser_functions.utf8fromidentifier(name), "Packages"))
+            }
+            if (name == "Packages")
+            {
                 NPObject* pkgObject = IcedTeaScriptablePluginObject::get_scriptable_java_package_object(instance, "");
+                NPObject* pkgObject = IcedTeaScriptableJavaPackageObject::get_scriptable_java_package_object(instance, "");
                 OBJECT_TO_NPVARIANT(pkgObject, *result);
                 return true;
 …
             java_result = java_request.getField(
                         IcedTeaPluginUtilities::getSourceFromInstance(instance),
                         class_id, instance_id, browser_functions.utf8fromidentifier(name));
+                        class_id, instance_id, name);
+        }
+    }
     else
+    {
+        if (!browser_functions.utf8fromidentifier(name))
+            return true;
+        if (!is_string_id) {
+            return false;
+        }
         java_result = java_request.getStaticField(
                                 IcedTeaPluginUtilities::getSourceFromInstance(instance),
                                 class_id, browser_functions.utf8fromidentifier(name));
+                                class_id, name);
+    }
 …
 bool
+IcedTeaScriptableJavaObject::setProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
+{
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::setProperty %s (ival=%d) to:\n", browser_functions.utf8fromidentifier(name), browser_functions.intfromidentifier(name));
+IcedTeaScriptableJavaObject::setProperty(NPObject *npobj, NPIdentifier name_id, const NPVariant *value)
+{
+    std::string name = IcedTeaPluginUtilities::NPIdentifierAsString(name_id);
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::setProperty %s (ival=%d) to:\n", name.c_str(), browser_functions.intfromidentifier(name_id));
     IcedTeaPluginUtilities::printNPVariant(*value);
-    bool isPropertyClass = false;
     JavaResultData* java_result;
     JavaRequestProcessor java_request = JavaRequestProcessor();
+    NPObject* obj;
     std::string instance_id = ((IcedTeaScriptableJavaObject*) npobj)->getInstanceID();
     std::string class_id = ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*)npobj;
+    std::string instance_id = scriptable_object->getInstanceID();
+    std::string class_id = scriptable_object->getClassID();
     NPP instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj);
 …
+    {
         // If array
+        if ( ((IcedTeaScriptableJavaObject*) npobj)->isArray() &&
+             browser_functions.utf8fromidentifier(name) &&
+             !strcmp(browser_functions.utf8fromidentifier(name), "length"))
+        if (scriptable_object->is_object_array && name == "length")
+        {
             printf("ERROR: Array length is not a modifiable property\n");
+            PLUGIN_ERROR("ERROR: Array length is not a modifiable property\n");
             return false;
         } else if ( ((IcedTeaScriptableJavaObject*) npobj)->isArray() &&
                     browser_functions.intfromidentifier(name) >= 0) // else if array and requesting index
+        } else if ( scriptable_object->is_object_array &&
+                    browser_functions.intfromidentifier(name_id) >= 0) // else if array and requesting index
+        {
 …
             if (java_result->error_occurred)
+            {
                 printf("ERROR: Couldn't fetch array length\n");
+                PLUGIN_ERROR("ERROR: Couldn't fetch array length\n");
                 return false;
+            }
 …
             // Access beyond size?
             if (browser_functions.intfromidentifier(name) >= length)
+            if (browser_functions.intfromidentifier(name_id) >= length)
+            {
                 return true;
 …
             std::string index = std::string();
             IcedTeaPluginUtilities::itoa(browser_functions.intfromidentifier(name), &index);
+            IcedTeaPluginUtilities::itoa(browser_functions.intfromidentifier(name_id), &index);
             std::string value_id = std::string();
 …
             java_result = java_request.setField(
                         IcedTeaPluginUtilities::getSourceFromInstance(instance),
                         class_id, instance_id, browser_functions.utf8fromidentifier(name), value_id);
+                        class_id, instance_id, name, value_id);
+        }
+    }
 …
         java_result = java_request.setStaticField(
                                 IcedTeaPluginUtilities::getSourceFromInstance(instance),
                                 class_id, browser_functions.utf8fromidentifier(name), value_id);
+                                class_id, name, value_id);
+    }
 …
 bool
-IcedTeaScriptableJavaObject::removeProperty(NPObject *npobj, NPIdentifier name)
+{
-        printf ("** Unimplemented: IcedTeaScriptableJavaObject::removeProperty %p\n", npobj);
-        return false;
+}
-bool
-IcedTeaScriptableJavaObject::enumerate(NPObject *npobj, NPIdentifier **value, uint32_t *count)
+{
-        printf ("** Unimplemented: IcedTeaScriptableJavaObject::enumerate %p\n", npobj);
-        return false;
+}
-bool
 IcedTeaScriptableJavaObject::construct(NPObject *npobj, const NPVariant *args, uint32_t argCount,
                    NPVariant *result)
+{
+    IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*)npobj;
     // Extract arg type array
     PLUGIN_DEBUG("IcedTeaScriptableJavaObject::construct %s. Args follow.\n", ((IcedTeaScriptableJavaObject*) npobj)->getClassID().c_str());
+    PLUGIN_DEBUG("IcedTeaScriptableJavaObject::construct %s. Args follow.\n", scriptable_object->getClassID().c_str());
     for (int i=0; i < argCount; i++)
+    {
 …
     JavaRequestProcessor java_request = JavaRequestProcessor();
-    NPObject* obj;
-    std::string class_id = ((IcedTeaScriptableJavaObject*) npobj)->getClassID();
     NPP instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj);
 …
         if (id == "0")
+        {
+            // error message must be allocated on heap
+            char* error_msg = (char*) malloc(1024*sizeof(char));
+            strcpy(error_msg, "Unable to create argument on Java side");
+            browser_functions.setexception(npobj, error_msg);
+            browser_functions.setexception(npobj, "Unable to create argument on Java side");
             return false;
+        }
 …
     java_result = java_request.newObject(
                             IcedTeaPluginUtilities::getSourceFromInstance(instance),
                             class_id,
+                            scriptable_object->class_id,
                             arg_ids);
     if (java_result->error_occurred)
+    {
+        // error message must be allocated on heap
+        int length = java_result->error_msg->length();
+        char* error_msg = (char*) malloc((length+1)*sizeof(char));
+        strcpy(error_msg, java_result->error_msg->c_str());
+        browser_functions.setexception(npobj, error_msg);
+        browser_functions.setexception(npobj, java_result->error_msg->c_str());
         return false;
+    }
+    std::string return_obj_instance_id = std::string();
+    std::string return_obj_class_id = class_id;
+    return_obj_instance_id.append(*(java_result->return_string));
+    obj = IcedTeaScriptableJavaPackageObject::get_scriptable_java_object(
+    std::string return_obj_instance_id = *java_result->return_string;
+    std::string return_obj_class_id = scriptable_object->class_id;
+    NPObject* obj = IcedTeaScriptableJavaObject::get_scriptable_java_object(
                                 IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj),
                                 return_obj_class_id, return_obj_instance_id, false);

trunk/icedtea-web/plugin/icedteanp/IcedTeaScriptablePluginObject.h

-              r348
+              r429
 #define __ICEDTEASCRIPTABLEPLUGINOBJECT_H_
-#if MOZILLA_VERSION_COLLAPSED < 1090100
-#include "npupp.h"
-#else
 #include <npapi.h>
 #include <npruntime.h>
-#endif
 #include "IcedTeaJavaRequestProcessor.h"
 …
         static void invalidate(NPObject *npobj);
         static bool hasMethod(NPObject *npobj, NPIdentifier name);
         static bool invoke(NPObject *npobj, NPIdentifier name,
+        static bool hasMethod(NPObject *npobj, NPIdentifier name_id);
+        static bool invoke(NPObject *npobj, NPIdentifier name_id,
                 const NPVariant *args, uint32_t argCount, NPVariant *result);
 …
                 uint32_t argCount, NPVariant *result);
         static bool hasProperty(NPObject *npobj, NPIdentifier name);
         static bool getProperty(NPObject *npobj, NPIdentifier name,
+        static bool hasProperty(NPObject *npobj, NPIdentifier name_id);
+        static bool getProperty(NPObject *npobj, NPIdentifier name_id,
                 NPVariant *result);
         static bool setProperty(NPObject *npobj, NPIdentifier name,
+        static bool setProperty(NPObject *npobj, NPIdentifier name_id,
                 const NPVariant *value);
         static bool removeProperty(NPObject *npobj, NPIdentifier name);
+        static bool removeProperty(NPObject *npobj, NPIdentifier name_id);
         static bool enumerate(NPObject *npobj, NPIdentifier **value,
 …
                 uint32_t argCount, NPVariant *result);
-        static NPObject* get_scriptable_java_package_object(NPP instance, const NPUTF8* name);
 };
 …
         static void invalidate(NPObject *npobj);
         static bool hasMethod(NPObject *npobj, NPIdentifier name);
         static bool invoke(NPObject *npobj, NPIdentifier name,
+        static bool hasMethod(NPObject *npobj, NPIdentifier name_id);
+        static bool invoke(NPObject *npobj, NPIdentifier name_id,
                 const NPVariant *args, uint32_t argCount, NPVariant *result);
 …
                 uint32_t argCount, NPVariant *result);
         static bool hasProperty(NPObject *npobj, NPIdentifier name);
         static bool getProperty(NPObject *npobj, NPIdentifier name,
+        static bool hasProperty(NPObject *npobj, NPIdentifier name_id);
+        static bool getProperty(NPObject *npobj, NPIdentifier name_id,
                 NPVariant *result);
         static bool setProperty(NPObject *npobj, NPIdentifier name,
+        static bool setProperty(NPObject *npobj, NPIdentifier name_id,
                 const NPVariant *value);
         static bool removeProperty(NPObject *npobj, NPIdentifier name);
+        static bool removeProperty(NPObject *npobj, NPIdentifier name_id);
         static bool enumerate(NPObject *npobj, NPIdentifier **value,
 …
                 uint32_t argCount, NPVariant *result);
+        static NPObject* get_scriptable_java_object(NPP instance,
+                                                    std::string class_id,
+                                                    std::string instance_id,
+                                                    bool isArray);
+        static NPObject* get_scriptable_java_package_object(NPP instance, const NPUTF8* name);
         static bool is_valid_java_object(NPObject* object_ptr);
 …
 class IcedTeaScriptableJavaObject: public NPObject
+{
+    private:
+        NPP instance;
+        bool isObjectArray;
+        std::string* class_id;
+        std::string* instance_id;
+    public:
+        IcedTeaScriptableJavaObject(NPP instance);
+        ~IcedTeaScriptableJavaObject();
+        void setClassIdentifier(std::string class_id);
+        void setInstanceIdentifier(std::string instance_id);
+        void setIsArray(bool isArray);
+        std::string getClassID() { return *class_id; }
+        std::string getInstanceID() { return *instance_id; }
+        NPP getInstance() { return instance; }
+        bool isArray() { return isObjectArray; }
+        static void deAllocate(NPObject *npobj);
+        static void invalidate(NPObject *npobj);
+        static bool hasMethod(NPObject *npobj, NPIdentifier name);
+        static bool invoke(NPObject *npobj, NPIdentifier name,
+                const NPVariant *args, uint32_t argCount, NPVariant *result);
+        static bool invokeDefault(NPObject *npobj, const NPVariant *args,
+                uint32_t argCount, NPVariant *result);
+        static bool hasProperty(NPObject *npobj, NPIdentifier name);
+        static bool getProperty(NPObject *npobj, NPIdentifier name,
+                NPVariant *result);
+        static bool setProperty(NPObject *npobj, NPIdentifier name,
+                const NPVariant *value);
+        static bool removeProperty(NPObject *npobj, NPIdentifier name);
+        static bool enumerate(NPObject *npobj, NPIdentifier **value,
+                uint32_t *count);
+        static bool construct(NPObject *npobj, const NPVariant *args,
+                uint32_t argCount, NPVariant *result);
+private:
+    NPP instance;
+    bool is_object_array;
+    /* These may be empty if 'is_applet_instance' is true
+     * and the object has not yet been used */
+    std::string class_id, instance_id;
+public:
+    IcedTeaScriptableJavaObject(NPP instance) {
+        this->instance = instance;
+        is_object_array = false;
+    }
+    static void deAllocate(NPObject *npobj) {
+        delete (IcedTeaScriptableJavaObject*)npobj;
+    }
+    std::string getInstanceID() {
+        return instance_id;
+    }
+    std::string getClassID() {
+        return class_id;
+    }
+    std::string objectKey() {
+        return getClassID() + ":" + getInstanceID();
+    }
+    static void invalidate(NPObject *npobj) {
+        IcedTeaPluginUtilities::removeInstanceID(npobj);
+        IcedTeaScriptableJavaObject* scriptable_object = (IcedTeaScriptableJavaObject*) npobj;
+        IcedTeaPluginUtilities::removeObjectMapping(scriptable_object->objectKey());
+    }
+    static bool hasMethod(NPObject *npobj, NPIdentifier name_id);
+    static bool invoke(NPObject *npobj, NPIdentifier name_id,
+            const NPVariant *args, uint32_t argCount, NPVariant *result);
+    static bool invokeDefault(NPObject *npobj, const NPVariant *args,
+            uint32_t argCount, NPVariant *result) {
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaObject::invokeDefault %p\n", npobj);
+        return false;
+    }
+    static bool hasProperty(NPObject *npobj, NPIdentifier name_id);
+    static bool getProperty(NPObject *npobj, NPIdentifier name_id,
+            NPVariant *result);
+    static bool setProperty(NPObject *npobj, NPIdentifier name_id,
+            const NPVariant *value);
+    static bool removeProperty(NPObject *npobj, NPIdentifier name_id) {
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaObject::removeProperty %p\n", npobj);
+        return false;
+    }
+    static bool enumerate(NPObject *npobj, NPIdentifier **value,
+            uint32_t *count) {
+        PLUGIN_ERROR ("** Unimplemented: IcedTeaScriptableJavaObject::enumerate %p\n", npobj);
+        return false;
+    }
+    static bool construct(NPObject *npobj, const NPVariant *args,
+            uint32_t argCount, NPVariant *result);
+     /* Creates and retains a scriptable java object (intended to be called asynch.) */
+    static NPObject* get_scriptable_java_object(NPP instance,
+                                                std::string class_id,
+                                                std::string instance_id,
+                                                bool isArray);
 };

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSObject.java

-              r418
+              r429
     /**
+     * Package-private method used through JSUtil#getJSObjectInternalReference.
+     * We make this package-private to avoid polluting the public interface.
+     * @return the internal identifier
+     */
+    long getInternalReference() {
+        AccessController.getContext().checkPermission(new JSObjectUnboxPermission());
+        return internal;
+    }
+    /**
      * it is illegal to construct a JSObject manually
      */

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSRunnable.java

-              r348
+              r429
 package netscape.javascript;
+import net.sourceforge.jnlp.util.logging.OutputController;
 import sun.applet.PluginDebug;
 …
         } catch (Throwable t) {
             PluginDebug.debug(t.toString());
             t.printStackTrace(System.err);
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,t);
+        }
+    }

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSUtil.java

-              r348
+              r429
         return captureStream.toString();
+    }
+    /**
+     * Uses package-private method JSObject.getInternalReference.
+     * This is package-private to avoid polluting the public interface.
+     * @param js JSObject to unbox
+     * @return the internal reference stored by the JSObject
+     */
+    public static long getJSObjectInternalReference(JSObject js) {
+        // NB: permission is checked in JSObject
+        return js.getInternalReference();
+    }
+}

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java

-              r348
+              r429
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 /*
  * This class resolved overloaded methods in Java objects using a cost
  * based-approach as described here:
+ * based-approach described here:
+ *
  * http://java.sun.com/javase/6/webnotes/6u10/plugin2/liveconnect/#OVERLOADED_METHODS
+ * http://jdk6.java.net/plugin2/liveconnect/#OVERLOADED_METHODS
  */
 public class MethodOverloadResolver {
+    private static boolean debugging = false;
+    public static void main(String[] args) {
+        testMethodResolver();
+    }
+    public static void testMethodResolver() {
+        debugging = true;
+        ArrayList<Object[]> list = new ArrayList<Object[]>(20);
+        FooClass fc = new FooClass();
+        // Numeric to java primitive
+        // foo_i has Integer and int params
+        String s1 = "foo_string_int(S,I)";
+        String s1a = "foo_string_int(S,S)";
+        Object[] o1 = { fc.getClass(), "foo_string_int", "blah", 42 };
+        list.add(o1);
+        Object[] o1a = { fc.getClass(), "foo_string_int", "blah", "42.42" };
+        list.add(o1a);
+        // Null to non-primitive type
+        // foo_i is overloaded with Integer and int
+        String s2 = "foo_string_int(N)";
+        Object[] o2 = { fc.getClass(), "foo_string_int", "blah", null };
+        list.add(o2);
+        // foo_jsobj is overloaded with JSObject and String params
+        String s3 = "foo_jsobj(LLowCostSignatureComputer/JSObject;)";
+        Object[] o3 = { fc.getClass(), "foo_jsobj", new JSObject() };
+        list.add(o3);
+        // foo_classtype is overloaded with Number and Integer
+        String s4 = "foo_classtype(Ljava/lang/Integer;)";
+        Object[] o4 = { fc.getClass(), "foo_classtype", 42 };
+        list.add(o4);
+        // foo_multiprim is overloaded with int, long and float types
+        String s5 = "foo_multiprim(I)";
+        String s6 = "foo_multiprim(F)";
+        String s6a = "foo_multiprim(D)";
+        Object[] o5 = { fc.getClass(), "foo_multiprim", new Integer(42) };
+        Object[] o6 = { fc.getClass(), "foo_multiprim", new Float(42.42) };
+        Object[] o6a = { fc.getClass(), "foo_multiprim", new Double(42.42) };
+        list.add(o5);
+        list.add(o6);
+        list.add(o6a);
+        // foo_float has float, String and JSObject type
+        String s7 = "foo_float(I)";
+        Object[] o7 = { fc.getClass(), "foo_float", new Integer(42) };
+        list.add(o7);
+        // foo_multiprim(float) is what this should convert
+        String s8 = "foo_float(S)";
+        Object[] o8 = { fc.getClass(), "foo_float", "42" };
+        list.add(o8);
+        // foo_class is overloaded with BarClass 2 and 3
+        String s9 = "foo_class(LLowCostSignatureComputer/BarClass3;)";
+        Object[] o9 = { fc.getClass(), "foo_class", new BarClass3() };
+        list.add(o9);
+        // foo_strandbyteonly takes string and byte
+        String s10 = "foo_strandbyteonly(I)";
+        Object[] o10 = { fc.getClass(), "foo_strandbyteonly", 42 };
+        list.add(o10);
+        // JSOBject to string
+        String s11 = "foo_strandbyteonly(LLowCostSignatureComputer/JSObject;)";
+        Object[] o11 = { fc.getClass(), "foo_strandbyteonly", new JSObject() };
+        list.add(o11);
+        // jsobject to string and int to float
+        String s12 = "foo_str_and_float(S,I)";
+        Object[] o12 = { fc.getClass(), "foo_str_and_float", new JSObject(), new Integer(42) };
+        list.add(o12);
+        // call for which no match will be found
+        String s13 = "foo_int_only(JSObject)";
+        Object[] o13 = { fc.getClass(), "foo_int_only", new JSObject() };
+        list.add(o13);
+        // method with no args
+        String s14 = "foo_noargs()";
+        Object[] o14 = { fc.getClass(), "foo_noargs" };
+        list.add(o14);
+        // method which takes a primitive bool, given a Boolean
+        String s15 = "foo_boolonly()";
+        Object[] o15 = { fc.getClass(), "foo_boolonly", new Boolean(true) };
+        list.add(o15);
+        for (Object[] o : list) {
+            Object[] methodAndArgs = getMatchingMethod(o);
+            if (debugging)
+                if (methodAndArgs != null)
+                    System.out.println("Best match: " + methodAndArgs[0] + "\n");
+                else
+                    System.out.println("No match found.\n");
+        }
+    static final int NUMERIC_SAME_COST = 1;
+    static final int NULL_TO_OBJECT_COST = 2;
+    static final int CLASS_SAME_COST = 3;
+    static final int NUMERIC_CAST_COST = 4;
+    static final int NUMERIC_BOOLEAN_COST = 5;
+    static final int STRING_NUMERIC_CAST_COST = 5;
+    static final int CLASS_SUPERCLASS_COST = 6;
+    static final int CLASS_STRING_COST = 7;
+    static final int ARRAY_CAST_COST = 8;
+    /* A method signature with its casted parameters
+     * We pretend a Constructor is a normal 'method' for ease of code reuse */
+    static class ResolvedMethod {
+        private java.lang.reflect.AccessibleObject method;
+        private Object[] castedParameters;
+        private int cost;
+        public ResolvedMethod(int cost, java.lang.reflect.AccessibleObject method, Object[] castedParameters) {
+            this.cost = cost;
+            this.method = method;
+            this.castedParameters = castedParameters;
+        }
+        java.lang.reflect.AccessibleObject getAccessibleObject() {
+            return method;
+        }
+        public Method getMethod() {
+            return (Method)method;
+        }
+        public Constructor<?> getConstructor() {
+            return (Constructor<?>)method;
+        }
+        public Object[] getCastedParameters() {
+            return castedParameters;
+        }
+        public int getCost() {
+            return cost;
+        }
+    }
+    /* A cast with an associated 'cost', used for picking method overloads */
+    static class WeightedCast {
+        private int cost;
+        private Object castedObject;
+        public WeightedCast(int cost, Object castedObject) {
+            this.cost = cost;
+            this.castedObject = castedObject;
+        }
+        public Object getCastedObject() {
+            return castedObject;
+        }
+        public int getCost() {
+            return cost;
+        }
+    }
+    public static ResolvedMethod getBestMatchMethod(Class<?> c, String methodName, Object[] args) {
+        Method[] matchingMethods = getMatchingMethods(c, methodName, args.length);
+        if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+            PluginDebug.debug("getMatchingMethod called with: "
+                    + Arrays.toString(args));
+        }
+        return getBestOverloadMatch(c, args, matchingMethods);
+    }
+    public static ResolvedMethod getBestMatchConstructor(Class<?> c, Object[] args) {
+        Constructor<?>[] matchingConstructors = getMatchingConstructors(c, args.length);
+        if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+            PluginDebug.debug("getMatchingConstructor called with: "
+                    + Arrays.toString(args));
+        }
+        return getBestOverloadMatch(c, args, matchingConstructors);
+    }
     /*
+     * Cost based overload resolution algorithm based on cost rules specified here:
+     *
+     * http://java.sun.com/javase/6/webnotes/6u10/plugin2/liveconnect/#OVERLOADED_METHODS
+     * Get best-matching method based on a cost based overload resolution
+     * algorithm is used, described here:
+     *
+     * http://jdk6.java.net/plugin2/liveconnect/#OVERLOADED_METHODS
+     *
+     * Note that we consider Constructor's to be 'methods' for convenience. We
+     * use the common parent class of Method/Constructor, 'AccessibleObject'
+     *
+     * NB: Although the spec specifies that ambiguous method calls (ie, same
+     * cost) should throw errors, we simply pick the first overload for
+     * simplicity. Method overrides should not be doing wildly different things
+     * anyway.
      */
+    public static Object[] getMatchingMethod(Object[] callList) {
+        Object[] ret = null;
+        Class<?> c = (Class<?>) callList[0];
+        String methodName = (String) callList[1];
+        Method[] matchingMethods = getMatchingMethods(c, methodName, callList.length - 2);
+        if (debugging)
+            System.out.println("getMatchingMethod called with: " + printList(callList));
+    static ResolvedMethod getBestOverloadMatch(Class<?> c, Object[] args,
+            java.lang.reflect.AccessibleObject[] candidates) {
         int lowestCost = Integer.MAX_VALUE;
+        for (Method matchingMethod : matchingMethods) {
+        java.lang.reflect.AccessibleObject cheapestMethod = null;
+        Object[] cheapestArgs = null;
+        boolean ambiguous = false;
+        methodLoop:
+        for (java.lang.reflect.AccessibleObject candidate : candidates) {
             int methodCost = 0;
+            Class[] paramTypes = matchingMethod.getParameterTypes();
             Object[] methodAndArgs = new Object[paramTypes.length + 1];
             methodAndArgs[0] = matchingMethod;
+            Class<?>[] paramTypes = getParameterTypesFor(candidate);
+            Object[] castedArgs = new Object[paramTypes.length];
             // Figure out which of the matched methods best represents what we
 …
             for (int i = 0; i < paramTypes.length; i++) {
                 Class<?> paramTypeClass = paramTypes[i];
                 Object suppliedParam = callList[i + 2];
+                Object suppliedParam = args[i];
                 Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam
+                        .getClass()
+                        : null;
+                Object[] costAndCastedObj = getCostAndCastedObject(
+                        .getClass() : null;
+                WeightedCast weightedCast = getCostAndCastedObject(
                         suppliedParam, paramTypeClass);
+                methodCost += (Integer) costAndCastedObj[0];
+                if ((Integer) costAndCastedObj[0] < 0)
+                    break;
+                Object castedObj = paramTypeClass.isPrimitive() ? costAndCastedObj[1]
+                        : paramTypeClass.cast(costAndCastedObj[1]);
+                methodAndArgs[i + 1] = castedObj;
+                Class<?> castedObjClass = castedObj == null ? null : castedObj
+                        .getClass();
+                Boolean castedObjIsPrim = castedObj == null ? null : castedObj
+                        .getClass().isPrimitive();
+                if (debugging)
+                    System.out.println("Param " + i + " of method "
+                            + matchingMethod + " has cost "
+                            + (Integer) costAndCastedObj[0]
+                if (weightedCast == null) {
+                    continue methodLoop; // Cannot call this constructor!
+                }
+                methodCost += weightedCast.getCost();
+                Object castedObj = paramTypeClass.isPrimitive() ?
+                            weightedCast.getCastedObject()
+                          : paramTypeClass.cast(weightedCast.getCastedObject());
+                castedArgs[i] = castedObj;
+                if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+                    Class<?> castedObjClass = castedObj == null ? null : castedObj.getClass();
+                    boolean castedObjIsPrim = castedObj == null ? false : castedObj.getClass().isPrimitive();
+                    PluginDebug.debug("Param " + i + " of method " + candidate
+                            + " has cost " + weightedCast.getCost()
                             + " original param type " + suppliedParamClass
                             + " casted to " + castedObjClass + " isPrimitive="
                             + castedObjIsPrim + " value " + castedObj);
+            }
-            if ((methodCost > 0 && methodCost < lowestCost) ||
-                    paramTypes.length == 0) {
-                ret = methodAndArgs;
-                lowestCost = methodCost;
+            }
+        }
-        return ret;
+    }
-    public static Object[] getMatchingConstructor(Object[] callList) {
-        Object[] ret = null;
-        Class<?> c = (Class<?>) callList[0];
-        Constructor[] matchingConstructors = getMatchingConstructors(c, callList.length - 1);
-        if (debugging)
-            System.out.println("getMatchingConstructor called with: " + printList(callList));
-        int lowestCost = Integer.MAX_VALUE;
-        for (Constructor matchingConstructor : matchingConstructors) {
-            int constructorCost = 0;
-            Class<?>[] paramTypes = matchingConstructor.getParameterTypes();
-            Object[] constructorAndArgs = new Object[paramTypes.length + 1];
-            constructorAndArgs[0] = matchingConstructor;
-            // Figure out which of the matched methods best represents what we
-            // want
-            for (int i = 0; i < paramTypes.length; i++) {
-                Class<?> paramTypeClass = paramTypes[i];
-                Object suppliedParam = callList[i + 1];
-                Class suppliedParamClass = suppliedParam != null ? suppliedParam
-                        .getClass()
-                        : null;
-                Object[] costAndCastedObj = getCostAndCastedObject(
-                        suppliedParam, paramTypeClass);
-                constructorCost += (Integer) costAndCastedObj[0];
-                if ((Integer) costAndCastedObj[0] < 0)
-                    break;
-                Object castedObj = paramTypeClass.isPrimitive() ? costAndCastedObj[1]
-                        : paramTypeClass.cast(costAndCastedObj[1]);
-                constructorAndArgs[i + 1] = castedObj;
-                Class<?> castedObjClass = castedObj == null ? null : castedObj
-                        .getClass();
-                Boolean castedObjIsPrim = castedObj == null ? null : castedObj
-                        .getClass().isPrimitive();
-                if (debugging)
-                    System.out.println("Param " + i + " of constructor "
-                            + matchingConstructor + " has cost "
-                            + (Integer) costAndCastedObj[0]
-                            + " original param type " + suppliedParamClass
-                            + " casted to " + castedObjClass + " isPrimitive="
-                            + castedObjIsPrim + " value " + castedObj);
+            }
-            if ((constructorCost > 0 && constructorCost < lowestCost) ||
-                    paramTypes.length == 0) {
-                ret = constructorAndArgs;
-                lowestCost = constructorCost;
+            }
+        }
-        return ret;
+    }
-    public static Object[] getCostAndCastedObject(Object suppliedParam, Class<?> paramTypeClass) {
-        Object[] ret = new Object[2];
-        Integer cost = new Integer(0);
-        Object castedObj;
-        Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam.getClass() : null;
-        // Either both are an array, or neither are
-        boolean suppliedParamIsArray = suppliedParamClass != null && suppliedParamClass.isArray();
-        if (paramTypeClass.isArray() != suppliedParamIsArray &&
-                !paramTypeClass.equals(Object.class) &&
-                !paramTypeClass.equals(String.class)) {
-            ret[0] = Integer.MIN_VALUE; // Not allowed
-            ret[1] = suppliedParam;
-            return ret;
+        }
-        // If param type is an array, supplied obj must be an array, Object or String (guaranteed by checks above)
-        // If it is an array, we need to copy/cast as we scan the array
-        // If it an object, we return "as is" [Everything can be narrowed to an object, cost=6]
-        // If it is a string, we need to convert according to the JS engine rules
-        if (paramTypeClass.isArray()) {
-            Object newArray = Array.newInstance(paramTypeClass.getComponentType(), Array.getLength(suppliedParam));
-            for (int i = 0; i < Array.getLength(suppliedParam); i++) {
-                Object original = Array.get(suppliedParam, i);
-                // When dealing with arrays, we represent empty slots with
-                // null. We need to convert this to 0 before recursive
-                // calling, since normal transformation does not allow
-                // null -> primitive
-                if (original == null && paramTypeClass.getComponentType().isPrimitive())
-                    original = 0;
-                Object[] costAndCastedObject = getCostAndCastedObject(original, paramTypeClass.getComponentType());
-                if ((Integer) costAndCastedObject[0] < 0) {
-                    ret[0] = Integer.MIN_VALUE; // Not allowed
-                    ret[1] = suppliedParam;
-                    return ret;
+                }
+                Array.set(newArray, i, costAndCastedObject[1]);
+            }
+            ret[0] = 9;
+            ret[1] = newArray;
+            return ret;
+        }
+        if (suppliedParamIsArray && paramTypeClass.equals(String.class)) {
+            ret[0] = 9;
+            ret[1] = getArrayAsString(suppliedParam);
+            return ret;
+            }
+            if (methodCost <= lowestCost) {
+                if (methodCost < lowestCost
+                        || argumentsAreSubclassesOf(castedArgs, cheapestArgs)) {
+                    lowestCost = methodCost;
+                    cheapestArgs = castedArgs;
+                    cheapestMethod = candidate;
+                    ambiguous = false;
+                } else {
+                    ambiguous = true;
+                }
+            }
+        }
+        // The spec says we should error out if the method call is ambiguous
+        // Instead we will report it in debug output
+        if (ambiguous) {
+            PluginDebug.debug("*** Warning: Ambiguous overload of ", c.getClass(), "#", cheapestMethod, "!");
+        }
+        if (cheapestMethod == null) {
+            return null;
+        }
+        return new ResolvedMethod(lowestCost, cheapestMethod, cheapestArgs);
+    }
+    public static WeightedCast getCostAndCastedObject(Object suppliedParam,
+            Class<?> paramTypeClass) {
+        Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam
+                .getClass() : null;
+        boolean suppliedParamIsArray = suppliedParamClass != null
+                && suppliedParamClass.isArray();
+        if (suppliedParamIsArray) {
+            if (paramTypeClass.isArray()) {
+                return getArrayToArrayCastWeightedCost(suppliedParam,
+                        paramTypeClass);
+            }
+            // Target type must be an array, Object or String
+            // If it an object, we return "as is" [Everything can be narrowed to an
+            // object, cost=CLASS_SUPERCLASS_COST]
+            // If it is a string, we need to convert according to the JS engine
+            // rules
+            if (paramTypeClass != String.class
+                    && paramTypeClass != Object.class) {
+                return null;
+            }
+            if (paramTypeClass.equals(String.class)) {
+                return new WeightedCast(ARRAY_CAST_COST,
+                        arrayToJavascriptStyleString(suppliedParam));
+            }
+        }
         // If this is null, there are only 2 possible cases
         if (suppliedParamClass == null) {
-            castedObj = null; // if value is null.. well, it is null
             if (!paramTypeClass.isPrimitive()) {
+                cost += 2; // Null to any non-primitive type
+                return new WeightedCast(NULL_TO_OBJECT_COST, null); // Null to any non-primitive type
+            }
+            return null;// Null to primitive not allowed
+        }
+        // Numeric type to the analogous Java primitive type
+        if (paramTypeClass.isPrimitive()
+                && paramTypeClass == getPrimitiveType(suppliedParam.getClass())) {
+            return new WeightedCast(NUMERIC_SAME_COST, suppliedParam);
+        }
+        // Class type to Class type where the types are the same
+        if (suppliedParamClass == paramTypeClass) {
+            return new WeightedCast(CLASS_SAME_COST, suppliedParam);
+        }
+        // Numeric type to a different primitive type
+        boolean wrapsPrimitive = (getPrimitiveType(suppliedParam.getClass()) != null);
+        if (wrapsPrimitive && paramTypeClass.isPrimitive()) {
+            double val;
+            // Coerce booleans
+            if (suppliedParam.equals(Boolean.TRUE)) {
+                val = 1.0;
+            } else if (suppliedParam.equals(Boolean.FALSE)){
+                val = 0.0;
+            } else if (suppliedParam instanceof Character) {
+                val = (double)(Character)suppliedParam;
             } else {
+                cost = Integer.MIN_VALUE; // Null to primitive not allowed
+            }
+        } else if (paramTypeClass.isPrimitive() && paramTypeClass.equals(getPrimitive(suppliedParam))) {
+            cost += 1; // Numeric type to the analogous Java primitive type
+            castedObj = suppliedParam; // Let auto-boxing handle it
+        } else if (suppliedParamClass.equals(paramTypeClass)) {
+            cost += 3; // Class type to Class type where the types are equal
+            castedObj = suppliedParam;
+        } else if (isNum(suppliedParam) &&
+                       (paramTypeClass.isPrimitive() ||
+                               java.lang.Number.class.isAssignableFrom(paramTypeClass) ||
+                               java.lang.Character.class.isAssignableFrom(paramTypeClass) ||
+                        java.lang.Byte.class.isAssignableFrom(paramTypeClass)
+                       )) {
+            cost += 4; // Numeric type to a different primitive type
+            if (suppliedParam.toString().equals("true"))
+                suppliedParam = "1";
+            else if (suppliedParam.toString().equals("false"))
+                suppliedParam = "0";
+            if (paramTypeClass.equals(Boolean.TYPE))
+                castedObj = getNum(suppliedParam.toString(), paramTypeClass).doubleValue() != 0D;
+            else if (paramTypeClass.equals(Character.TYPE))
+                castedObj = (char) Short.decode(suppliedParam.toString()).shortValue();
+            else
+                castedObj = getNum(suppliedParam.toString(), paramTypeClass);
+        } else if (suppliedParam instanceof java.lang.String &&
+                    isNum(suppliedParam) &&
+                        (paramTypeClass.isInstance(java.lang.Number.class) ||
+                                paramTypeClass.isInstance(java.lang.Character.class) ||
+                                paramTypeClass.isInstance(java.lang.Byte.class) ||
+                         paramTypeClass.isPrimitive())) {
+            cost += 5; // String to numeric type
+            if (suppliedParam.toString().equals("true"))
+                suppliedParam = "1";
+            else if (suppliedParam.toString().equals("false"))
+                suppliedParam = "0";
+            if (paramTypeClass.equals(Character.TYPE))
+                castedObj = (char) Short.decode(suppliedParam.toString()).shortValue();
+            else
+                castedObj = getNum(suppliedParam.toString(), paramTypeClass);
+        } else if (suppliedParam instanceof java.lang.String &&
+                     (paramTypeClass.equals(java.lang.Boolean.class) ||
+                      paramTypeClass.equals(java.lang.Boolean.TYPE))) {
+            cost += 5; // Same cost as above
+            castedObj = new Boolean(suppliedParam.toString().length() > 0);
+        } else if (paramTypeClass.isAssignableFrom(suppliedParamClass)) {
+            cost += 6; // Class type to superclass type;
+            castedObj = paramTypeClass.cast(suppliedParam);
+        } else if (paramTypeClass.equals(String.class)) {
+            cost += 7; // Any Java value to String
+            castedObj = suppliedParam.toString();
+        } else if (suppliedParam instanceof JSObject &&
+                   paramTypeClass.isArray()) {
+            cost += 8; // JSObject to Java array
+            castedObj = (JSObject) suppliedParam;
+                val = ((Number)suppliedParam).doubleValue();
+            }
+            int castCost = NUMERIC_CAST_COST;
+            Object castedObj;
+            if (paramTypeClass.equals(Boolean.TYPE)) {
+                castedObj = (val != 0D && !Double.isNaN(val));
+                if (suppliedParam.getClass() != Boolean.class) {
+                    castCost = NUMERIC_BOOLEAN_COST;
+                }
+            } else {
+                castedObj = toBoxedPrimitiveType(val, paramTypeClass);
+            }
+            return new WeightedCast(castCost, castedObj);
+        }
+        // Numeric string to numeric type
+        if (isNumericString(suppliedParam) && paramTypeClass.isPrimitive()) {
+            Object castedObj;
+            if (paramTypeClass.equals(Character.TYPE)) {
+                castedObj = (char) Short.decode((String)suppliedParam).shortValue();
+            } else {
+                castedObj = stringAsPrimitiveType((String)suppliedParam, paramTypeClass);
+            }
+            return new WeightedCast(STRING_NUMERIC_CAST_COST, castedObj);
+        }
+        // Same cost as above
+        if (suppliedParam instanceof java.lang.String
+                && (paramTypeClass == java.lang.Boolean.class || paramTypeClass == java.lang.Boolean.TYPE)) {
+            return new WeightedCast(STRING_NUMERIC_CAST_COST, !suppliedParam.equals(""));
+        }
+        // Class type to superclass type;
+        if (paramTypeClass.isAssignableFrom(suppliedParamClass)) {
+            return new WeightedCast(CLASS_SUPERCLASS_COST, paramTypeClass.cast(suppliedParam));
+        }
+        // Any java value to String
+        if (paramTypeClass.equals(String.class)) {
+            return new WeightedCast(CLASS_STRING_COST, suppliedParam.toString());
+        }
+        return null;
+    }
+    private static WeightedCast getArrayToArrayCastWeightedCost(Object suppliedArray,
+            Class<?> paramTypeClass) {
+        int arrLength = Array.getLength(suppliedArray);
+        Class<?> arrType = paramTypeClass.getComponentType();
+        // If it is an array, we need to copy/cast as we scan the array
+        Object newArray = Array.newInstance(arrType, arrLength);
+        for (int i = 0; i < arrLength; i++) {
+            Object original = Array.get(suppliedArray, i);
+            // When dealing with arrays, we represent empty slots with
+            // null. We need to convert this to 0 before recursive
+            // calling, since normal transformation does not allow
+            // null -> primitive
+            if (original == null && arrType.isPrimitive()) {
+                original = 0;
+            }
+            WeightedCast costAndCastedObject = getCostAndCastedObject(original,
+                    paramTypeClass.getComponentType());
+            if (costAndCastedObject == null) {
+                return null;
+            }
+            Array.set(newArray, i, costAndCastedObject.getCastedObject());
+        }
+        return new WeightedCast(ARRAY_CAST_COST, newArray);
+    }
+    private static Method[] getMatchingMethods(Class<?> c, String name,
+            int paramCount) {
+        List<Method> matchingMethods = new ArrayList<Method>();
+        for (Method m : c.getMethods()) {
+            if (m.getName().equals(name)) {
+                if (m.getParameterTypes().length == paramCount) {
+                    matchingMethods.add(m);
+                }
+            }
+        }
+        return matchingMethods.toArray(new Method[0]);
+    }
+    private static Constructor<?>[] getMatchingConstructors(Class<?> c,
+            int paramCount) {
+        List<Constructor<?>> matchingConstructors = new ArrayList<Constructor<?>>();
+        for (Constructor<?> cs : c.getConstructors()) {
+            if (cs.getParameterTypes().length == paramCount) {
+                matchingConstructors.add(cs);
+            }
+        }
+        return matchingConstructors.toArray(new Constructor<?>[0]);
+    }
+    private static Class<?> getPrimitiveType(Class<?> c) {
+        if (c.isPrimitive()) {
+            return c;
+        }
+        if (c == Byte.class) {
+            return Byte.TYPE;
+        } else if (c == Character.class) {
+            return Character.TYPE;
+        } else if (c == Short.class) {
+            return Short.TYPE;
+        } else if (c == Integer.class) {
+            return Integer.TYPE;
+        } else if (c == Long.class) {
+            return Long.TYPE;
+        } else if (c == Float.class) {
+            return Float.TYPE;
+        } else if (c == Double.class) {
+            return Double.TYPE;
+        } else if (c == Boolean.class) {
+            return Boolean.TYPE;
         } else {
+            cost = Integer.MIN_VALUE; // Not allowed
+            castedObj = suppliedParam;
+        }
+        ret[0] = cost;
+        ret[1] = castedObj;
+        return ret;
+    }
+    private static Method[] getMatchingMethods(Class<?> c, String name, int paramCount) {
+        Method[] allMethods = c.getMethods();
+        ArrayList<Method> matchingMethods = new ArrayList<Method>(5);
+        for (Method m : allMethods) {
+            if (m.getName().equals(name) && m.getParameterTypes().length == paramCount)
+                matchingMethods.add(m);
+        }
+        return matchingMethods.toArray(new Method[0]);
+    }
+    private static Constructor[] getMatchingConstructors(Class<?> c, int paramCount) {
+        Constructor[] allConstructors = c.getConstructors();
+        ArrayList<Constructor> matchingConstructors = new ArrayList<Constructor>(5);
+        for (Constructor cs : allConstructors) {
+            if (cs.getParameterTypes().length == paramCount)
+                matchingConstructors.add(cs);
+        }
+        return matchingConstructors.toArray(new Constructor[0]);
+    }
+    private static Class getPrimitive(Object o) {
+        if (o instanceof java.lang.Byte) {
+            return java.lang.Byte.TYPE;
+        } else if (o instanceof java.lang.Character) {
+            return java.lang.Character.TYPE;
+        } else if (o instanceof java.lang.Short) {
+            return java.lang.Short.TYPE;
+        } else if (o instanceof java.lang.Integer) {
+            return java.lang.Integer.TYPE;
+        } else if (o instanceof java.lang.Long) {
+            return java.lang.Long.TYPE;
+        } else if (o instanceof java.lang.Float) {
+            return java.lang.Float.TYPE;
+        } else if (o instanceof java.lang.Double) {
+            return java.lang.Double.TYPE;
+        } else if (o instanceof java.lang.Boolean) {
+            return java.lang.Boolean.TYPE;
+        }
+        return o.getClass();
+    }
+    private static boolean isNum(Object o) {
+        if (o instanceof java.lang.Number)
+            return true;
+        // Boolean is changeable to number as well
+        if (o instanceof java.lang.Boolean)
+            return true;
+            return null;
+        }
+    }
+    private static boolean isNumericString(Object o) {
         // At this point, it _has_ to be a string else automatically
         // return false
         if (!(o instanceof java.lang.String))
+        if (!(o instanceof java.lang.String)) {
             return false;
+        }
         try {
 …
+    }
+    private static Number getNum(String s, Class<?> c) throws NumberFormatException {
+        Number n;
+        if (s.contains("."))
+            n = new Double(s);
+        else
+            n = new Long(s);
+    private static Object toBoxedPrimitiveType(double val, Class<?> c) {
+        Class<?> prim = getPrimitiveType(c);
         // See if we need to collapse first
+        if (c.equals(java.lang.Integer.class) ||
+                c.equals(java.lang.Integer.TYPE)) {
+            return n.intValue();
+        }
+        if (c.equals(java.lang.Long.class) ||
+                c.equals(java.lang.Long.TYPE)) {
+            return n.longValue();
+        }
+        if (c.equals(java.lang.Short.class) ||
+                c.equals(java.lang.Short.TYPE)) {
+            return n.shortValue();
+        }
+        if (c.equals(java.lang.Float.class) ||
+                c.equals(java.lang.Float.TYPE)) {
+            return n.floatValue();
+        }
+        if (c.equals(java.lang.Double.class) ||
+                c.equals(java.lang.Double.TYPE)) {
+            return n.doubleValue();
+        }
+        if (c.equals(java.lang.Byte.class) ||
+                c.equals(java.lang.Byte.TYPE)) {
+            return n.byteValue();
+        }
+        return n;
+    }
+    private static String printList(Object[] oList) {
+        String ret = "";
+        ret += "{ ";
+        for (Object o : oList) {
+            String oStr = o != null ? o.toString() + " [" + o.getClass() + "]" : "null";
+            ret += oStr;
+            ret += ", ";
+        }
+        ret = ret.substring(0, ret.length() - 2); // remove last ", "
+        ret += " }";
+        return ret;
+    }
+    private static String getArrayAsString(Object array) {
+        // We are guaranteed that supplied object is a String
+        String ret = new String();
+        for (int i = 0; i < Array.getLength(array); i++) {
+        if (prim == Integer.TYPE) {
+            return (int)val;
+        } else if (prim == Long.TYPE) {
+            return (long)val;
+        } else if (prim == Short.TYPE) {
+            return (short)val;
+        } else if (prim == Float.TYPE) {
+            return (float)val;
+        } else if (prim == Double.TYPE) {
+            return val;
+        } else if (prim == Byte.TYPE) {
+            return (byte)val;
+        } else if (prim == Character.TYPE) {
+            return (char)(short)val;
+        }
+        return val;
+    }
+    private static Object stringAsPrimitiveType(String s, Class<?> c)
+            throws NumberFormatException {
+        double val = Double.parseDouble(s);
+        return toBoxedPrimitiveType(val, c);
+    }
+    // Test whether we can get from 'args' to 'testArgs' only by using widening conversions,
+    // eg String -> Object
+    private static boolean argumentsAreSubclassesOf(Object[] args, Object[] testArgs) {
+        for (int i = 0; i < args.length; i++) {
+            if (!testArgs[i].getClass().isAssignableFrom(args[i].getClass())) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static Class<?>[] getParameterTypesFor(java.lang.reflect.AccessibleObject method) {
+        if (method instanceof Method) {
+            return ((Method)method).getParameterTypes();
+        } else /*m instanceof Constructor*/ {
+            return ((Constructor<?>)method).getParameterTypes();
+        }
+    }
+    private static String arrayToJavascriptStyleString(Object array) {
+        int arrLength = Array.getLength(array);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < arrLength; i++) {
             Object element = Array.get(array, i);
             if (element != null) {
                 if (element.getClass().isArray()) {
                     ret += getArrayAsString(element);
+                    sb.append(arrayToJavascriptStyleString(element));
                 } else {
                     ret += element;
+                    sb.append(element);
+                }
+            }
             ret += ",";
+            sb.append(',');
+        }
         // Trim the final ","
         if (ret.length() > 0) {
             ret = ret.substring(0, ret.length() - 1);
+        }
         return ret;
+        if (arrLength > 0) {
+            sb.setLength(sb.length() - 1);
+        }
+        return sb.toString();
+    }
+}
-/** Begin test classes **/
-class FooClass {
-    public FooClass() {
+    }
-    public FooClass(Boolean b, int i) {
+    }
-    public FooClass(Boolean b, Integer i) {
+    }
-    public FooClass(Boolean b, short s) {
+    }
-    public FooClass(String s, int i) {
+    }
-    public FooClass(String s, Integer i) {
+    }
-    public FooClass(java.lang.Number num) {
+    }
-    public FooClass(java.lang.Integer integer) {
+    }
-    public FooClass(long l) {
+    }
-    public FooClass(double d) {
+    }
-    public FooClass(float f) {
+    }
-    public FooClass(JSObject j) {
+    }
-    public FooClass(BarClass1 b) {
+    }
-    public FooClass(BarClass2 b) {
+    }
-    public FooClass(String s) {
+    }
-    public FooClass(byte b) {
+    }
-    public FooClass(String s, Float f) {
+    }
-    public FooClass(int i) {
+    }
-    public void FooClass() {
+    }
-    public void FooClass(boolean b) {
+    }
-    public void foo(Boolean b, int i) {
+    }
-    public void foo(Boolean b, Integer i) {
+    }
-    public void foo(Boolean b, short s) {
+    }
-    public void foo_string_int(String s, int i) {
+    }
-    public void foo_string_int(String s, Integer i) {
+    }
-    public void foo_jsobj(JSObject j) {
+    }
-    public void foo_jsobj(String s) {
+    }
-    public void foo_classtype(java.lang.Number num) {
+    }
-    public void foo_classtype(java.lang.Integer integer) {
+    }
-    public void foo_multiprim(int i) {
+    }
-    public void foo_multiprim(long l) {
+    }
-    public void foo_multiprim(float f) {
+    }
-    public void foo_multiprim(double d) {
+    }
-    public void foo_float(float f) {
+    }
-    public void foo_float(String s) {
+    }
-    public void foo_float(JSObject j) {
+    }
-    public void foo_class(BarClass1 b) {
+    }
-    public void foo_class(BarClass2 b) {
+    }
-    public void foo_strandbyteonly(String s) {
+    }
-    public void foo_strandbyteonly(byte b) {
+    }
-    public void foo_str_and_float(String s, Float f) {
+    }
-    public void foo_int_only(int i) {
+    }
-    public void foo_noargs() {
+    }
-    public void foo_boolonly(boolean b) {
+    }
+}
-class BarClass1 {
+}
-class BarClass2 extends BarClass1 {
+}
-class BarClass3 extends BarClass2 {
+}
-class JSObject {
+}

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java

-              r418
+              r429
 import java.security.ProtectionDomain;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
+import net.sourceforge.jnlp.DefaultLaunchHandler;
 import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.DefaultLaunchHandler;
+import net.sourceforge.jnlp.util.logging.OutputController;
+import netscape.javascript.JSObject;
 import netscape.javascript.JSObjectCreatePermission;
+import netscape.javascript.JSUtil;
 class Signature {
     private String signature;
     private int currentIndex;
     private List<Class> typeList;
+    private List<Class<?>> typeList;
     private static final char ARRAY = '[';
     private static final char OBJECT = 'L';
 …
         this.signature = signature;
         currentIndex = 0;
         typeList = new ArrayList<Class>(10);
+        typeList = new ArrayList<Class<?>>(10);
         String elem;
 …
             elem = nextTypeName();
             if (elem == null) // end of signature
+            if (elem == null) {
                 continue;
+            Class primitive = primitiveNameToType(elem);
+            if (primitive != null)
+            }
+            Class<?> primitive = primitiveNameToType(elem);
+            if (primitive != null) {
                 typeList.add(primitive);
+            }
             else {
                 int dimsize = 0;
 …
                         typeList.add(Array.newInstance(primitive, dims)
                                                                 .getClass());
                     } else
+                    } else {
                         typeList.add(Array.newInstance(
                                                                 getClass(arrayType, cl), dims).getClass());
+                    }
                 } else {
                     typeList.add(getClass(elem, cl));
 …
+    }
     public static Class getClass(String name, ClassLoader cl) {
         Class c = null;
+    public static Class<?> getClass(String name, ClassLoader cl) {
+        Class<?> c = null;
         try {
 …
+    }
     public static Class primitiveNameToType(String name) {
         if (name.equals("void"))
+    public static Class<?> primitiveNameToType(String name) {
+        if (name.equals("void")) {
             return Void.TYPE;
+        else if (name.equals("boolean"))
+        }
+        else if (name.equals("boolean")) {
             return Boolean.TYPE;
+        else if (name.equals("byte"))
+        }
+        else if (name.equals("byte")) {
             return Byte.TYPE;
+        else if (name.equals("char"))
+        }
+        else if (name.equals("char")) {
             return Character.TYPE;
+        else if (name.equals("short"))
+        }
+        else if (name.equals("short")) {
             return Short.TYPE;
+        else if (name.equals("int"))
+        }
+        else if (name.equals("int")) {
             return Integer.TYPE;
+        else if (name.equals("long"))
+        }
+        else if (name.equals("long")) {
             return Long.TYPE;
+        else if (name.equals("float"))
+        }
+        else if (name.equals("float")) {
             return Float.TYPE;
+        else if (name.equals("double"))
+        }
+        else if (name.equals("double")) {
             return Double.TYPE;
+        else
+        }
+        else {
             return null;
+    }
+    public Class[] getClassArray() {
+        return typeList.subList(0, typeList.size()).toArray(new Class[] {});
+        }
+    }
+    public Class<?>[] getClassArray() {
+        return typeList.subList(0, typeList.size()).toArray(new Class<?>[] {});
+    }
+}
 …
     int identifier = 0;
     public static PluginStreamHandler streamhandler;
+    private static PluginStreamHandler streamhandler;
     long startTime = 0;
+    public PluginAppletSecurityContext(int identifier) {
+    /* Package-private constructor that allows for bypassing security manager installation.
+     * This is useful for testing. Note that while the public constructor should be used otherwise,
+     * the security installation can't be bypassed if it has already occurred.*/
+    PluginAppletSecurityContext(int identifier, boolean ensureSecurityContext) {
         this.identifier = identifier;
+        // We need a security manager.. and since there is a good chance that
+        // an applet will be loaded at some point, we should make it the SM
+        // that JNLPRuntime will try to install
+        if (System.getSecurityManager() == null) {
+            JNLPRuntime.initialize(/* isApplication */false);
+            JNLPRuntime.setDefaultLaunchHandler(new DefaultLaunchHandler(System.err));
+        }
+        JNLPRuntime.disableExit();
+        if (ensureSecurityContext) {
+            // We need a security manager.. and since there is a good chance that
+            // an applet will be loaded at some point, we should make it the SM
+            // that JNLPRuntime will try to install
+            if (System.getSecurityManager() == null) {
+                JNLPRuntime.initialize(/* isApplication */false);
+                JNLPRuntime.setDefaultLaunchHandler(new DefaultLaunchHandler(OutputController.getLogger()));
+            }
+            JNLPRuntime.disableExit();
+        }
         URL u = null;
 …
             u = new URL("file://");
         } catch (Exception e) {
+            e.printStackTrace();
+        }
+        this.classLoaders.put(liveconnectLoader, u);
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
+        PluginAppletSecurityContext.classLoaders.put(liveconnectLoader, u);
+    }
+    public PluginAppletSecurityContext(int identifier) {
+        this(identifier, true);
+    }
     private static <V> V parseCall(String s, ClassLoader cl, Class<V> c) {
         if (c == Integer.class)
+        if (c == Integer.class) {
             return c.cast(new Integer(s));
+        else if (c == String.class)
+            return c.cast(new String(s));
+        else if (c == Signature.class)
+        }
+        else if (c == String.class) {
+            return c.cast(s);
+        }
+        else if (c == Signature.class) {
             return c.cast(new Signature(s, cl));
+        else
+        }
+        else {
             throw new RuntimeException("Unexpected call value.");
+    }
+    private Object parseArgs(String s, Class c) {
+        if (c == Boolean.TYPE || c == Boolean.class)
+            return new Boolean(s);
+        else if (c == Byte.TYPE || c == Byte.class)
+        }
+    }
+    private Object parseArgs(String s, Class<?> c) {
+        if (c == Boolean.TYPE || c == Boolean.class) {
+            return Boolean.valueOf(s);
+        }
+        else if (c == Byte.TYPE || c == Byte.class) {
             return new Byte(s);
+        }
         else if (c == Character.TYPE || c == Character.class) {
             String[] bytes = s.split("_");
 …
             int full = ((high << 8) & 0x0ff00) | (low & 0x0ff);
             return new Character((char) full);
         } else if (c == Short.TYPE || c == Short.class)
+        } else if (c == Short.TYPE || c == Short.class) {
             return new Short(s);
+        else if (c == Integer.TYPE || c == Integer.class)
+        }
+        else if (c == Integer.TYPE || c == Integer.class) {
             return new Integer(s);
+        else if (c == Long.TYPE || c == Long.class)
+        }
+        else if (c == Long.TYPE || c == Long.class) {
             return new Long(s);
+        else if (c == Float.TYPE || c == Float.class)
+        }
+        else if (c == Float.TYPE || c == Float.class) {
             return new Float(s);
+        else if (c == Double.TYPE || c == Double.class)
+        }
+        else if (c == Double.TYPE || c == Double.class) {
             return new Double(s);
+        else
+        }
+        else {
             return store.getObject(new Integer(s));
+        }
+    }
     public void associateSrc(ClassLoader cl, URL src) {
         PluginDebug.debug("Associating ", cl, " with ", src);
         this.classLoaders.put(cl, src);
+        PluginAppletSecurityContext.classLoaders.put(cl, src);
+    }
     public void associateInstance(Integer i, ClassLoader cl) {
         PluginDebug.debug("Associating ", cl, " with instance ", i);
         this.instanceClassLoaders.put(i, cl);
+        PluginAppletSecurityContext.instanceClassLoaders.put(i, cl);
+    }
 …
+    }
+    public static PluginStreamHandler getStreamhandler() {
+        return streamhandler;
+    }
     public static Map<String, String> getLoaderInfo() {
         Hashtable<String, String> map = new Hashtable<String, String>();
 …
+    }
+    private static long privilegedJSObjectUnbox(final JSObject js) {
+        return AccessController.doPrivileged(new PrivilegedAction<Long>() {
+            @Override
+            public Long run() {
+                return JSUtil.getJSObjectInternalReference(js);
+            }
+        });
+    }
+    /**
+     * Create a string that identifies a Java object precisely, for passing to
+     * Javascript.
+     *
+     * For builtin value types, a 'literalreturn' prefix is used and the object
+     * is passed with a string representation.
+     *
+     * For JSObject's, a 'jsobject' prefix is used and the object is passed
+     * with the JSObject's internal identifier.
+     *
+     * For other Java objects, an object store reference is used.
+     *
+     * @param obj the object for which to create an identifier
+     * @param type the type to use for representation decisions
+     * @param unboxPrimitives whether to treat boxed primitives as value types
+     * @return an identifier string
+     */
+    public String toObjectIDString(Object obj, Class<?> type, boolean unboxPrimitives) {
+        /* Void (can occur from declared return type), pass special "void" string: */
+        if (type == Void.TYPE) {
+            return "literalreturn void";
+        }
+        /* Null, pass special "null" string: */
+        if (obj == null) {
+            return "literalreturn null";
+        }
+        /* Primitive, accurately represented by its toString() form: */
+        boolean returnAsString = ( type == Boolean.TYPE
+                                || type == Byte.TYPE
+                                || type == Short.TYPE
+                                || type == Integer.TYPE
+                                || type == Long.TYPE );
+        if (unboxPrimitives) {
+            returnAsString = ( returnAsString
+                            || type == Boolean.class
+                            || type == Byte.class
+                            || type == Short.class
+                            || type == Integer.class
+                            || type == Long.class);
+        }
+        if (returnAsString) {
+            return "literalreturn " + obj.toString();
+        }
+        /* Floating point number, we ensure we give enough precision: */
+        if ( type == Float.TYPE || type == Double.TYPE ||
+                ( unboxPrimitives && (type == Float.class || type == Double.class) )) {
+            return "literalreturn " + String.format("%308.308e", obj);
+        }
+        /* Character that should be returned as number: */
+        if (type == Character.TYPE || (unboxPrimitives && type == Character.class)) {
+            return "literalreturn " + (int) (Character) obj;
+        }
+        /* JSObject, unwrap underlying Javascript reference: */
+        if (type == netscape.javascript.JSObject.class) {
+            long reference = privilegedJSObjectUnbox((JSObject)obj);
+            return "jsobject " + Long.toString(reference);
+        }
+        /* Other kind of object, track this object and return our reference: */
+        store.reference(obj);
+        return store.getIdentifier(obj).toString();
+    }
     public void handleMessage(int reference, String src, AccessControlContext callContext, String message) {
 …
         try {
             if (message.startsWith("FindClass")) {
                 ClassLoader cl = null;
                 Class c = null;
+                ClassLoader cl;
+                Class<?> c;
                 cl = liveconnectLoader;
                 String[] args = message.split(" ");
 …
                 } catch (ClassNotFoundException cnfe) {
                     cl = this.instanceClassLoaders.get(instance);
+                    cl = PluginAppletSecurityContext.instanceClassLoaders.get(instance);
                     PluginDebug.debug("Not found. Looking in ", cl);
 …
                 if (message.startsWith("GetStaticMethodID") ||
                                     methodName.equals("<init>") ||
+                                    methodName.equals("<clinit>"))
+                    c = (Class<?>) store.getObject(classID);
+                else
+                    c = store.getObject(classID).getClass();
+                Method m = null;
+                Constructor cs = null;
+                Object o = null;
+                                    methodName.equals("<clinit>")) {
+                                                c = (Class<?>) store.getObject(classID);
+                                            }
+                else {
+                                                c = store.getObject(classID).getClass();
+                                            }
+                Method m;
+                Constructor<?> cs;
+                Object o;
                 if (methodName.equals("<init>")
                                                 || methodName.equals("<clinit>")) {
 …
                 PluginDebug.debug("GetStaticFieldID/GetFieldID got class=", c.getName());
                 Field f = null;
+                Field f;
                 f = c.getField(fieldName);
 …
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                if (ret == null) {
+                    write(reference, "GetStaticField literalreturn null");
+                } else if (f.getType() == Boolean.TYPE
+                        || f.getType() == Byte.TYPE
+                        || f.getType() == Short.TYPE
+                        || f.getType() == Integer.TYPE
+                        || f.getType() == Long.TYPE) {
+                    write(reference, "GetStaticField literalreturn " + ret);
+                } else if (f.getType() == Float.TYPE
+                                || f.getType() == Double.TYPE) {
+                    write(reference, "GetStaticField literalreturn " + String.format("%308.308e", ret));
+                } else if (f.getType() == Character.TYPE) {
+                    write(reference, "GetStaticField literalreturn " + (int) (Character) ret);
+                } else {
+                    // Track returned object.
+                    store.reference(ret);
+                    write(reference, "GetStaticField " + store.getIdentifier(ret));
+                }
+                }
+                String objIDStr = toObjectIDString(ret, f.getType(), false /*do not unbox primitives*/);
+                write(reference, "GetStaticField " + objIDStr);
             } else if (message.startsWith("GetValue")) {
                 String[] args = message.split(" ");
 …
                 Object ret = store.getObject(index);
+                if (ret == null) {
+                    write(reference, "GetValue literalreturn null");
+                } else if (ret.getClass() == Boolean.TYPE
+                        || ret.getClass() == Boolean.class
+                        || ret.getClass() == Byte.TYPE
+                        || ret.getClass() == Byte.class
+                        || ret.getClass() == Short.TYPE
+                        || ret.getClass() == Short.class
+                        || ret.getClass() == Integer.TYPE
+                        || ret.getClass() == Integer.class
+                        || ret.getClass() == Long.TYPE
+                        || ret.getClass() == Long.class) {
+                    write(reference, "GetValue literalreturn " + ret);
+                } else if (ret.getClass() == Float.TYPE
+                        || ret.getClass() == Float.class
+                        || ret.getClass() == Double.TYPE
+                        || ret.getClass() == Double.class) {
+                    write(reference, "GetValue literalreturn " + String.format("%308.308e", ret));
+                } else if (ret.getClass() == Character.TYPE
+                        || ret.getClass() == Character.class) {
+                    write(reference, "GetValue literalreturn " + (int) (Character) ret);
+                } else {
+                    // Track returned object.
+                    store.reference(ret);
+                    write(reference, "GetValue " + store.getIdentifier(ret));
+                }
+                Class<?> retClass = ret != null ? ret.getClass() : null;
+                String objIDStr = toObjectIDString(ret, retClass, true /*unbox primitives*/);
+                write(reference, "GetValue " + objIDStr);
             } else if (message.startsWith("SetStaticField") ||
                                    message.startsWith("SetField")) {
 …
                 final Field f = (Field) store.getObject(fieldID);
                 final Object fValue = MethodOverloadResolver.getCostAndCastedObject(value, f.getType())[1];
+                final Object fValue = MethodOverloadResolver.getCostAndCastedObject(value, f.getType()).getCastedObject();
                 AccessControlContext acc = callContext != null ? callContext : getClosedAccessControlContext();
+                checkPermission(src,
+                                                message.startsWith("SetStaticField") ? (Class) o : o.getClass(),
+                                                acc);
+                checkPermission(src, message.startsWith("SetStaticField") ? (Class) o : o.getClass(), acc);
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                }
                 write(reference, "SetField");
 …
                 Integer index = parseCall(args[2], null, Integer.class);
+                Object ret = Array.get(store.getObject(arrayID), index);
+                Class retClass = store.getObject(arrayID).getClass().getComponentType(); // prevent auto-boxing influence
+                if (ret == null) {
+                    write(reference, "GetObjectArrayElement literalreturn null");
+                } else if (retClass == Boolean.TYPE
+                        || retClass == Byte.TYPE
+                        || retClass == Short.TYPE
+                        || retClass == Integer.TYPE
+                        || retClass == Long.TYPE) {
+                    write(reference, "GetObjectArrayElement literalreturn " + ret);
+                } else if (retClass == Float.TYPE
+                                || retClass == Double.TYPE) {
+                    write(reference, "GetObjectArrayElement literalreturn " + String.format("%308.308e", ret));
+                } else if (retClass == Character.TYPE) {
+                    write(reference, "GetObjectArrayElement literalreturn " + (int) (Character) ret);
+                } else {
+                    // Track returned object.
+                    store.reference(ret);
+                    write(reference, "GetObjectArrayElement " + store.getIdentifier(ret));
+                }
+                Object array = store.getObject(arrayID);
+                Object ret = Array.get(array, index);
+                Class<?> retClass = array.getClass().getComponentType(); // prevent auto-boxing influence
+                String objIDStr = toObjectIDString(ret, retClass, false /*do not unbox primitives*/);
+                write(reference, "GetObjectArrayElement " + objIDStr);
             } else if (message.startsWith("SetObjectArrayElement")) {
 …
                 // Cast the object to appropriate type before insertion
                 value = MethodOverloadResolver.getCostAndCastedObject(value, store.getObject(arrayID).getClass().getComponentType())[1];
+                value = MethodOverloadResolver.getCostAndCastedObject(value, store.getObject(arrayID).getClass().getComponentType()).getCastedObject();
                 Array.set(store.getObject(arrayID), index, value);
 …
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                if (ret == null) {
+                    write(reference, "GetField literalreturn null");
+                } else if (f.getType() == Boolean.TYPE
+                        || f.getType() == Byte.TYPE
+                        || f.getType() == Short.TYPE
+                        || f.getType() == Integer.TYPE
+                        || f.getType() == Long.TYPE) {
+                    write(reference, "GetField literalreturn " + ret);
+                } else if (f.getType() == Float.TYPE
+                                || f.getType() == Double.TYPE) {
+                    write(reference, "GetField literalreturn " + String.format("%308.308e", ret));
+                } else if (f.getType() == Character.TYPE) {
+                    write(reference, "GetField literalreturn " + (int) (Character) ret);
+                } else {
+                    // Track returned object.
+                    store.reference(ret);
+                    write(reference, "GetField " + store.getIdentifier(ret));
+                }
+                }
+                String objIDStr = toObjectIDString(ret, f.getType(), false /*do not unbox primitives*/);
+                write(reference, "GetField " + objIDStr);
             } else if (message.startsWith("GetObjectClass")) {
                 int oid = Integer.parseInt(message.substring("GetObjectClass"
 …
+                }
+                // length -3 to discard first 3, + 2 for holding object
+                // and method name
+                Object[] arguments = new Object[args.length - 1];
+                arguments[0] = c;
+                arguments[1] = methodName;
+                for (int i = 0; i < args.length - 3; i++) {
+                    arguments[i + 2] = store.getObject(parseCall(args[3 + i], null, Integer.class));
+                    PluginDebug.debug("GOT ARG: ", arguments[i + 2]);
+                }
+                Object[] matchingMethodAndArgs = MethodOverloadResolver.getMatchingMethod(arguments);
+                if (matchingMethodAndArgs == null) {
+                // Discard first 3 parts of message
+                Object[] arguments = new Object[args.length - 3];
+                for (int i = 0; i < arguments.length; i++) {
+                    arguments[i] = store.getObject(parseCall(args[3 + i], null, Integer.class));
+                    PluginDebug.debug("GOT ARG: ", arguments[i]);
+                }
+                MethodOverloadResolver.ResolvedMethod rm =
+                        MethodOverloadResolver.getBestMatchMethod(c, methodName, arguments);
+                if (rm == null) {
                     write(reference, "Error: No suitable method named " + methodName + " with matching args found");
                     return;
+                }
+                final Method m = (Method) matchingMethodAndArgs[0];
+                Object[] castedArgs = new Object[matchingMethodAndArgs.length - 1];
+                for (int i = 0; i < castedArgs.length; i++) {
+                    castedArgs[i] = matchingMethodAndArgs[i + 1];
+                }
+                String collapsedArgs = "";
+                for (Object arg : castedArgs) {
+                    collapsedArgs += " " + arg;
+                }
+                final Method m = rm.getMethod();
+                final Object[] castedArgs = rm.getCastedParameters();
                 PluginDebug.debug("Calling method ", m, " on object ", o
                                                 , " (", c, ") with ", collapsedArgs);
+                                                , " (", c, ") with ", Arrays.toString(castedArgs));
                 AccessControlContext acc = callContext != null ? callContext : getClosedAccessControlContext();
 …
                 m.setAccessible(true);
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                 }
                 String retO;
 …
+                }
+                PluginDebug.debug("Calling ", m, " on ", o, " with "
+                                                , collapsedArgs, " and that returned: ", ret
+                                                , " of type ", retO);
+                if (m.getReturnType().equals(java.lang.Void.class) ||
+                                    m.getReturnType().equals(java.lang.Void.TYPE)) {
+                    write(reference, "CallMethod literalreturn void");
+                } else if (ret == null) {
+                    write(reference, "CallMethod literalreturn null");
+                } else if (m.getReturnType() == Boolean.TYPE
+                                                || m.getReturnType() == Byte.TYPE
+                                                || m.getReturnType() == Short.TYPE
+                                                || m.getReturnType() == Integer.TYPE
+                                                || m.getReturnType() == Long.TYPE) {
+                    write(reference, "CallMethod literalreturn " + ret);
+                } else if (m.getReturnType() == Float.TYPE
+                                || m.getReturnType() == Double.TYPE) {
+                    write(reference, "CallMethod literalreturn " + String.format("%308.308e", ret));
+                } else if (m.getReturnType() == Character.TYPE) {
+                    write(reference, "CallMethod literalreturn " + (int) (Character) ret);
+                } else {
+                    // Track returned object.
+                    store.reference(ret);
+                    write(reference, "CallMethod " + store.getIdentifier(ret));
+                }
+                PluginDebug.debug("Calling ", m, " on ", o, " with ",
+                        Arrays.toString(castedArgs), " and that returned: ", ret,
+                        " of type ", retO);
+                String objIDStr = toObjectIDString(ret, m.getReturnType(), false /*do not unbox primitives*/);
+                write(reference, "CallMethod " + objIDStr);
             } else if (message.startsWith("GetSuperclass")) {
                 String[] args = message.split(" ");
                 Integer classID = parseCall(args[1], null, Integer.class);
                 Class<?> c = null;
                 Class<?> ret = null;
+                Class<?> c;
+                Class<?> ret;
                 c = (Class) store.getObject(classID);
 …
                 Integer stringID = parseCall(args[1], null, Integer.class);
                 String o = null;
+                String o;
                 byte[] b = null;
                 o = (String) store.getObject(stringID);
 …
                 Integer stringID = parseCall(args[1], null, Integer.class);
                 String o = null;
+                String o;
                 byte[] b = null;
                 o = (String) store.getObject(stringID);
 …
                 Integer stringID = parseCall(args[1], null, Integer.class);
                 String o = null;
+                String o;
                 byte[] b = null;
                 StringBuffer buf = null;
 …
                 buf = new StringBuffer(b.length * 2);
                 buf.append(b.length);
+                for (int i = 0; i < b.length; i++)
+                    buf
+                                                        .append(" "
+                                                                        + Integer
+                                                                                        .toString(((int) b[i]) & 0x0ff, 16));
+                for (int i = 0; i < b.length; i++) {
+                    buf.append(" " + Integer.toString(((int) b[i]) & 0x0ff, 16));
+                }
                 write(reference, "GetStringUTFChars " + buf);
 …
                 Integer stringID = parseCall(args[1], null, Integer.class);
                 String o = null;
+                String o;
                 byte[] b = null;
                 StringBuffer buf = null;
 …
                 buf = new StringBuffer(b.length * 2);
                 buf.append(b.length);
+                for (int i = 0; i < b.length; i++)
+                    buf
+                                                        .append(" "
+                                                                        + Integer
+                                                                                        .toString(((int) b[i]) & 0x0ff, 16));
+                for (int i = 0; i < b.length; i++) {
+                    buf.append(" " + Integer.toString(((int) b[i]) & 0x0ff, 16));
+                }
                 PluginDebug.debug("Java: GetStringChars: ", o);
 …
                 Integer objectID = parseCall(args[1], null, Integer.class);
                 String o = null;
+                String o;
                 byte[] b = null;
                 StringBuffer buf = null;
 …
                 buf = new StringBuffer(b.length * 2);
                 buf.append(b.length);
+                for (int i = 0; i < b.length; i++)
+                    buf
+                            .append(" "
+                                    + Integer
+                                            .toString(((int) b[i]) & 0x0ff, 16));
+                for (int i = 0; i < b.length; i++) {
+                    buf.append(" " + Integer.toString(((int) b[i]) & 0x0ff, 16));
+                }
                 write(reference, "GetToStringValue " + buf);
 …
                 Integer length = parseCall(args[2], null, Integer.class);
                 Object newArray = null;
                 Class c;
+                Object newArray;
+                Class<?> c;
                 if (type.equals("bool")) {
                     c = Boolean.class;
 …
+                }
                 if (args.length > 3)
+                if (args.length > 3) {
                     newArray = Array.newInstance(c, new int[] { length, parseCall(args[3], null, Integer.class) });
+                else
+                }
+                else {
                     newArray = Array.newInstance(c, length);
+                }
                 store.reference(newArray);
 …
                 Integer methodNameID = parseCall(args[2], null, Integer.class);
                 Class c = (Class<?>) store.getObject(classNameID);
+                Class<?> c = (Class<?>) store.getObject(classNameID);
                 String methodName = (String) store.getObject(methodNameID);
 …
                 Integer fieldNameID = parseCall(args[2], null, Integer.class);
                 Class c = (Class) store.getObject(classNameID);
+                Class<?> c = (Class<?>) store.getObject(classNameID);
                 String fieldName = (String) store.getObject(fieldNameID);
 …
                 Integer objectID = parseCall(args[3], null, Integer.class);
                 Object newArray = null;
+                Object newArray;
                 newArray = Array.newInstance((Class) store.getObject(classID),
                                                 length);
                 Object[] array = (Object[]) newArray;
                 for (int i = 0; i < array.length; i++)
+                for (int i = 0; i < array.length; i++) {
                     array[i] = store.getObject(objectID);
+                }
                 store.reference(newArray);
                 write(reference, "NewObjectArray "
 …
                 Integer methodID = parseCall(args[2], null, Integer.class);
                 final Constructor m = (Constructor) store.getObject(methodID);
+                final Constructor<?> m = (Constructor<?>) store.getObject(methodID);
                 Class[] argTypes = m.getParameterTypes();
 …
                 AccessControlContext acc = callContext != null ? callContext : getClosedAccessControlContext();
                 Class c = (Class) store.getObject(classID);
+                Class<?> c = (Class<?>) store.getObject(classID);
                 checkPermission(src, c, acc);
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                }
                 store.reference(ret);
 …
                 String[] args = message.split(" ");
                 Integer classID = parseCall(args[1], null, Integer.class);
+                Class c = (Class) store.getObject(classID);
+                final Constructor cons;
+                final Object[] fArguments;
+                Object[] arguments = new Object[args.length - 1];
+                arguments[0] = c;
+                for (int i = 0; i < args.length - 2; i++) {
+                    arguments[i + 1] = store.getObject(parseCall(args[2 + i],
+                Class<?> c = (Class<?>) store.getObject(classID);
+                // Discard first 2 parts of message
+                Object[] arguments = new Object[args.length - 2];
+                for (int i = 0; i < arguments.length; i++) {
+                    arguments[i] = store.getObject(parseCall(args[2 + i],
                             null, Integer.class));
                     PluginDebug.debug("GOT ARG: ", arguments[i + 1]);
+                }
                 Object[] matchingConstructorAndArgs = MethodOverloadResolver
                         .getMatchingConstructor(arguments);
                 if (matchingConstructorAndArgs == null) {
+                    PluginDebug.debug("GOT ARG: ", arguments[i]);
+                }
+                MethodOverloadResolver.ResolvedMethod resolvedConstructor =
+                        MethodOverloadResolver.getBestMatchConstructor(c, arguments);
+                if (resolvedConstructor == null) {
                     write(reference,
                             "Error: No suitable constructor with matching args found");
 …
+                }
+                Object[] castedArgs = new Object[matchingConstructorAndArgs.length - 1];
+                for (int i = 0; i < castedArgs.length; i++) {
+                    castedArgs[i] = matchingConstructorAndArgs[i + 1];
+                }
+                cons = (Constructor) matchingConstructorAndArgs[0];
+                fArguments = castedArgs;
+                String collapsedArgs = "";
+                for (Object arg : fArguments) {
+                    collapsedArgs += " " + arg.toString();
+                }
+                final Constructor<?> cons = resolvedConstructor.getConstructor();
+                final Object[] castedArgs = resolvedConstructor.getCastedParameters();
                 PluginDebug.debug("Calling constructor on class ", c,
                                    " with ", collapsedArgs);
+                                   " with ", Arrays.toString(castedArgs));
                 AccessControlContext acc = callContext != null ? callContext : getClosedAccessControlContext();
 …
                 Object ret = AccessController.doPrivileged(new PrivilegedAction<Object>() {
+                    @Override
                     public Object run() {
                         try {
                             return cons.newInstance(fArguments);
+                            return cons.newInstance(castedArgs);
                         } catch (Throwable t) {
                             return t;
 …
                 }, acc);
                 if (ret instanceof Throwable)
+                if (ret instanceof Throwable) {
                     throw (Throwable) ret;
+                }
                 store.reference(ret);
 …
                 int bytelength = 2 * strlength;
                 byte[] byteArray = new byte[bytelength];
                 String ret = null;
+                String ret;
                 for (int i = 0; i < strlength; i++) {
                     int c = parseCall(args[2 + i], null, Integer.class);
 …
             } else if (message.startsWith("ExceptionOccurred")) {
                 PluginDebug.debug("EXCEPTION: ", throwable);
                 if (throwable != null)
+                if (throwable != null) {
                     store.reference(throwable);
+                }
                 write(reference, "ExceptionOccurred "
                                                 + store.getIdentifier(throwable));
             } else if (message.startsWith("ExceptionClear")) {
                 if (throwable != null && store.contains(throwable))
+                if (throwable != null && store.contains(throwable)) {
                     store.unreference(store.getIdentifier(throwable));
+                }
                 throwable = null;
                 write(reference, "ExceptionClear");
 …
+            }
         } catch (Throwable t) {
             t.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,t);
             String msg = t.getCause() != null ? t.getCause().getMessage() : t.getMessage();
 …
             // the exception we get here will always be an
             // "InvocationTargetException" due to the use of reflection above
             if (message.startsWith("CallMethod") || message.startsWith("CallStaticMethod"))
+            if (message.startsWith("CallMethod") || message.startsWith("CallStaticMethod")) {
                 throwable = t.getCause();
+            }
+        }
 …
      * @throws AccessControlException If the script has insufficient permissions
      */
     public void checkPermission(String jsSrc, Class target, AccessControlContext acc) throws AccessControlException {
+    public void checkPermission(String jsSrc, Class<?> target, AccessControlContext acc) throws AccessControlException {
         // NPRuntime does not allow cross-site calling. We therefore always
         // allow this, for the time being
 …
         name = name.replace('/', '.');
         ClassLoader cl = liveconnectLoader;
         Class c = null;
+        Class<?> c = null;
         try {
 …
         } catch (ClassNotFoundException cnfe) {
             // do nothing ... this should never happen
             cnfe.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,cnfe);
+        }
 …
         Class<?> c = (Class<?>) store.getObject(classID);
         Method m = null;
         Constructor cs = null;
+        Constructor<?> cs = null;
         try {
 …
         } catch (NoSuchMethodException e) {
             // should never happen
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
 …
         } catch (SecurityException e) {
             // should never happen
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
         } catch (NoSuchFieldException e) {
             // should never happen
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
 …
+            }
             if (src.equals("[System]"))
+            if (src.equals("[System]")) {
                 grantedPermissions.add(new JSObjectCreatePermission());
+            }
         } else {

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginAppletViewer.java

-              r418
+              r429
 package sun.applet;
+import static net.sourceforge.jnlp.runtime.Translator.R;
 import java.applet.Applet;
 import java.applet.AppletContext;
 import java.applet.AudioClip;
+import java.awt.BorderLayout;
+import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.Frame;
 …
 import java.awt.Image;
 import java.awt.Insets;
-import java.awt.Toolkit;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 …
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.PrintStream;
-import java.io.Reader;
-import java.io.StringReader;
 import java.io.UnsupportedEncodingException;
-import java.lang.reflect.InvocationTargetException;
 import java.net.SocketPermission;
 import java.net.URI;
 import java.net.URL;
+import java.net.URLConnection;
 import java.security.AccessController;
 import java.security.AllPermission;
 import java.security.PrivilegedAction;
-import java.security.PrivilegedActionException;
-import java.security.PrivilegedExceptionAction;
 import java.util.Enumeration;
 import java.util.HashMap;
 …
 import java.util.Map;
 import java.util.Vector;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 …
 import javax.swing.SwingUtilities;
+import net.sourceforge.jnlp.LaunchException;
 import net.sourceforge.jnlp.NetxPanel;
+import net.sourceforge.jnlp.PluginParameters;
 import net.sourceforge.jnlp.runtime.JNLPClassLoader;
+import net.sourceforge.jnlp.security.appletextendedsecurity.AppletSecurityLevel;
+import net.sourceforge.jnlp.security.appletextendedsecurity.AppletStartupSecuritySettings;
+import net.sourceforge.jnlp.splashscreen.SplashController;
+import net.sourceforge.jnlp.splashscreen.SplashPanel;
+import net.sourceforge.jnlp.splashscreen.SplashUtils;
 import sun.awt.AppContext;
 import sun.awt.SunToolkit;
 …
 import com.sun.jndi.toolkit.url.UrlUtil;
+/**
+ * Lets us construct one using unix-style one shot behaviors
+ */
+class PluginAppletPanelFactory {
+    public AppletPanel createPanel(PluginStreamHandler streamhandler,
+                                   final int identifier,
+                                   final long handle, int x, int y,
+                                   final URL doc,
+                                   final Hashtable<String, String> atts) {
+        final NetxPanel panel = AccessController.doPrivileged(new PrivilegedAction<NetxPanel>() {
+            public NetxPanel run() {
+                NetxPanel panel = new NetxPanel(doc, atts, false);
+                NetxPanel.debug("Using NetX panel");
+                PluginDebug.debug(atts.toString());
+                return panel;
+            }
+        });
+        // Framing the panel needs to happen in a thread whose thread group
+        // is the same as the threadgroup of the applet thread. If this
+        // isn't the case, the awt eventqueue thread's context classloader
+        // won't be set to a JNLPClassLoader, and when an applet class needs
+        // to be loaded from the awt eventqueue, it won't be found.
+        Thread panelInit = new Thread(panel.getThreadGroup(), new Runnable() {
+            @Override public void run() {
+                panel.createNewAppContext();
+                // create the frame.
+                PluginAppletViewer.framePanel(identifier, handle, panel);
+                panel.init();
+                // Start the applet
+                initEventQueue(panel);
+            }
+        }, "NetXPanel initializer");
+        panelInit.start();
+        while(panelInit.isAlive()) {
+            try {
+                panelInit.join();
+            } catch (InterruptedException e) {
+            }
+        }
+        // Wait for the panel to initialize
+        PluginAppletViewer.waitForAppletInit(panel);
+        Applet a = panel.getApplet();
+        // Still null?
+        if (a == null) {
+            streamhandler.write("instance " + identifier + " reference " + -1 + " fatalError: " + "Initialization timed out");
+            return null;
+        }
+        PluginDebug.debug("Applet ", a.getClass(), " initialized");
+        streamhandler.write("instance " + identifier + " reference 0 initialized");
+        /* AppletViewerPanel sometimes doesn't set size right initially. This
+         * causes the parent frame to be the default (10x10) size.
+         *
+         * Normally it goes unnoticed since browsers like Firefox make a resize
+         * call after init. However some browsers (e.g. Midori) don't.
+         *
+         * We therefore manually set the parent to the right size.
+         */
+        try {
+            SwingUtilities.invokeAndWait(new Runnable() {
+                public void run() {
+                    panel.getParent().setSize(Integer.valueOf(atts.get("width")), Integer.valueOf(atts.get("height")));
+                }
+            });
+        } catch (InvocationTargetException ite) {
+            // Not being able to resize is non-fatal
+            PluginDebug.debug("Unable to resize panel: ");
+            ite.printStackTrace();
+        } catch (InterruptedException ie) {
+            // Not being able to resize is non-fatal
+            PluginDebug.debug("Unable to resize panel: ");
+            ie.printStackTrace();
+        }
+        AppletSecurityContextManager.getSecurityContext(0).associateSrc(panel.getAppletClassLoader(), doc);
+        AppletSecurityContextManager.getSecurityContext(0).associateInstance(identifier, panel.getAppletClassLoader());
+        return panel;
+    }
+    public boolean isStandalone() {
+        return false;
+    }
+    /**
+     * Send the initial set of events to the appletviewer event queue.
+     * On start-up the current behaviour is to load the applet and call
+     * Applet.init() and Applet.start().
+     */
+    private void initEventQueue(AppletPanel panel) {
+        // appletviewer.send.event is an undocumented and unsupported system
+        // property which is used exclusively for testing purposes.
+        PrivilegedAction<String> pa = new PrivilegedAction<String>() {
+            public String run() {
+                return System.getProperty("appletviewer.send.event");
+            }
+        };
+        String eventList = AccessController.doPrivileged(pa);
+        if (eventList == null) {
+            // Add the standard events onto the event queue.
+            panel.sendEvent(AppletPanel.APPLET_LOAD);
+            panel.sendEvent(AppletPanel.APPLET_INIT);
+            panel.sendEvent(AppletPanel.APPLET_START);
+        } else {
+            // We're testing AppletViewer.  Force the specified set of events
+            // onto the event queue, wait for the events to be processed, and
+            // exit.
+            // The list of events that will be executed is provided as a
+            // ","-separated list.  No error-checking will be done on the list.
+            String[] events = eventList.split(",");
+            for (String event : events) {
+                PluginDebug.debug("Adding event to queue: ", event);
+                if ("dispose".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_DISPOSE);
+                else if ("load".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_LOAD);
+                else if ("init".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_INIT);
+                else if ("start".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_START);
+                else if ("stop".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_STOP);
+                else if ("destroy".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_DESTROY);
+                else if ("quit".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_QUIT);
+                else if ("error".equals(event))
+                    panel.sendEvent(AppletPanel.APPLET_ERROR);
+                else
+                    // non-fatal error if we get an unrecognized event
+                    PluginDebug.debug("Unrecognized event name: ", event);
+            }
+            while (!panel.emptyEventQueue())
+                ;
+        }
+    }
+}
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.util.logging.OutputController;
 /*
 …
 @SuppressWarnings("serial")
 public class PluginAppletViewer extends PluginAppletViewerBase
         implements AppletContext, Printable {
+        implements AppletContext, Printable, SplashController {
     /**
 …
     private Graphics bufFrameImgGraphics;
+    private SplashPanel splashPanel;
+    private static long REQUEST_TIMEOUT=60000;//60s
+    private static void waitForRequestCompletion(PluginCallRequest request) {
+        try {
+            if (!request.isDone()) {
+                request.wait(REQUEST_TIMEOUT);
+            }
+            if (!request.isDone()) {
+                // Do not wait indefinitely to avoid the potential of deadlock
+                throw new RuntimeException("Possible deadlock, releasing");
+            }
+        } catch (InterruptedException ex) {
+            throw new RuntimeException("Interrupted waiting for call request.", ex);
+        }
+    }
     /**
      * Null constructor to allow instantiation via newInstance()
 …
+    }
     public static void framePanel(int identifier, long handle, NetxPanel panel) {
+    public static PluginAppletViewer framePanel(int identifier, long handle, int width, int height, NetxPanel panel) {
         PluginDebug.debug("Framing ", panel);
         // SecurityManager MUST be set, and only privileged code may call reFrame()
+        // SecurityManager MUST be set, and only privileged code may call framePanel()
         System.getSecurityManager().checkPermission(new AllPermission());
         PluginAppletViewer appletFrame = new PluginAppletViewer(handle, identifier, panel);
+        appletFrame.add("Center", panel);
+        appletFrame.pack();
+        appletFrame.setSize(width, height);
         appletFrame.appletEventListener = new AppletEventListener(appletFrame, appletFrame);
         panel.addAppletListener(appletFrame.appletEventListener);
+         // Clear references, if any
+        if (applets.containsKey(identifier)) {
+            PluginAppletViewer oldFrame = applets.get(identifier);
+            oldFrame.remove(panel);
+            panel.removeAppletListener(oldFrame.appletEventListener);
+        }
         appletsLock.lock();
 …
         PluginDebug.debug(panel, " framed");
+        return appletFrame;
+    }
 …
         windowEventListener = new WindowAdapter() {
+            @Override
             public void windowClosing(WindowEvent evt) {
                 destroyApplet(identifier);
+            }
+            @Override
             public void windowIconified(WindowEvent evt) {
                 appletStop();
+            }
+            @Override
             public void windowDeiconified(WindowEvent evt) {
                 appletStart();
 …
         addWindowListener(windowEventListener);
+        final AppletPanel fPanel = panel;
+        try {
+            SwingUtilities.invokeAndWait(new SplashCreator(fPanel));
+        } catch (Exception e) {
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e); // Not much we can do other than  print
+        }
+    }
+    @Override
+    public void replaceSplash(final SplashPanel newSplash) {
+        if (splashPanel == null) {
+            return;
+        }
+        if (newSplash == null) {
+            removeSplash();
+            return;
+        }
+        try {
+            SwingUtilities.invokeAndWait(new Runnable() {
+                @Override
+                public void run() {
+                    splashPanel.getSplashComponent().setVisible(false);
+                    splashPanel.stopAnimation();
+                    remove(splashPanel.getSplashComponent());
+                    newSplash.setPercentage(splashPanel.getPercentage());
+                    newSplash.setSplashWidth(splashPanel.getSplashWidth());
+                    newSplash.setSplashHeight(splashPanel.getSplashHeight());
+                    newSplash.adjustForSize();
+                    splashPanel = newSplash;
+                    add("Center", splashPanel.getSplashComponent());
+                    pack();
+                }
+            });
+        } catch (Exception e) {
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e); // Not much we can do other than print
+        }
+    }
+    @Override
+    public void removeSplash() {
+        if (splashPanel == null) {
+            return;
+        }
+        try {
+            SwingUtilities.invokeAndWait(new Runnable() {
+                @Override
+                public void run() {
+                    splashPanel.getSplashComponent().setVisible(false);
+                    splashPanel.stopAnimation();
+                    removeAll();
+                    setLayout(new BorderLayout());
+                    //remove(splashPanel.getSplashComponent());
+                    splashPanel = null;
+                    //remove(panel);
+                    // Re-add the applet to notify container
+                    add(panel);
+                    panel.setVisible(true);
+                    pack();
+                }
+            });
+        } catch (Exception e) {
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e); // Not much we can do other than print
+        }
+    }
+    @Override
+    public int getSplashWidth() {
+        if (splashPanel != null) {
+            return splashPanel.getSplashWidth();
+        } else {
+            return -1;
+        }
+    }
+    @Override
+    public int getSplashHeigth() {
+        if (splashPanel != null) {
+            return splashPanel.getSplashHeight();
+        } else {
+            return -1;
+        }
+    }
 …
+        }
+        @Override
         public void appletStateChanged(AppletEvent evt) {
             AppletPanel src = (AppletPanel) evt.getSource();
 …
             panelLive.signalAll();
             panelLock.unlock();
             switch (evt.getID()) {
                 case AppletPanel.APPLET_RESIZE: {
 …
                     // so we will have to rearrange it as well.
                     //
                     if (a != null)
+                    if (a != null) {
                         AppletPanel.changeFrameAppContext(frame, SunToolkit.targetToAppContext(a));
+                    else
+                    }
+                    else {
                         AppletPanel.changeFrameAppContext(frame, AppContext.getAppContext());
+                    }
                     updateStatus(appletViewer.identifier, PAV_INIT_STATUS.INIT_COMPLETE);
+                    break;
+                }
+                case AppletPanel.APPLET_START: {
+                    if (src.status != AppletPanel.APPLET_INIT && src.status != AppletPanel.APPLET_STOP) {
+                        String s="Applet started, but but reached invalid state";
+                        PluginDebug.debug(s);
+                        SplashPanel sp=SplashUtils.getErrorSplashScreen(appletViewer.panel.getWidth(), appletViewer.panel.getHeight(), new Exception(s));
+                        appletViewer.replaceSplash(sp);
+                    }
+                    break;
+                }
+                case AppletPanel.APPLET_ERROR: {
+                    String s="Undefined error causing applet not to staart appeared";
+                    PluginDebug.debug(s);
+                        SplashPanel sp=SplashUtils.getErrorSplashScreen(appletViewer.panel.getWidth(), appletViewer.panel.getHeight(), new Exception(s));
+                        appletViewer.replaceSplash(sp);
                     break;
+                }
 …
+    }
+    private static void handleInitializationMessage(int identifier, String message) throws IOException, LaunchException {
+        /* The user has specified via a global setting that applets should not be run.*/
+        if (AppletStartupSecuritySettings.getInstance().getSecurityLevel() == AppletSecurityLevel.DENY_ALL) {
+            throw new LaunchException(null, null, R("LSFatal"), R("LCClient"), R("LUnsignedApplet"), R("LUnsignedAppletPolicyDenied"));
+        }
+        // If there is a key for this status, it means it
+        // was either initialized before, or destroy has been
+        // processed. Stop moving further.
+        if (updateStatus(identifier, PAV_INIT_STATUS.PRE_INIT) != null) {
+            return;
+        }
+        // Extract the information from the message
+        String[] msgParts = new String[4];
+        for (int i = 0; i < 3; i++) {
+            int spaceLocation = message.indexOf(' ');
+            int nextSpaceLocation = message.indexOf(' ', spaceLocation + 1);
+            msgParts[i] = message.substring(spaceLocation + 1, nextSpaceLocation);
+            message = message.substring(nextSpaceLocation + 1);
+        }
+        long handle = Long.parseLong(msgParts[0]);
+        String width = msgParts[1];
+        String height = msgParts[2];
+        int spaceLocation = message.indexOf(' ', "tag".length() + 1);
+        String documentBase = message.substring("tag".length() + 1, spaceLocation);
+        String paramString = message.substring(spaceLocation + 1);
+        PluginDebug.debug("Handle = ", handle, "\n",
+                            "Width = ", width, "\n",
+                            "Height = ", height, "\n",
+                            "DocumentBase = ", documentBase, "\n",
+                            "Params = ", paramString);
+        JNLPRuntime.saveHistory(documentBase);
+        PluginAppletPanelFactory factory = new PluginAppletPanelFactory();
+        AppletMessageHandler amh = new AppletMessageHandler("appletviewer");
+        URL url = new URL(documentBase);
+        URLConnection conn = url.openConnection();
+        /* The original URL may have been redirected - this
+         * sets it to whatever URL/codebase we ended up getting
+         */
+        url = conn.getURL();
+        PluginParameters params = new PluginParameterParser().parse(width, height, paramString);
+        // Let user know we are starting up
+        streamhandler.write("instance " + identifier + " status " + amh.getMessage("status.start"));
+        factory.createPanel(streamhandler, identifier, handle, url, params);
+        long maxTimeToSleep = APPLET_TIMEOUT;
+        appletsLock.lock();
+        try {
+            while (!applets.containsKey(identifier) &&
+                    maxTimeToSleep > 0) { // Map is populated only by reFrame
+                maxTimeToSleep -= waitTillTimeout(appletsLock, appletAdded,
+                                                  maxTimeToSleep);
+            }
+        }
+        finally {
+            appletsLock.unlock();
+        }
+        // If wait exceeded maxWait, we timed out. Throw an exception
+        if (maxTimeToSleep <= 0)  {
+            // Caught in handleMessage
+            throw new RuntimeException("Applet initialization timeout");
+        }
+        // We should not try to destroy an applet during
+        // initialization. It may cause an inconsistent state,
+        // which would bad if it's a trusted applet that
+        // read/writes to files
+        waitForAppletInit(applets.get(identifier).panel);
+        // Should we proceed with reframing?
+         PluginDebug.debug("Init complete");
+        if (updateStatus(identifier, PAV_INIT_STATUS.REFRAME_COMPLETE).equals(PAV_INIT_STATUS.INACTIVE)) {
+            destroyApplet(identifier);
+            return;
+        }
+    }
     /**
      * Handle an incoming message from the plugin.
 …
         try {
             if (message.startsWith("handle")) {
+                // If there is a key for this status, it means it
+                // was either initialized before, or destroy has been
+                // processed. Stop moving further.
+                if (updateStatus(identifier, PAV_INIT_STATUS.PRE_INIT) != null)
+                    return;
+                // Extract the information from the message
+                String[] msgParts = new String[4];
+                for (int i = 0; i < 3; i++) {
+                    int spaceLocation = message.indexOf(' ');
+                    int nextSpaceLocation = message.indexOf(' ', spaceLocation + 1);
+                    msgParts[i] = message.substring(spaceLocation + 1, nextSpaceLocation);
+                    message = message.substring(nextSpaceLocation + 1);
+                }
+                long handle = Long.parseLong(msgParts[0]);
+                String width = msgParts[1];
+                String height = msgParts[2];
+                int spaceLocation = message.indexOf(' ', "tag".length() + 1);
+                String documentBase =
+                        UrlUtil.decode(message.substring("tag".length() + 1, spaceLocation));
+                String tag = message.substring(spaceLocation + 1);
+                PluginDebug.debug("Handle = ", handle, "\n",
+                                    "Width = ", width, "\n",
+                                    "Height = ", height, "\n",
+                                    "DocumentBase = ", documentBase, "\n",
+                                    "Tag = ", tag);
+                PluginAppletViewer.parse
+                                        (identifier, handle, width, height,
+                                                new StringReader(tag),
+                                                new URL(documentBase));
+                long maxTimeToSleep = APPLET_TIMEOUT;
+                appletsLock.lock();
+                try {
+                    while (!applets.containsKey(identifier) &&
+                            maxTimeToSleep > 0) { // Map is populated only by reFrame
+                        maxTimeToSleep -= waitTillTimeout(appletsLock, appletAdded,
+                                                          maxTimeToSleep);
+                    }
+                }
+                finally {
+                    appletsLock.unlock();
+                }
+                // If wait exceeded maxWait, we timed out. Throw an exception
+                if (maxTimeToSleep <= 0)
+                    throw new Exception("Applet initialization timeout");
+                // We should not try to destroy an applet during
+                // initialization. It may cause an inconsistent state,
+                // which would bad if it's a trusted applet that
+                // read/writes to files
+                waitForAppletInit(applets.get(identifier).panel);
+                // Should we proceed with reframing?
+                if (updateStatus(identifier, PAV_INIT_STATUS.REFRAME_COMPLETE).equals(PAV_INIT_STATUS.INACTIVE)) {
+                    destroyApplet(identifier);
+                    return;
+                }
+                handleInitializationMessage(identifier, message);
             } else if (message.startsWith("destroy")) {
 …
                 // don't bother processing further for inactive applets
                 if (status.get(identifier).equals(PAV_INIT_STATUS.INACTIVE))
+                if (status.get(identifier).equals(PAV_INIT_STATUS.INACTIVE)) {
                     return;
+                }
                 applets.get(identifier).handleMessage(reference, message);
 …
         } catch (Exception e) {
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
             // If an exception happened during pre-init, we need to update status
 …
     private static synchronized void destroyApplet(int identifier) {
+        // We should not try to destroy an applet during
+        // initialization. It may cause an inconsistent state.
+        waitForAppletInit( applets.get(identifier).panel );
         PluginDebug.debug("DestroyApplet called for ", identifier);
 …
             // If panel is already disposed, return
             if (pav.panel.applet == null) {
+            if (pav.panel.getApplet() == null) {
                 PluginDebug.debug(identifier, " panel inactive. Returning.");
                 return;
 …
             SwingUtilities.invokeLater(new Runnable() {
+                @Override
                 public void run() {
                     pav.appletClose();
 …
     public static void waitForAppletInit(NetxPanel panel) {
+        PluginDebug.debug("Waiting for applet init");
         // Wait till initialization finishes
         long maxTimeToSleep = APPLET_TIMEOUT;
 …
         panelLock.lock();
         try {
+            while (panel.getApplet() == null &&
+                    panel.isAlive() &&
+            while (!panel.isInitialized() &&
                     maxTimeToSleep > 0) {
                 PluginDebug.debug("Waiting for applet panel ", panel, " to initialize...");
 …
+    }
+    /* Resizes an applet panel, waiting for the applet to initialze.
+     * Should be done asynchronously to avoid the chance of deadlock. */
+    private void resizeAppletPanel(final int width, final int height) {
+        // Wait for panel to come alive
+        waitForAppletInit(panel);
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                panel.updateSizeInAtts(height, width);
+                setSize(width, height);
+                // There is a rather odd drawing bug whereby resizing
+                // the panel makes no difference on initial call
+                // because the panel thinks that it is already the
+                // right size. Validation has no effect there either.
+                // So we work around by setting size to 1, validating,
+                // and then setting to the right size and validating
+                // again. This is not very efficient, and there is
+                // probably a better way -- but resizing happens
+                // quite infrequently, so for now this is how we do it
+                panel.setSize(1, 1);
+                panel.validate();
+                panel.setSize(width, height);
+                panel.validate();
+                panel.getApplet().resize(width, height);
+                panel.getApplet().validate();
+            }
+        });
+    }
     public void handleMessage(int reference, String message) {
         if (message.startsWith("width")) {
-            // Wait for panel to come alive
-            long maxTimeToSleep = APPLET_TIMEOUT;
-            statusLock.lock();
-            try {
-                while (!status.get(identifier).equals(PAV_INIT_STATUS.INIT_COMPLETE) &&
-                        maxTimeToSleep > 0) {
-                    maxTimeToSleep -= waitTillTimeout(statusLock, initComplete,
-                                                      maxTimeToSleep);
+                }
+            }
-            finally {
-                statusLock.unlock();
+            }
             // 0 => width, 1=> width_value, 2 => height, 3=> height_value
             String[] dimMsg = message.split(" ");
+            final int width = Integer.parseInt(dimMsg[1]);
             final int height = Integer.parseInt(dimMsg[3]);
+            final int width = Integer.parseInt(dimMsg[1]);
+            panel.updateSizeInAtts(height, width);
+            try {
+                SwingUtilities.invokeAndWait(new Runnable() {
+                    public void run() {
+                        setSize(width, height);
+                        // There is a rather odd drawing bug whereby resizing
+                        // the panel makes no difference on initial call
+                        // because the panel thinks that it is already the
+                        // right size. Validation has no effect there either.
+                        // So we work around by setting size to 1, validating,
+                        // and then setting to the right size and validating
+                        // again. This is not very efficient, and there is
+                        // probably a better way -- but resizing happens
+                        // quite infrequently, so for now this is how we do it
+                        panel.setSize(1, 1);
+                        panel.validate();
+                        panel.setSize(width, height);
+                        panel.validate();
+                        panel.applet.resize(width, height);
+                        panel.applet.validate();
+                    }
+                });
+            } catch (InterruptedException e) {
+                // do nothing
+                e.printStackTrace();
+            } catch (InvocationTargetException e) {
+                // do nothing
+                e.printStackTrace();
+            }
+            /* Resize the applet asynchronously, to avoid the chance of
+             * deadlock while waiting for the applet to initialize.
+             *
+             * In general, worker threads should spawn new threads for any blocking operations. */
+            Thread resizeAppletThread = new Thread("resizeAppletThread") {
+                @Override
+                public void run() {
+                    resizeAppletPanel(width, height);
+                }
+            };
+            /* Let it eventually complete */
+            resizeAppletThread.start();
         } else if (message.startsWith("GetJavaObject")) {
 …
             Object o;
-            // First, wait for panel to instantiate
-            // Next, wait for panel to come alive
-            long maxTimeToSleep = APPLET_TIMEOUT;
-            panelLock.lock();
-            try {
-                while (panel == null || !panel.isAlive())
-                    maxTimeToSleep -= waitTillTimeout(panelLock, panelLive,
-                                                      maxTimeToSleep);
+            }
-            finally {
-                panelLock.unlock();
+            }
             // Wait for the panel to initialize
             // (happens in a separate thread)
             waitForAppletInit(panel);
             PluginDebug.debug(panel, " -- ", panel.getApplet(), " -- ", panel.isAlive());
+            PluginDebug.debug(panel, " -- ", panel.getApplet(), " -- initialized: ", panel.isInitialized());
             // Still null?
             if (panel.getApplet() == null) {
+                streamhandler.write("instance " + identifier + " reference " + -1 + " fatalError: " + "Initialization timed out");
+                streamhandler.write("instance " + identifier + " reference " + -1 + " fatalError: " + "Initialization failed");
+                streamhandler.write("context 0 reference " + reference + " Error");
                 return;
+            }
 …
      * Get an audio clip.
      */
+    @Override
     public AudioClip getAudioClip(URL url) {
         checkConnect(url);
 …
      * Get an image.
      */
+    @Override
     public Image getImage(URL url) {
         return getCachedImage(url);
 …
                 String resourceName = originalURL.substring(codeBase.length());
+                JNLPClassLoader loader = (JNLPClassLoader) panel.getAppletClassLoader();
+                URL localURL = null;
+                if (loader.resourceAvailableLocally(resourceName))
+                    url = loader.getResource(resourceName);
+                url = localURL != null ? localURL : url;
+                if (panel.getAppletClassLoader() instanceof JNLPClassLoader) {
+                    JNLPClassLoader loader = (JNLPClassLoader) panel.getAppletClassLoader();
+                    URL localURL = null;
+                    if (loader.resourceAvailableLocally(resourceName)) {
+                        url = loader.getResource(resourceName);
+                    }
+                    url = localURL != null ? localURL : url;
+                }
+            }
 …
+            }
         } catch (Exception e) {
             System.err.println("Error occurred when trying to fetch image:");
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL, "Error occurred when trying to fetch image:");
+            OutputController.getLogger().log(e);
             return null;
+        }
 …
      * Get an applet by name.
      */
+    @Override
     public Applet getApplet(String name) {
         name = name.toLowerCase();
 …
      * applets on this page.
      */
+    @Override
     public Enumeration<Applet> getApplets() {
         Vector<Applet> v = new Vector<Applet>();
 …
+    }
+    /**
+     * Ignore.
+     */
+    @Override
     public void showDocument(URL url) {
         PluginDebug.debug("Showing document...");
 …
+    }
+    /**
+     * Ignore.
+     */
+    @Override
     public void showDocument(URL url, String target) {
+        // If it is a javascript document, eval on current page.
+        if ("javascript".equals(url.getProtocol())) {
+            // Snip protocol off string
+            String evalString = url.toString().substring("javascript:".length());
+            eval(getWindow(), evalString);
+            return;
+        }
         try {
             Long reference = getRequestIdentifier();
 …
      * Show status.
      */
+    @Override
     public void showStatus(String status) {
         try {
 …
     public static void setMember(long internal, String name, Object value) {
+        System.err.println("Setting to class " + value.getClass() + ":" + value.getClass().isPrimitive());
+        AppletSecurityContextManager.getSecurityContext(0).store(name);
+        int nameID = AppletSecurityContextManager.getSecurityContext(0).getIdentifier(name);
+        PluginDebug.debug("Setting to class " + value.getClass() + ":" + value.getClass().isPrimitive());
+        PluginAppletSecurityContext securityContext = AppletSecurityContextManager.getSecurityContext(0);
+        securityContext.store(name);
+        int nameID = securityContext.getIdentifier(name);
         Long reference = getRequestIdentifier();
         // work on a copy of value, as we don't want to be manipulating
         // complex objects
+        String valueToSetTo;
+        if (value instanceof java.lang.Byte ||
+                value instanceof java.lang.Character ||
+                value instanceof java.lang.Short ||
+                value instanceof java.lang.Integer ||
+                value instanceof java.lang.Long ||
+                value instanceof java.lang.Float ||
+                value instanceof java.lang.Double ||
+                value instanceof java.lang.Boolean) {
+            valueToSetTo = "literalreturn " + value.toString();
+            // Character -> Str results in str value.. we need int value as
+            // per specs.
+            if (value instanceof java.lang.Character) {
+                valueToSetTo = "literalreturn " + (int) ((java.lang.Character) value).charValue();
+            } else if (value instanceof Float ||
+                        value instanceof Double) {
+                valueToSetTo = "literalreturn " + String.format("%308.308e", value);
+            }
+        } else {
+            AppletSecurityContextManager.getSecurityContext(0).store(value);
+            valueToSetTo = Integer.toString(AppletSecurityContextManager.getSecurityContext(0).getIdentifier(value));
+        }
+        String objIDStr = securityContext.toObjectIDString(value,
+                value.getClass(), true /* unbox primitives */);
         // Prefix with dummy instance for convenience.
         PluginCallRequest request = requestFactory.getPluginCallRequest("void",
                 "instance " + 0 + " reference " + reference + " SetMember " +
                         internal + " " + nameID + " " + valueToSetTo, reference);
+                        internal + " " + nameID + " " + objIDStr, reference);
         streamhandler.postCallRequest(request);
 …
     // FIXME: handle long index as well.
     public static void setSlot(long internal, int index, Object value) {
+        AppletSecurityContextManager.getSecurityContext(0).store(value);
+        PluginAppletSecurityContext securityContext = AppletSecurityContextManager.getSecurityContext(0);
+        securityContext.store(value);
         Long reference = getRequestIdentifier();
+        // work on a copy of value, as we don't want to be manipulating
+        // complex objects
+        String valueToSetTo;
+        if (value instanceof java.lang.Byte ||
+                value instanceof java.lang.Character ||
+                value instanceof java.lang.Short ||
+                value instanceof java.lang.Integer ||
+                value instanceof java.lang.Long ||
+                value instanceof java.lang.Float ||
+                value instanceof java.lang.Double ||
+                value instanceof java.lang.Boolean) {
+            valueToSetTo = "literalreturn " + value.toString();
+            // Character -> Str results in str value.. we need int value as
+            // per specs.
+            if (value instanceof java.lang.Character) {
+                valueToSetTo = "literalreturn " + (int) ((java.lang.Character) value).charValue();
+            } else if (value instanceof Float ||
+                        value instanceof Double) {
+                valueToSetTo = "literalreturn " + String.format("%308.308e", value);
+            }
+        } else {
+            AppletSecurityContextManager.getSecurityContext(0).store(value);
+            valueToSetTo = Integer.toString(AppletSecurityContextManager.getSecurityContext(0).getIdentifier(value));
+        }
+        String objIDStr = securityContext.toObjectIDString(value,
+                value.getClass(), true /* unbox primitives */);
         // Prefix with dummy instance for convenience.
         PluginCallRequest request = requestFactory.getPluginCallRequest("void",
                 "instance " + 0 + " reference " + reference + " SetSlot " +
                         internal + " " + index + " " + valueToSetTo, reference);
+                        internal + " " + index + " " + objIDStr, reference);
         streamhandler.postCallRequest(request);
 …
             synchronized (request) {
                 PluginDebug.debug("wait eval request 2");
                 while (request.isDone() == false)
+                while (request.isDone() == false) {
                     request.wait();
+                }
                 PluginDebug.debug("wait eval request 3");
+            }
 …
             synchronized (request) {
                 PluginDebug.debug("wait call request 2");
                 while (request.isDone() == false)
+                while (request.isDone() == false) {
                     request.wait();
+                }
                 PluginDebug.debug("wait call request 3");
+            }
 …
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
             return null;
+        }
 …
             synchronized (request) {
                 PluginDebug.debug("wait cookieinfo request 2");
                 while (request.isDone() == false)
+                while (request.isDone() == false) {
                     request.wait();
+                }
                 PluginDebug.debug("wait cookieinfo request 3");
+            }
 …
+    }
+    public static Object requestPluginProxyInfo(URI uri) {
+        String requestURI = null;
+    /**
+     * Obtain information about the proxy from the browser.
+     *
+     * @param uri a String in url-encoded form
+     * @return a {@link URI} that indicates a proxy.
+     */
+    public static Object requestPluginProxyInfo(String uri) {
         Long reference = getRequestIdentifier();
-        try {
-            // there is no easy way to get SOCKS proxy info. So, we tell mozilla that we want proxy for
-            // an HTTP uri in case of non http/ftp protocols. If we get back a SOCKS proxy, we can
-            // use that, if we get back an http proxy, we fallback to DIRECT connect
-            String scheme = uri.getScheme();
-            String port = uri.getPort() != -1 ? ":" + uri.getPort() : "";
-            if (!uri.getScheme().startsWith("http") && !uri.getScheme().equals("ftp"))
-                scheme = "http";
-            requestURI = UrlUtil.encode(scheme + "://" + uri.getHost() + port + "/" + uri.getPath(), "UTF-8");
-        } catch (Exception e) {
-            PluginDebug.debug("Cannot construct URL from ", uri.toString(), " ... falling back to DIRECT proxy");
-            e.printStackTrace();
-            return null;
+        }
         PluginCallRequest request = requestFactory.getPluginCallRequest("proxyinfo",
                 "plugin PluginProxyInfo reference " + reference + " " +
                         requestURI, reference);
+                        uri, reference);
         PluginMessageConsumer.registerPriorityWait(reference);
 …
             synchronized (request) {
                 PluginDebug.debug("wait call request 2");
                 while (request.isDone() == false)
+                while (request.isDone() == false) {
                     request.wait();
+                }
                 PluginDebug.debug("wait call request 3");
+            }
 …
             synchronized (request) {
                 PluginDebug.debug("wait finalize request 2");
                 while (request.isDone() == false)
+                while (request.isDone() == false) {
                     request.wait();
+                }
                 PluginDebug.debug("wait finalize request 3");
+            }
 …
         streamhandler.postCallRequest(request);
         streamhandler.write(request.getMessage());
+        try {
+            PluginDebug.debug("wait ToString request 1");
+            synchronized (request) {
+                PluginDebug.debug("wait ToString request 2");
+                while (request.isDone() == false)
+                    request.wait();
+                PluginDebug.debug("wait ToString request 3");
+            }
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted waiting for call request.",
+                                        e);
+        }
+        PluginDebug.debug("wait ToString request 1");
+        synchronized (request) {
+            PluginDebug.debug("wait ToString request 2");
+            waitForRequestCompletion(request);
+            PluginDebug.debug("wait ToString request 3");
+        }
         PluginDebug.debug(" ToString DONE");
         return (String) request.getObject();
 …
+    }
+    @Override
     public void setStream(String key, InputStream stream) throws IOException {
         // We do nothing.
 …
         // We do nothing.
         return null;
+    }
-    /**
-     * Decodes the string (converts html escapes into proper characters)
+     *
-     * @param toDecode The string to decode
-     * @return The decoded string
-     */
-    public static String decodeString(String toDecode) {
-        toDecode = toDecode.replace("&gt;", ">");
-        toDecode = toDecode.replace("&lt;", "<");
-        toDecode = toDecode.replace("&amp;", "&");
-        toDecode = toDecode.replace("&#10;", "\n");
-        toDecode = toDecode.replace("&#13;", "\r");
-        toDecode = toDecode.replace("&quot;", "\"");
-        return toDecode;
+    }
 …
     /**
-     * Print the HTML tag.
-     */
-    public static void printTag(PrintStream out, Hashtable<String, String> atts) {
-        out.print("<applet");
-        String v = atts.get("codebase");
-        if (v != null) {
-            out.print(" codebase=\"" + v + "\"");
+        }
-        v = atts.get("code");
-        if (v == null) {
-            v = "applet.class";
+        }
-        out.print(" code=\"" + v + "\"");
-        v = atts.get("width");
-        if (v == null) {
-            v = "150";
+        }
-        out.print(" width=" + v);
-        v = atts.get("height");
-        if (v == null) {
-            v = "100";
+        }
-        out.print(" height=" + v);
-        v = atts.get("name");
-        if (v != null) {
-            out.print(" name=\"" + v + "\"");
+        }
-        out.println(">");
-        // A very slow sorting algorithm
-        int len = atts.size();
-        String params[] = new String[len];
-        len = 0;
-        for (Enumeration<String> e = atts.keys(); e.hasMoreElements();) {
-            String param = e.nextElement();
-            int i = 0;
-            for (; i < len; i++) {
-                if (params[i].compareTo(param) >= 0) {
-                    break;
+                }
+            }
-            System.arraycopy(params, i, params, i + 1, len - i);
-            params[i] = param;
-            len++;
+        }
-        for (int i = 0; i < len; i++) {
-            String param = params[i];
-            if (systemParam.get(param) == null) {
-                out.println("<param name=" + param +
-                        " value=\"" + atts.get(param) + "\">");
+            }
+        }
-        out.println("</applet>");
+    }
-    /**
      * Make sure the atrributes are uptodate.
      */
 …
         Dimension d = panel.getSize();
         Insets in = panel.getInsets();
+        panel.atts.put("width",
+                       Integer.valueOf(d.width - (in.left + in.right)).toString());
+        panel.atts.put("height",
+                       Integer.valueOf(d.height - (in.top + in.bottom)).toString());
+        int width = d.width - (in.left + in.right);
+        int height = d.height - (in.top + in.bottom);
+        panel.updateSizeInAtts(height, width);
+    }
 …
          */
         try {
             ((AppletViewerPanel)panel).joinAppletThread();
             ((AppletViewerPanel)panel).release();
+            ((AppletViewerPanelAccess)panel).joinAppletThread();
+            ((AppletViewerPanelAccess)panel).release();
         } catch (InterruptedException e) {
             return; // abort the reload
 …
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
+            @Override
             public Void run() {
                 ((AppletViewerPanel)panel).createAppletThread();
+                ((AppletViewerPanelAccess)panel).createAppletThread();
                 return null;
+            }
 …
+    }
+    @Override
     public int print(Graphics graphics, PageFormat pf, int pageIndex) {
         return Printable.NO_SUCH_PAGE;
 …
         new Thread(new Runnable() {
             @SuppressWarnings("deprecation")
+            @Override
             public void run() {
                 ClassLoader cl = p.applet.getClass().getClassLoader();
 …
                 // Since we want to deal with JNLPClassLoader, extract it if this
                 // is a codebase loader
                 if (cl instanceof JNLPClassLoader.CodeBaseClassLoader)
+                if (cl instanceof JNLPClassLoader.CodeBaseClassLoader) {
                     cl = ((JNLPClassLoader.CodeBaseClassLoader) cl).getParentJNLPClassLoader();
+                ThreadGroup tg = ((JNLPClassLoader) cl).getApplication().getThreadGroup();
+                }
                 appletShutdown(p);
 …
                 // Mark classloader unusable
+                ((JNLPClassLoader) cl).decrementLoaderUseCount();
+                if (cl instanceof JNLPClassLoader) {
+                    ((JNLPClassLoader) cl).decrementLoaderUseCount();
+                }
                 try {
                     SwingUtilities.invokeAndWait(new Runnable() {
+                        @Override
                         public void run() {
                             dispose();
 …
+    }
-    /**
-     * Scan spaces.
-     */
-    public static void skipSpace(int[] c, Reader in) throws IOException {
-        while ((c[0] >= 0) &&
-                ((c[0] == ' ') || (c[0] == '\t') || (c[0] == '\n') || (c[0] == '\r'))) {
-            c[0] = in.read();
+        }
+    }
-    /**
-     * Scan identifier
-     */
-    public static String scanIdentifier(int[] c, Reader in) throws IOException {
-        StringBuilder buf = new StringBuilder();
-        if (c[0] == '!') {
-            // Technically, we should be scanning for '!--' but we are reading
-            // from a stream, and there is no way to peek ahead. That said,
-            // a ! at this point can only mean comment here afaik, so we
-            // should be okay
-            skipComment(c, in);
-            return "";
+        }
-        while (true) {
-            if (((c[0] >= 'a') && (c[0] <= 'z')) ||
-                    ((c[0] >= 'A') && (c[0] <= 'Z')) ||
-                    ((c[0] >= '0') && (c[0] <= '9')) || (c[0] == '_')) {
-                buf.append((char) c[0]);
-                c[0] = in.read();
-            } else {
-                return buf.toString();
+            }
+        }
+    }
-    public static void skipComment(int[] c, Reader in) throws IOException {
-        StringBuilder buf = new StringBuilder();
-        boolean commentHeaderPassed = false;
-        c[0] = in.read();
-        buf.append((char) c[0]);
-        while (true) {
-            if (c[0] == '-' && (c[0] = in.read()) == '-') {
-                buf.append((char) c[0]);
-                if (commentHeaderPassed) {
-                    // -- encountered ... is > next?
-                    if ((c[0] = in.read()) == '>') {
-                        buf.append((char) c[0]);
-                        PluginDebug.debug("Comment skipped: ", buf.toString());
-                        // comment skipped.
-                        return;
+                    }
-                } else {
-                    // first -- is part of <!-- ... , just mark that we have passed it
-                    commentHeaderPassed = true;
+                }
-            } else if (commentHeaderPassed == false) {
-                buf.append((char) c[0]);
-                PluginDebug.debug("Warning: Attempted to skip comment, but this tag does not appear to be a comment: ", buf.toString());
-                return;
+            }
-            c[0] = in.read();
-            buf.append((char) c[0]);
+        }
+    }
-    /**
-     * Scan tag
-     */
-    public static Hashtable<String, String> scanTag(int[] c, Reader in) throws IOException {
-        Hashtable<String, String> atts = new Hashtable<String, String>();
-        skipSpace(c, in);
-        while (c[0] >= 0 && c[0] != '>') {
-            String att = decodeString(scanIdentifier(c, in));
-            String val = "";
-            skipSpace(c, in);
-            if (c[0] == '=') {
-                int quote = -1;
-                c[0] = in.read();
-                skipSpace(c, in);
-                if ((c[0] == '\'') || (c[0] == '\"')) {
-                    quote = c[0];
-                    c[0] = in.read();
+                }
-                StringBuilder buf = new StringBuilder();
-                while ((c[0] > 0) &&
-                        (((quote < 0) && (c[0] != ' ') && (c[0] != '\t') &&
-                                (c[0] != '\n') && (c[0] != '\r') && (c[0] != '>'))
-                         || ((quote >= 0) && (c[0] != quote)))) {
-                    buf.append((char) c[0]);
-                    c[0] = in.read();
+                }
-                if (c[0] == quote) {
-                    c[0] = in.read();
+                }
-                skipSpace(c, in);
-                val = decodeString(buf.toString());
+            }
-            PluginDebug.debug("PUT ", att, " = '", val, "'");
-            atts.put(att.toLowerCase(java.util.Locale.ENGLISH), val);
-            while (true) {
-                if ((c[0] == '>') || (c[0] < 0) ||
-                        ((c[0] >= 'a') && (c[0] <= 'z')) ||
-                        ((c[0] >= 'A') && (c[0] <= 'Z')) ||
-                        ((c[0] >= '0') && (c[0] <= '9')) || (c[0] == '_'))
-                    break;
-                c[0] = in.read();
+            }
-            //skipSpace(in);
+        }
-        return atts;
+    }
-    // private static final == inline
-    private static final boolean isInt(Object o) {
-        boolean isInt = false;
-        try {
-            Integer.parseInt((String) o);
-            isInt = true;
-        } catch (Exception e) {
-            // don't care
+        }
-        return isInt;
+    }
-    /* values used for placement of AppletViewer's frames */
-    private static int x = 0;
-    private static int y = 0;
-    private static final int XDELTA = 30;
-    private static final int YDELTA = XDELTA;
-    static String encoding = null;
-    /**
-     * Scan an html file for <applet> tags
-     */
-    public static void parse(int identifier, long handle, String width, String height, Reader in, URL url, String enc)
-            throws IOException {
-        encoding = enc;
-        parse(identifier, handle, width, height, in, url, System.out, new PluginAppletPanelFactory());
+    }
-    public static void parse(int identifier, long handle, String width, String height, Reader in, URL url)
-            throws PrivilegedActionException {
-        final int fIdentifier = identifier;
-        final long fHandle = handle;
-        final String fWidth = width;
-        final String fHeight = height;
-        final Reader fIn = in;
-        final URL fUrl = url;
-        AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
-            public Void run() throws IOException {
-                parse(fIdentifier, fHandle, fWidth, fHeight, fIn, fUrl,
-                        System.out, new PluginAppletPanelFactory());
-                return null;
+            }
-        });
+    }
-    @SuppressWarnings("unused")
-    public static void parse(int identifier, long handle, String width,
-                 String height, Reader in, URL url,
-                              PrintStream statusMsgStream,
-                              PluginAppletPanelFactory factory)
-            throws IOException {
-        boolean isObjectTag = false;
-        boolean objectTagAlreadyParsed = false;
-        // The current character
-        // FIXME: This is an evil hack to force pass-by-reference.. the
-        // parsing code needs to be rewritten from scratch to prevent such
-        //a need
-        int[] c = new int[1];
-        // warning messages
-        String requiresNameWarning = amh.getMessage("parse.warning.requiresname");
-        String paramOutsideWarning = amh.getMessage("parse.warning.paramoutside");
-        String appletRequiresCodeWarning = amh.getMessage("parse.warning.applet.requirescode");
-        String appletRequiresHeightWarning = amh.getMessage("parse.warning.applet.requiresheight");
-        String appletRequiresWidthWarning = amh.getMessage("parse.warning.applet.requireswidth");
-        String objectRequiresCodeWarning = amh.getMessage("parse.warning.object.requirescode");
-        String objectRequiresHeightWarning = amh.getMessage("parse.warning.object.requiresheight");
-        String objectRequiresWidthWarning = amh.getMessage("parse.warning.object.requireswidth");
-        String embedRequiresCodeWarning = amh.getMessage("parse.warning.embed.requirescode");
-        String embedRequiresHeightWarning = amh.getMessage("parse.warning.embed.requiresheight");
-        String embedRequiresWidthWarning = amh.getMessage("parse.warning.embed.requireswidth");
-        String appNotLongerSupportedWarning = amh.getMessage("parse.warning.appnotLongersupported");
-        java.net.URLConnection conn = url.openConnection();
-        /* The original URL may have been redirected - this
-         * sets it to whatever URL/codebase we ended up getting
-         */
-        url = conn.getURL();
-        int ydisp = 1;
-        Hashtable<String, String> atts = null;
-        while (true) {
-            c[0] = in.read();
-            if (c[0] == -1)
-                break;
-            if (c[0] == '<') {
-                c[0] = in.read();
-                if (c[0] == '/') {
-                    c[0] = in.read();
-                    String nm = scanIdentifier(c, in);
-                    if (nm.equalsIgnoreCase("applet") ||
-                             nm.equalsIgnoreCase("object") ||
-                             nm.equalsIgnoreCase("embed")) {
-                        // We can't test for a code tag until </OBJECT>
-                        // because it is a parameter, not an attribute.
-                        if (isObjectTag) {
-                            if (atts.get("code") == null && atts.get("object") == null) {
-                                statusMsgStream.println(objectRequiresCodeWarning);
-                                atts = null;
+                            }
+                        }
-                        if (atts != null) {
-                            // XXX 5/18 In general this code just simply
-                            // shouldn't be part of parsing.  It's presence
-                            // causes things to be a little too much of a
-                            // hack.
-                            // Let user know we are starting up
-                            streamhandler.write("instance " + identifier + " status " + amh.getMessage("status.start"));
-                            factory.createPanel(streamhandler, identifier, handle, x, y, url, atts);
-                            x += XDELTA;
-                            y += YDELTA;
-                            // make sure we don't go too far!
-                            Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
-                            if ((x > d.width - 300) || (y > d.height - 300)) {
-                                x = 0;
-                                y = 2 * ydisp * YDELTA;
-                                ydisp++;
+                            }
+                        }
-                        atts = null;
-                        isObjectTag = false;
+                    }
-                } else {
-                    String nm = scanIdentifier(c, in);
-                    if (nm.equalsIgnoreCase("param")) {
-                        Hashtable<String, String> t = scanTag(c, in);
-                        String att = t.get("name");
-                        if (att == null) {
-                            statusMsgStream.println(requiresNameWarning);
-                        } else {
-                            String val = t.get("value");
-                            if (val == null) {
-                                statusMsgStream.println(requiresNameWarning);
-                            } else {
-                                PluginDebug.debug("PUT ", att, " = ", val);
-                                atts.put(att.toLowerCase(), val);
+                            }
+                        }
-                    } else if (nm.equalsIgnoreCase("applet")) {
-                        atts = scanTag(c, in);
-                        // If there is a classid and no code tag present, transform it to code tag
-                        if (atts.get("code") == null && atts.get("classid") != null
-                                && !(atts.get("classid")).startsWith("clsid:")) {
-                            atts.put("code", atts.get("classid"));
+                        }
-                        // remove java: from code tag
-                        if (atts.get("code") != null && (atts.get("code")).startsWith("java:")) {
-                            atts.put("code", (atts.get("code")).substring(5));
+                        }
-                        if (atts.get("code") == null && atts.get("object") == null) {
-                            statusMsgStream.println(appletRequiresCodeWarning);
-                            atts = null;
+                        }
-                        if (atts.get("width") == null || !isInt(atts.get("width"))) {
-                            atts.put("width", width);
+                        }
-                        if (atts.get("height") == null || !isInt(atts.get("height"))) {
-                            atts.put("height", height);
+                        }
-                    } else if (nm.equalsIgnoreCase("object")) {
-                        isObjectTag = true;
-                        // Once code is set, additional nested objects are ignored
-                        if (!objectTagAlreadyParsed) {
-                            objectTagAlreadyParsed = true;
-                            atts = scanTag(c, in);
+                        }
-                        // If there is a classid and no code tag present, transform it to code tag
-                        if (atts.get("code") == null && atts.get("classid") != null
-                                && !(atts.get("classid")).startsWith("clsid:")) {
-                            atts.put("code", atts.get("classid"));
+                        }
-                        // remove java: from code tag
-                        if (atts.get("code") != null && (atts.get("code")).startsWith("java:")) {
-                            atts.put("code", (atts.get("code")).substring(5));
+                        }
-                        // java_* aliases override older names:
-                        // http://java.sun.com/j2se/1.4.2/docs/guide/plugin/developer_guide/using_tags.html#in-ie
-                        if (atts.get("java_code") != null) {
-                            atts.put("code", (atts.get("java_code")));
+                        }
-                        if (atts.containsKey("code")) {
-                            objectTagAlreadyParsed = true;
+                        }
-                        if (atts.get("java_codebase") != null) {
-                            atts.put("codebase", (atts.get("java_codebase")));
+                        }
-                        if (atts.get("java_archive") != null) {
-                            atts.put("archive", (atts.get("java_archive")));
+                        }
-                        if (atts.get("java_object") != null) {
-                            atts.put("object", (atts.get("java_object")));
+                        }
-                        if (atts.get("java_type") != null) {
-                            atts.put("type", (atts.get("java_type")));
+                        }
-                        if (atts.get("width") == null || !isInt(atts.get("width"))) {
-                            atts.put("width", width);
+                        }
-                        if (atts.get("height") == null || !isInt(atts.get("height"))) {
-                            atts.put("height", height);
+                        }
-                    } else if (nm.equalsIgnoreCase("embed")) {
-                        atts = scanTag(c, in);
-                        // If there is a classid and no code tag present, transform it to code tag
-                        if (atts.get("code") == null && atts.get("classid") != null
-                                && !(atts.get("classid")).startsWith("clsid:")) {
-                            atts.put("code", atts.get("classid"));
+                        }
-                        // remove java: from code tag
-                        if (atts.get("code") != null && (atts.get("code")).startsWith("java:")) {
-                            atts.put("code", (atts.get("code")).substring(5));
+                        }
-                        // java_* aliases override older names:
-                        // http://java.sun.com/j2se/1.4.2/docs/guide/plugin/developer_guide/using_tags.html#in-nav
-                        if (atts.get("java_code") != null) {
-                            atts.put("code", (atts.get("java_code")));
+                        }
-                        if (atts.get("java_codebase") != null) {
-                            atts.put("codebase", (atts.get("java_codebase")));
+                        }
-                        if (atts.get("java_archive") != null) {
-                            atts.put("archive", (atts.get("java_archive")));
+                        }
-                        if (atts.get("java_object") != null) {
-                            atts.put("object", (atts.get("java_object")));
+                        }
-                        if (atts.get("java_type") != null) {
-                            atts.put("type", (atts.get("java_type")));
+                        }
-                        if (atts.get("code") == null && atts.get("object") == null) {
-                            statusMsgStream.println(embedRequiresCodeWarning);
-                            atts = null;
+                        }
-                        if (atts.get("width") == null || !isInt(atts.get("width"))) {
-                            atts.put("width", width);
+                        }
-                        if (atts.get("height") == null || !isInt(atts.get("height"))) {
-                            atts.put("height", height);
+                        }
+                    }
+                }
+            }
+        }
-        in.close();
+    }
-    private static AppletMessageHandler amh = new AppletMessageHandler("appletviewer");
     private static void checkConnect(URL url) {
 …
                 java.security.Permission perm =
                         url.openConnection().getPermission();
                 if (perm != null)
+                if (perm != null) {
                     security.checkPermission(perm);
+                else
+                }
+                else {
                     security.checkConnect(url.getHost(), url.getPort());
+                }
             } catch (java.io.IOException ioe) {
                 security.checkConnect(url.getHost(), url.getPort());
 …
      * which are accounted for) and then calls paint anyway.
      */
+    public void update(Graphics g) {
+    @Override
+    public void paint(Graphics g) {
         // If the image or the graphics don't exist, create new ones
         if (bufFrameImg == null || bufFrameImgGraphics == null) {
+            bufFrameImg = createImage(getWidth(), getHeight());
+            // although invisible applets do not have right to paint
+            // we rather paint to 1x1 to be sure all callbacks  will be completed
+            bufFrameImg = createImage(Math.max(1, getWidth()), Math.max(1, getHeight()));
             bufFrameImgGraphics = bufFrameImg.getGraphics();
+        }
         // Paint off-screen
+        paint(bufFrameImgGraphics);
+        for (Component c: this.getComponents()) {
+                c.paint(bufFrameImgGraphics);
+        }
         // Draw the painted image
         g.drawImage(bufFrameImg, 0, 0, this);
+    }
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
     /**
      * Waits on a given condition queue until timeout.
 …
         // Can't wait on null. Return 0 indicating no wait happened.
+        if (lock == null)
+            return 0;
+        if (lock == null) {
+                                               return 0;
+                                           }
         assert lock.isHeldByCurrentThread();
 …
         return System.nanoTime() - sleepStart;
+    }
+    private class SplashCreator implements Runnable {
+        private final AppletPanel fPanel;
+        public SplashCreator(AppletPanel fPanel) {
+            this.fPanel = fPanel;
+        }
+        @Override
+        public void run() {
+            add("Center", fPanel);
+            fPanel.setVisible(false);
+            splashPanel = SplashUtils.getSplashScreen(fPanel.getWidth(), fPanel.getHeight());
+            if (splashPanel != null) {
+                splashPanel.startAnimation();
+                PluginDebug.debug("Added splash " + splashPanel);
+                add("Center", splashPanel.getSplashComponent());
+            }
+            pack();
+        }
+    }
+}

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginDebug.java

-              r348
+              r429
 package sun.applet;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.util.logging.OutputController;
 public class PluginDebug {
     static final boolean DEBUG = System.getenv().containsKey("ICEDTEAPLUGIN_DEBUG");
+    static final boolean DEBUG = JNLPRuntime.isDebug();
     public static void debug(Object... messageChunks) {
 …
                 b.append(chunk);
+            }
             System.err.println(b.toString());
+            OutputController.getLogger().log(OutputController.Level.MESSAGE_DEBUG, b.toString());
+        }
+    }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginException.java

-              r418
+              r429
 package sun.applet;
+import net.sourceforge.jnlp.util.logging.OutputController;
 public class PluginException extends Exception {
     public PluginException(PluginStreamHandler sh, int instance, int reference, Throwable t) {
         t.printStackTrace();
+        OutputController.getLogger().log(OutputController.Level.ERROR_ALL,t);
         this.setStackTrace(t.getStackTrace());

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMain.java

-              r418
+              r429
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.net.Authenticator;
 import java.net.CookieHandler;
 import java.net.CookieManager;
 import java.net.ProxySelector;
+import java.net.URL;
+import java.net.URLStreamHandler;
 import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Map;
 import java.util.Properties;
+import sun.awt.AppContext;
+import sun.awt.SunToolkit;
 import net.sourceforge.jnlp.config.DeploymentConfiguration;
 import net.sourceforge.jnlp.runtime.JNLPRuntime;
 import net.sourceforge.jnlp.security.JNLPAuthenticator;
+import net.sourceforge.jnlp.util.logging.JavaConsole;
+import net.sourceforge.jnlp.util.logging.LogConfig;
+import net.sourceforge.jnlp.util.logging.OutputController;
 /**
 …
  */
 public class PluginMain extends PluginMainBase {
-    // the files where stdout/stderr are sent to
-    public static final String PLUGIN_STDERR_FILE = "java.stderr";
-    public static final String PLUGIN_STDOUT_FILE = "java.stdout";
     // This is used in init().  Getting rid of this is desirable but depends
     // on whether the property that uses it is necessary/standard.
     private static final String theVersion = System.getProperty("java.version");
+    /* Install a handler directly using reflection. This ensures that java doesn't error-out
+     * when javascript is used in a URL. We can then handle these URLs correctly in eg PluginAppletViewer.showDocument().
+     */
+    static private void installDummyJavascriptProtocolHandler() {
+        try {
+            Field handlersField = URL.class.getDeclaredField("handlers");
+            handlersField.setAccessible(true);
+            @SuppressWarnings("unchecked")
+            Hashtable<String, URLStreamHandler> handlers = (Hashtable<String,URLStreamHandler>)handlersField.get(null);
+            // Place an arbitrary handler, we only need the URL construction to not error-out
+            handlers.put("javascript", new sun.net.www.protocol.http.Handler());
+        } catch (Exception e) {
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL, "Unable to install 'javascript:' URL protocol handler!");
+            OutputController.getLogger().log(e);
+        }
+    }
     /**
 …
     public static void main(String args[])
             throws IOException {
+        //we are polite, we reprint start arguments
+        OutputController.getLogger().log("startup arguments: ");
+        for (int i = 0; i < args.length; i++) {
+            String string = args[i];
+            OutputController.getLogger().log(i + ": "+string);
+        }
+        if (AppContext.getAppContext() == null) {
+            SunToolkit.createNewAppContext();
+        }
+        installDummyJavascriptProtocolHandler();
         if (!checkArgs(args)) {
+            System.exit(1);
+        }
+            JNLPRuntime.exit(1);
+        }
+        DeploymentConfiguration.move14AndOlderFilesTo15StructureCatched();
+        if (JavaConsole.isEnabled()) {
+            if ((args.length < 3) || !new File(args[2]).exists()) {
+                OutputController.getLogger().log(OutputController.Level.ERROR_ALL, "Warning, although console is on, plugin debug connection do not exists. No plugin information will be displayed in console (only java ones).");
+            } else {
+                JavaConsole.getConsole().createPluginReader(new File(args[2]));
+            }
+        }
         try {
             PluginStreamHandler streamHandler = connect(args);
-            boolean redirectStreams = System.getenv().containsKey("ICEDTEAPLUGIN_DEBUG");
-            // must be called before JNLPRuntime.initialize()
-            JNLPRuntime.setRedirectStreams(redirectStreams);
             PluginAppletSecurityContext sc = new PluginAppletSecurityContext(0);
 …
             setCookieHandler(streamHandler);
+            JavaConsole.getConsole().setClassLoaderInfoProvider(new JavaConsole.ClassLoaderInfoProvider() {
+                @Override
+                public Map<String, String> getLoaderInfo() {
+                    return PluginAppletSecurityContext.getLoaderInfo();
+                }
+            });
         } catch (Exception e) {
             e.printStackTrace();
             System.err.println("Something very bad happened. I don't know what to do, so I am going to exit :(");
             System.exit(1);
+            OutputController.getLogger().log(e);
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL, "Something very bad happened. I don't know what to do, so I am going to exit :(");
+            JNLPRuntime.exit(1);
+        }
+    }
 …
+        }
         // override the proxy selector set by JNLPRuntime
         ProxySelector.setDefault(new PluginProxySelector());
+        ProxySelector.setDefault(new PluginProxySelector(JNLPRuntime.getConfiguration()));
+    }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java

-              r348
+              r429
 /* VoidPluginCallRequest -- represent Java-to-JavaScript requests
+/*
    Copyright (C) 2008  Red Hat
 …
 import java.util.ArrayList;
 import java.util.LinkedList;
+import net.sourceforge.jnlp.util.logging.OutputController;
 class PluginMessageConsumer {
 …
+    }
-    public void notifyWorkerIsFree(PluginMessageHandlerWorker worker) {
-        consumerThread.interrupt();
+    }
     public void queue(String message) {
         synchronized (readQueue) {
 …
         // Wake that lazy consumer thread
         consumerThread.interrupt();
+        consumerThread.notifyHasWork();
+    }
     protected class ConsumerThread extends Thread {
+        public ConsumerThread() {
+            super("PluginMessageConsumer.ConsumerThread");
+        }
+        // Notify that either work is ready to do, or a worker is available
+        public synchronized void notifyHasWork() {
+            notifyAll();
+        }
+        // Wait a bit until either work is ready to do, or a worker is available
+        public synchronized void waitForWork() {
+            try {
+                // Do not wait indefinitely to avoid the potential of deadlock
+                wait(1000);
+            } catch (InterruptedException e) {
+                // Should not typically occur
+               OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+            }
+        }
         /**
 …
                     worker.setmessage(message);
                     worker.interrupt();
+                    worker.notifyHasWork();
                 } else {
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException ie) {
+                    }
+                    waitForWork();
+                }
+            }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java

-              r418
+              r429
 package sun.applet;
+import net.sourceforge.jnlp.util.logging.OutputController;
 class PluginMessageHandlerWorker extends Thread {
 …
     private final boolean isPriorityWorker;
     private final int id;
     private String message;
+    private volatile String message;
     private PluginStreamHandler streamHandler;
     private PluginMessageConsumer consumer;
+    public synchronized void notifyHasWork() {
+        notifyAll();
+    }
+    public synchronized void waitForWork() {
+        try {
+            // Do not wait indefinitely to avoid the potential of deadlock
+            wait(1000);
+        } catch (InterruptedException e) {
+            // Should not typically occur
+           OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
+    }
     public PluginMessageHandlerWorker(
 …
                 PluginStreamHandler streamHandler, int id,
                 boolean isPriorityWorker) {
+        super("PluginMessageHandlerWorker" + id);
         this.id = id;
 …
             } else {
+                waitForWork();
+                // Sleep when there is nothing to do
+                try {
+                    Thread.sleep(Integer.MAX_VALUE);
+                    PluginDebug.debug("Consumer thread ", id, " sleeping...");
+                } catch (InterruptedException ie) {
+                    PluginDebug.debug("Consumer thread ", id, " woken...");
+                    // nothing.. someone woke us up, see if there
+                    // is work to do
+                }
+                // Someone woke us up, see if there is work to do
+                // PluginDebug.debug("Consumer thread ", id, " woken...");
+            }
+        }
 …
         synchronized (this) {
             this.free = true;
-            // Signal the consumer that we are done in case it was waiting
-            consumer.notifyWorkerIsFree(this);
+        }
+    }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginObjectStore.java

-              r348
+              r429
     INSTANCE;
     private HashMap<Integer, Object> objects = new HashMap<Integer, Object>();
     private HashMap<Integer, Integer> counts = new HashMap<Integer, Integer>();
     private HashMap<Object, Integer> identifiers = new HashMap<Object, Integer>();
+    private final Map<Integer, Object> objects = new HashMap<Integer, Object>();
+    private final Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
+    private final Map<Object, Integer> identifiers = new HashMap<Object, Integer>();
     private final Object lock = new Object();
 …
     public Integer getIdentifier(Object object) {
+        if (object == null)
+            return 0;
         synchronized(lock) {
-            if (object == null)
-                return 0;
             return identifiers.get(object);
+        }
 …
     public boolean contains(Object object) {
         synchronized(lock) {
             if (object == null)
+        if (object != null) {
+            synchronized(lock) {
                 return identifiers.containsKey(object);
+            }
+        }
+        return false;
-            return false;
+        }
+    }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginProxyInfoRequest.java

-              r348
+              r429
 import java.net.URI;
+import net.sourceforge.jnlp.util.logging.OutputController;
 /**
 …
             // Nothing.. this is expected if there is no proxy
         } catch (Exception e) {
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginProxySelector.java

-              r348
+              r429
 package sun.applet;
+import java.io.UnsupportedEncodingException;
 import java.net.InetSocketAddress;
 import java.net.Proxy;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.List;
+import com.sun.jndi.toolkit.url.UrlUtil;
+import net.sourceforge.jnlp.config.DeploymentConfiguration;
 import net.sourceforge.jnlp.runtime.JNLPProxySelector;
+import net.sourceforge.jnlp.util.logging.OutputController;
 import net.sourceforge.jnlp.util.TimedHashMap;
 …
     private TimedHashMap<String, Proxy> proxyCache = new TimedHashMap<String, Proxy>();
+    public PluginProxySelector(DeploymentConfiguration config) {
+        super(config);
+    }
     /**
 …
         // Nothing usable in cache. Fetch info from browser
+        String requestURI;
+        try {
+            requestURI = convertUriSchemeForProxyQuery(uri);
+        } catch (Exception e) {
+            PluginDebug.debug("Cannot construct URL from ", uri.toString(), " ... falling back to DIRECT proxy");
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+            proxyList.add(Proxy.NO_PROXY);
+            return proxyList;
+        }
         Proxy proxy = Proxy.NO_PROXY;
         Object o = PluginAppletViewer.requestPluginProxyInfo(uri);
+        Object o = getProxyFromRemoteCallToBrowser(requestURI);
         // If the browser returned anything, try to parse it. If anything in the try block fails, the fallback is direct connection
 …
                     proxy = new Proxy(type, socketAddr);
                     String uriKey = uri.getScheme() + "://" + uri.getHost();
+                    String uriKey = computeKey(uri);
                     proxyCache.put(uriKey, proxy);
                 } else {
 …
+            }
         } catch (Exception e) {
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
 …
+    }
+    /** For tests to override */
+    protected Object getProxyFromRemoteCallToBrowser(String uri) {
+        return PluginAppletViewer.requestPluginProxyInfo(uri);
+    }
     /**
      * Checks to see if proxy information is already cached.
 …
      */
     private Proxy checkCache(URI uri) {
+        String uriKey = uri.getScheme() + "://" + uri.getHost();
+        String uriKey = computeKey(uri);
         if (proxyCache.get(uriKey) != null) {
             return proxyCache.get(uriKey);
 …
+    }
+    /** Compute a key to use for the proxy cache */
+    private String computeKey(URI uri) {
+        return uri.getScheme() + "://" + uri.getHost();
+    }
+    public static String convertUriSchemeForProxyQuery(URI uri) throws URISyntaxException, UnsupportedEncodingException {
+        // there is no easy way to get SOCKS proxy info. So, we tell mozilla that we want proxy for
+        // an HTTP uri in case of non http/ftp protocols. If we get back a SOCKS proxy, we can
+        // use that, if we get back an http proxy, we fallback to DIRECT connect
+        String scheme = uri.getScheme();
+        if (!scheme.startsWith("http") && !scheme.equals("ftp")) {
+            scheme = "http";
+        }
+        URI result = new URI(scheme, uri.getUserInfo(), uri.getHost(), uri.getPort(),
+                uri.getPath(), uri.getQuery(), uri.getFragment());
+        return UrlUtil.encode(result.toString(), "UTF-8");
+    }
+}

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginStreamHandler.java

-              r418
+              r429
 /* VoidPluginCallRequest -- represent Java-to-JavaScript requests
+/*
    Copyright (C) 2008  Red Hat
 …
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
-import java.net.MalformedURLException;
 import java.nio.charset.Charset;
 import javax.swing.SwingUtilities;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.runtime.Translator;
+import net.sourceforge.jnlp.util.logging.JavaConsole;
+import net.sourceforge.jnlp.util.logging.OutputController;
 public class PluginStreamHandler {
 …
     private RequestQueue queue = new RequestQueue();
-    private JavaConsole console = new JavaConsole();
     private PluginMessageConsumer consumer;
 …
+    public PluginStreamHandler(InputStream inputstream, OutputStream outputstream)
+            throws MalformedURLException, IOException {
+    public PluginStreamHandler(InputStream inputstream, OutputStream outputstream) {
         PluginDebug.debug("Current context CL=", Thread.currentThread().getContextClassLoader());
 …
     public void startProcessing() {
         Thread listenerThread = new Thread() {
+        Thread listenerThread = new Thread("PluginStreamHandlerListenerThread") {
             public void run() {
 …
                         AppletSecurityContextManager.dumpStore(0);
                         PluginDebug.debug("APPLETVIEWER: exiting appletviewer");
                         System.exit(0);
+                        JNLPRuntime.exit(0);
+                    }
+                }
 …
     private void handlePluginMessage(String message) {
         if (message.equals("plugin showconsole")) {
+            showConsole();
+            if (JavaConsole.isEnabled()){
+                JavaConsole.getConsole().showConsoleLater();
+            } else {
+                OutputController.getLogger().log(OutputController.Level.ERROR_ALL, Translator.R("DPJavaConsoleDisabledHint"));
+            }
         } else if (message.equals("plugin hideconsole")) {
+            hideConsole();
+            if (JavaConsole.isEnabled()){
+                JavaConsole.getConsole().hideConsoleLater();
+            } else {
+                OutputController.getLogger().log(OutputController.Level.ERROR_ALL, Translator.R("DPJavaConsoleDisabledHint"));
+            }
         } else {
             // else this is something that was specifically requested
 …
+     *
      * @return the read string
+     *
-     * @exception IOException if an error occurs
      */
     private String read() {
 …
                 AppletSecurityContextManager.dumpStore(0);
                 PluginDebug.debug("APPLETVIEWER: exiting appletviewer");
                 System.exit(0);
+                JNLPRuntime.exit(0);
+            }
         } catch (IOException e) {
             e.printStackTrace();
+            OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+        }
 …
+     *
      * @param message the message to write
+     *
-     * @exception IOException if an error occurs
      */
     public void write(String message) {
 …
                 // pipe may have closed
                 if (!shuttingDown) {
                     e.printStackTrace();
+                    OutputController.getLogger().log(OutputController.Level.ERROR_ALL,e);
+                }
 …
                 // we can do anymore. Don't hang around.
                 PluginDebug.debug("Unable to write to PIPE. APPLETVIEWER exiting");
                 System.exit(1);
+                JNLPRuntime.exit(1);
+            }
+        }
 …
         return;
+    }
-    private void showConsole() {
-        SwingUtilities.invokeLater(new Runnable() {
-            public void run() {
-                console.showConsole();
+            }
-        });
+    }
-    private void hideConsole() {
-        SwingUtilities.invokeLater(new Runnable() {
-            public void run() {
-                console.hideConsole();
+            }
-        });
+    }
+}

Context Navigation

Legend:

trunk/icedtea-web/plugin/icedteanp/IcedTeaJavaRequestProcessor.cc

trunk/icedtea-web/plugin/icedteanp/IcedTeaJavaRequestProcessor.h

trunk/icedtea-web/plugin/icedteanp/IcedTeaNPPlugin.cc

trunk/icedtea-web/plugin/icedteanp/IcedTeaNPPlugin.h

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginRequestProcessor.h

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginUtils.cc

trunk/icedtea-web/plugin/icedteanp/IcedTeaPluginUtils.h

trunk/icedtea-web/plugin/icedteanp/IcedTeaScriptablePluginObject.cc

trunk/icedtea-web/plugin/icedteanp/IcedTeaScriptablePluginObject.h

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSObject.java

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSRunnable.java

trunk/icedtea-web/plugin/icedteanp/java/netscape/javascript/JSUtil.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginAppletViewer.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginDebug.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginException.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMain.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMessageConsumer.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginMessageHandlerWorker.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginObjectStore.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginProxyInfoRequest.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginProxySelector.java

trunk/icedtea-web/plugin/icedteanp/java/sun/applet/PluginStreamHandler.java

Download in other formats: