-- a/ChangeLog Wed Aug 26 01:14:21 2009 -0400

++ b/ChangeLog Wed Aug 26 15:06:47 2009 -0400

-- a/plugin/icedteanp/IcedTeaJavaRequestProcessor.cc Wed Aug 26 

2009-08-26 Deepak Bhole <dbhole@redhat.com>

 * plugin/icedteanp/IcedTeaJavaRequestProcessor.cc

 (createJavaObjectFromVariant): Add conditional compilation blocks to

 handle new API along with old. Call renamed newObjectWithConstructor

 function.

 (newObject): New function. Creates an object based on the most optimum

 cost with arbitrary arguments.

 (newObjectWithConstructor): Renamed from newObject(). Also, take 

 an argument to provide to Java.

 * plugin/icedteanp/IcedTeaJavaRequestProcessor.h: Change as per above 

 file changes.

 * plugin/icedteanp/IcedTeaNPPlugin.cc: Include XPCOM specific headers 

 if xulrunner version is < 1.9.2. Instantiate internal Mozilla objects 

 if xulrunner < 1.9.2.

 (GCJ_New): Correctly account for documentbase length when allocating 

 memory to prevent corruption.

 (GCJ_Destroy): Remove old instance mappings when destroyed.

 (GCJ_GetJavaClass): Remove unused method.

 (get_cookie_info): Change object signature to include length result. 

 on xulrunner version, either use internal Mozilla API for fetching 

 info, or use NPN_GetValueForURL.

 (plugin_get_documentbase): Define for when xulrunner is >= 1.9.2.

 (consume_message): Deal with single proxy URL rather than components.

 Update to handle when xulrunner is >= 1.9.2

 (get_proxy_info): Change signature to deal with single url rather than

 components. Use NPN_GetValueForURL if xulrunner is >= 1.9.2.

 (NP_Initialize): Add pointers for getvalueforurl and setvalueforurl in 

 NPPluginFuncs table. Also, handle case for when browser provides the

 plugin .so name as the link location rather than target location.

 * plugin/icedteanp/IcedTeaNPPlugin.h: Include XPCOM specific headers 

 if xulrunner version is < 1.9.2.

 * plugin/icedteanp/IcedTeaPluginRequestProcessor.cc

 (eval): Use the new NPN_PluginThreadAsynCcall function to dispatch 

 to main thread asynchronously.

 (call): Same.

 (setMember): Same.

 (getMember): Same.

 (storeVariantInJava): Handle changed API when xulrunner >= 1.9.2

 (_setMember): Account for changes in the way that the callerpacks

 arguments.

 (_getMember): Same.

 (_call): Same.

 (_eval): Same.

 * plugin/icedteanp/IcedTeaPluginRequestProcessor.h: Include Mozilla

 specific headers only if xulrunner is < 1.9.2. Remove old ThreadData

 struct and add new AyncCallThreadData struct that contains results and

 arguments.

 * plugin/icedteanp/IcedTeaPluginUtils.cc

 (getSourceFromInstance): Provide null source location due to lack of a

 secure way to get documentbase.

 (printNPVariant): Account for change API in xulrunner 1.9.2.

 (NPVariantToString): Same.

 * plugin/icedteanp/IcedTeaPluginUtils.h: Include Mozilla specific 

 only if xulrunner is < 1.9.2.

 * plugin/icedteanp/IcedTeaScriptablePluginObject.cc

 (invoke): Pass exception over to JS engine.

 (construct): Implement object construction.

 * plugin/icedteanp/IcedTeaScriptablePluginObject.h: Include Mozilla

 specific headers only if xulrunner is < 1.9.2.

 * plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java

 (getMatchingConstructor): New method, returns a matching constructor 

 on arguments.

 (getMatchingConstructors): New helper method for 

 * plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java

 (handleMessage): Handle new type of call, "NewObjectWithConstructor".

 (checkPermission): Disable checks for the time being, as NPRuntime 

 not allow cross-site calling anyway.

 * plugin/icedteanp/java/sun/applet/PluginAppletViewer.java

 (setStatus): Remove newlines from status messages.

 * plugin/icedteanp/sun/applet/PluginCookieInfoRequest.java

 (parseReturn): Store cookie info as a string rather than a list of

 HttpCookie objects.

 (getObject): Return the new cookie string.

 * plugin/icedteanp/sun/applet/PluginCookieManager.java: New file, 

 CookieManager as is set as the default cookie manager for the plugin.

 * plugin/icedteanp/sun/applet/PluginCookieStore.java : Deleted. New 

 uses a custom cookiemanager rather than just a custom store.

 * plugin/icedteanp/sun/applet/PluginMain.java

 (init): Wire in the new cookie manager.

#if MOZILLA_VERSION_COLLAPSED < 1090200

#else

 stringArg += NPVARIANT_TO_STRING(variant).UTF8Characters;

#endif

 java_result = java_request.newObject("[System]", jsObjectClassID, 

 java_result = java_request.newObjectWithConstructor("[System]", 

JavaRequestProcessor::newObject(std::string source, std::string 

JavaRequestProcessor::newObject(std::string source, std::string 

 const NPVariant* args, int argCount)

{

 JavaRequestProcessor* java_request;

 std::string message = std::string();

 this->instance = 0; // context is always 0 (needed for java-side 

 this->reference = IcedTeaPluginUtilities::getReference();

 IcedTeaPluginUtilities::constructMessagePrefix(0, reference, source, 

 message += " NewObject ";

 message += classID;

 message += " ";

 // First, we need to load the arguments into the java-side table

 for (int i=0; i < argCount; i++) {

 int objectID = createJavaObjectFromVariant(args[i]);

 if (objectID == 0)

 {

 result->error_occurred = true;

 result->error_msg->append("Unable to create arguments");

 return result;

 }

 char* id = (char*) malloc(sizeof(char)*32);

 sprintf(id, "%d", objectID);

 message += id;

 message += " ";

 free(id);

 }

 postAndWaitForResponse(message);

 IcedTeaPluginUtilities::releaseReference();

 return result;

}

JavaResultData*

JavaRequestProcessor::newObjectWithConstructor(std::string source, 

 message += " NewObject ";

 message += " NewObjectWithConstructor ";

 message += objectID;

 message += classID;

-- a/plugin/icedteanp/IcedTeaJavaRequestProcessor.h Wed Aug 26 01:14:21 

 /* Creates a new object */

 /* Creates a new object with choosable constructor */

 std::string objectID, std::string methodID,

 std::string classID,

 const NPVariant* args, int numArgs);

 /* Creates a new object when constructor is undetermined */

 JavaResultData* newObjectWithConstructor(std::string source, 

 std::string methodID,

-- a/plugin/icedteanp/IcedTeaNPPlugin.cc Wed Aug 26 01:14:21 2009 -0400

++ b/plugin/icedteanp/IcedTeaNPPlugin.cc Wed Aug 26 15:06:47 2009 -0400

 #include "IcedTeaScriptablePluginObject.h"

#endif

GQuark ITNP_PLUGIN_ERROR = g_quark_from_string("IcedTeaNPPlugin");

#if MOZILLA_VERSION_COLLAPSED < 1090200

#endif

NS_IMETHODIMP get_cookie_info(const char* siteAddr, char** 

NPError get_cookie_info(const char* siteAddr, char** cookieString, 

void get_proxy_info(const char* siteAddr, char** proxy_scheme, char** 

NPError get_proxy_info(const char* siteAddr, char** proxy, uint32_t* 

 tag_message = (gchar*) malloc(strlen(applet_tag)*sizeof(gchar) + 

 tag_message = (gchar*) malloc(strlen(applet_tag)*sizeof(gchar) + 

jref

NPError

GCJ_GetJavaClass (void)

get_cookie_info(const char* siteAddr, char** cookieString, uint32_t* 

{

{

 PLUGIN_DEBUG_0ARG ("GCJ_GetJavaClass\n");

#if MOZILLA_VERSION_COLLAPSED < 1090200

 PLUGIN_DEBUG_0ARG ("GCJ_GetJavaClass return\n");

 return 0;

}

NS_IMETHODIMP

get_cookie_info(const char* siteAddr, char** cookieString)

{

 return NS_ERROR_FAILURE;

 return NPERR_GENERIC_ERROR;

 return NS_ERROR_FAILURE;

 return NPERR_GENERIC_ERROR;

 return NS_ERROR_FAILURE;

 return NPERR_GENERIC_ERROR;

 return NS_ERROR_FAILURE;

 return NPERR_GENERIC_ERROR;

 return NS_OK;

#else

}

 // getvalueforurl needs an NPP instance. Quite frankly, there is no 

 // to know which instance needs the information, as applets on Java 

 // be multi-threaded and the thread making a proxy.cookie request 

 // easily tracked.

 // Fortunately, XULRunner does not care about the instance as long as 

 // valid. So we just pick the first valid one and use it. Proxy/Cookie

 // information is not instance specific anyway, it is URL specific.

 if (browser_functions.getvalueforurl)

 {

 GHashTableIter iter;

 gpointer id, instance;

 g_hash_table_iter_init (&iter, instance_to_id_map);

 g_hash_table_iter_next (&iter, &instance, &id);

 return browser_functions.getvalueforurl((NPP) instance, NPNURLVCookie, 

 } else

 {

 return NPERR_GENERIC_ERROR;

 }

#endif

 return NPERR_NO_ERROR;

}

 gchar* proxy_scheme = (gchar*) malloc(sizeof(gchar)*32);

 gchar* proxy;

 gchar* proxy_host = (gchar*) malloc(sizeof(gchar)*64);

 uint32_t len;

 gchar* proxy_port = (gchar*) malloc(sizeof(gchar)*8);

 GError *error = g_error_new(ITNP_PLUGIN_ERROR, 0, "");

 get_proxy_info(decoded_url, &proxy_scheme, &proxy_host, &proxy_port, 

#if MOZILLA_VERSION_COLLAPSED < 1090200

 proxy = (char*) malloc(sizeof(char)*2048);

#endif

 if (error->code == 0)

 if (get_proxy_info(decoded_url, &proxy, &len) == NPERR_NO_ERROR)

 proxy_info = g_strconcat (proxy_info, proxy_scheme, " ", proxy_host, " 

 proxy_info = g_strconcat (proxy_info, proxy, NULL);

 g_free(proxy_scheme);

 proxy_scheme = NULL;

#if MOZILLA_VERSION_COLLAPSED < 1090200

 g_free(proxy_host);

 g_free(proxy);

 proxy_host = NULL;

 proxy = NULL;

 g_free(proxy_port);

#endif

 proxy_port = NULL;

 GError *error = g_error_new(ITNP_PLUGIN_ERROR, 0, "");

 uint32_t len;

 if (get_cookie_info(decoded_url, &cookie_string, &len) == 

 if (get_cookie_info(decoded_url, &cookie_string) == NS_OK)

}

#else

void get_proxy_info(const char* siteAddr, char** proxy_scheme, char** 

#endif

{

}

NPError

get_proxy_info(const char* siteAddr, char** proxy, uint32_t* len)

{

#if MOZILLA_VERSION_COLLAPSED < 1090200

 error->code = 1;

 return NPERR_GENERIC_ERROR;

 return;

 error->code = 1;

 return NPERR_GENERIC_ERROR;

 return;

 error->code = 1;

 return NPERR_GENERIC_ERROR;

 return;

 error->code = 1;

 return NPERR_GENERIC_ERROR;

 return;

 // pack information in return variables

 snprintf(*proxy, sizeof(char)*1024, "%s://%s:%d", ptype.get(), 

 snprintf(*proxy_scheme, sizeof(char)*32, "%s", ptype.get());

 *len = strlen(*proxy);

 snprintf(*proxy_host, sizeof(char)*64, "%s", ipAddr.get());

 snprintf(*proxy_port, sizeof(char)*8, "%d", pport);

 PLUGIN_DEBUG_2ARG("Proxy info for %s: %s\n", siteAddr, *proxy);

 PLUGIN_DEBUG_4ARG("Proxy info for %s: %s %s %s\n", siteAddr, 

#else

 if (browser_functions.getvalueforurl)

 {

 // As in get_cookie_info, we use the first active instance

 GHashTableIter iter;

 gpointer id, instance;

 g_hash_table_iter_init (&iter, instance_to_id_map);

 g_hash_table_iter_next (&iter, &instance, &id);

 browser_functions.getvalueforurl((NPP) instance, NPNURLVProxy, 

 } else

 {

 return NPERR_GENERIC_ERROR;

 }

#endif

 return NPERR_NO_ERROR;

 PLUGIN_DEBUG_0ARG ("plugin_test_appletviewer\n");

 PLUGIN_DEBUG_1ARG ("plugin_test_appletviewer: %s\n", 

 PLUGIN_ERROR ("Invalid browser function table.");

 fprintf (stderr, "ERROR: Invalid browser function table. Some 

 return NPERR_INVALID_FUNCTABLE_ERROR;

 filename = g_strdup (info.dli_fname);

 filename = (gchar*) malloc(sizeof(gchar)*1024);

 filename_size = readlink(info.dli_fname, filename, 1023);

 if (filename_size >= 0)

 {

 filename[filename_size] = '\0';

 }

 printf("FILENAME=%s\n", filename);

 if (filename_size <= 0)

 {

 free(filename);

 filename = g_strdup(info.dli_fname);

 }

 PLUGIN_DEBUG_4ARG(".so is located at: %s and the link points to: %s. 

-- a/plugin/icedteanp/IcedTeaNPPlugin.h Wed Aug 26 01:14:21 2009 -0400

++ b/plugin/icedteanp/IcedTeaNPPlugin.h Wed Aug 26 15:06:47 2009 -0400

#include <nsThreadUtils.h>

#include <nsThreadUtils.h>

#if MOZILLA_VERSION_COLLAPSED < 1090200

int get_id_from_instance(NPP* instance);

int get_id_from_instance(NPP instance);

-- a/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc Wed Aug 26 

++ b/plugin/icedteanp/IcedTeaPluginRequestProcessor.cc Wed Aug 26 

 std::vector<void*> internal_request_params = std::vector<void*>();

 AyncCallThreadData thread_data = AyncCallThreadData();

 ResultData rdata = ResultData();

 thread_data.result_ready = false;

 nsCOMPtr<nsIRunnable> event;

 thread_data.parameters = std::vector<void*>();

 thread_data.result = std::string();

 internal_request_params.push_back(instance);

 internal_request_params.push_back(window_ptr);

 thread_data.parameters.push_back(instance);

 internal_request_params.push_back(&script);

 thread_data.parameters.push_back(window_ptr);

 thread_data.parameters.push_back(&script);

 rdata.result_ready = false;

 event = new IcedTeaRunnableMethod(&_eval, (void*) 

 browser_functions.pluginthreadasynccall(instance, &_eval, 

 NS_DispatchToMainThread(event, 0);

 while (!thread_data.result_ready) usleep(2000); // Wait till result is 

 while (!rdata.result_ready) usleep(2000); // Wait till result is ready

 NPVariant* result_variant = (NPVariant*) 

 NPVariant* result_variant = (NPVariant*) 

 std::vector<void*> internal_request_params = std::vector<void*>();

 AyncCallThreadData thread_data = AyncCallThreadData();

 ResultData rdata = ResultData();

 thread_data.result_ready = false;

 nsCOMPtr<nsIRunnable> event;

 thread_data.parameters = std::vector<void*>();

 thread_data.result = std::string();

 internal_request_params.push_back(instance);

 internal_request_params.push_back(window_ptr);

 thread_data.parameters.push_back(instance);

 internal_request_params.push_back(&window_function_name);

 thread_data.parameters.push_back(window_ptr);

 internal_request_params.push_back(&arg_count);

 thread_data.parameters.push_back(&window_function_name);

 internal_request_params.push_back(args_array);

 thread_data.parameters.push_back(&arg_count);

 thread_data.parameters.push_back(args_array);

 printf("Packing %p [%p] %p %s@%p %p %p\n", instance, 

 printf("Packing %p [%p] %p %s@%p %p %p\n", instance, 

 rdata.result_ready = false;

 browser_functions.pluginthreadasynccall(instance, &_call, 

 event = new IcedTeaRunnableMethod(&_call, (void*) 

 NS_DispatchToMainThread(event, 0);

 while (!thread_data.result_ready) usleep(2000); // wait till ready

 while (!rdata.result_ready) usleep(2000); // wait till ready

 NPVariant* result_variant = (NPVariant*) 

 NPVariant* result_variant = (NPVariant*) 

 std::string member_ptr_str = std::string();

 std::vector<std::string*>* internal_request_params = new 

 NPP instance;

 goto cleanup;

 //goto cleanup;

 goto cleanup;

 //goto cleanup;

 goto cleanup;

 //goto cleanup;

 IcedTeaPluginUtilities::JSIDToString(member, &member_ptr_str);

 AyncCallThreadData thread_data = AyncCallThreadData();

 internal_request_params->push_back(&member_ptr_str);

 thread_data.result_ready = false;

 internal_request_params->push_back(&property_name);

 thread_data.parameters = std::vector<void*>();

 internal_request_params->push_back(&type);

 thread_data.result = std::string();

 internal_request_params->push_back(&value);

 thread_data.parameters.push_back(instance);

 rdata->result_ready = false;

 thread_data.parameters.push_back(member);

 event = new IcedTeaRunnableMethod(&_setMember, (void*) 

 thread_data.parameters.push_back(&property_name);

 NS_DispatchToMainThread(event, 0);

 thread_data.parameters.push_back(&type);

 thread_data.parameters.push_back(&value);

 while (!rdata->result_ready) usleep(2000); // wait till ready

 browser_functions.pluginthreadasynccall(instance, &_setMember, 

 while (!thread_data.result_ready) usleep(2000); // wait till ready

 ResultData member_data;

 NPObject* parent_ptr;

 std::string parent_id = std::string();

 nsCOMPtr<nsIRunnable> event;

 std::vector<std::string*> internal_request_params = 

 int instance;

 int instance_id;

 instance = atoi(message_parts->at(1).c_str());

 instance_id = atoi(message_parts->at(1).c_str());

 parent_id += message_parts->at(3);

 parent_ptr = reinterpret_cast <NPObject*> 

 internal_request_params.push_back(&parent_id);

 AyncCallThreadData thread_data = AyncCallThreadData();

 internal_request_params.push_back(java_result->return_string);

 thread_data.result_ready = false;

 thread_data.parameters = std::vector<void*>();

 member_data = ResultData();

 thread_data.result = std::string();

 member_data.result_ready = false;

 NPP instance = 

 event = new IcedTeaRunnableMethod(&_getMember, (void*) 

 thread_data.parameters.push_back(instance);

 NS_DispatchToMainThread(event, 0);

 thread_data.parameters.push_back(parent_ptr);

 thread_data.parameters.push_back(java_result->return_string);

 while (!member_data.result_ready) usleep(2000); // wait till ready

 browser_functions.pluginthreadasynccall(instance, &_getMember, 

 PLUGIN_DEBUG_1ARG("Member PTR after internal request: %s\n", 

 while (!thread_data.result_ready) usleep(2000); // wait till ready

 PLUGIN_DEBUG_1ARG("Member PTR after internal request: %s\n", 

 args.push_back(*(member_data.return_string));

 args.push_back(thread_data.result);

 java_result = java_request.newObject("",

 java_result = java_request.newObjectWithConstructor("",

 java_result = java_request.newObject("",

 java_result = java_request.newObjectWithConstructor("",

 java_result = java_request.newObject("",

 java_result = java_request.newObjectWithConstructor("",

 java_result = java_request.newObject("",

 java_result = java_request.newObjectWithConstructor("",

 java_result = java_request.newObject("",

 java_result = java_request.newObjectWithConstructor("",

void*

void

_setMember(void* data, void* result)

_setMember(void* data)

 std::vector<std::string*>* message_parts = 

 std::vector<void*> parameters = ((AyncCallThreadData*) 

 instance = (NPP) parameters.at(0);

 ", message_parts);

 member = (NPObject*) parameters.at(1);

 property_name = (std::string*) parameters.at(2);

 member = reinterpret_cast <NPObject*> 

 type = (std::string*) parameters.at(3);

 property_name = message_parts->at(1);

 value = (std::string*) parameters.at(4);

 type = message_parts->at(2);

 value = message_parts->at(3);

 instance = IcedTeaPluginUtilities::getInstanceFromMemberPtr(member);

 ((AyncCallThreadData*) data)->result_ready = true;

 ((ResultData*) result)->result_ready = true;

}

void*

_getMember(void* data, void* result)

{

 std::string* parent_ptr_str;

 std::vector<std::string*>* message_parts = 

 std::vector<void*> parameters = ((AyncCallThreadData*) 

 instance = (NPP) parameters.at(0);

 ", message_parts);

 parent_ptr = (NPObject*) parameters.at(1);

 member_name = (std::string*) parameters.at(2);

 parent_ptr_str = message_parts->at(0);

 member_name = message_parts->at(1);

 ((ResultData*) result)->return_string = new std::string();

 ((AyncCallThreadData*) data)->result.append(member_ptr_str);

 ((ResultData*) result)->return_string->append(member_ptr_str);

 ((AyncCallThreadData*) data)->result_ready = true;

 ((ResultData*) result)->result_ready = true;

void*

void

_eval(void* data, void* result)

_eval(void* data)

 ((ResultData*) result)->return_string = new std::string();

#if MOZILLA_VERSION_COLLAPSED < 1090200

 ((ResultData*) result)->return_string->append(eval_result_ptr_str);

#else

 ((ResultData*) result)->result_ready = true;

 script.UTF8Characters = script_str->c_str();

 script.UTF8Length = script_str->size();

 PLUGIN_DEBUG_1ARG("Evaluating: %s\n", script.UTF8Characters);

#endif

void*

 ((AyncCallThreadData*) data)->result.append(eval_result_ptr_str);

_call(void* data, void* result)

 ((AyncCallThreadData*) data)->result_ready = true;

 ((ResultData*) result)->return_string = new std::string();

 ((AyncCallThreadData*) data)->result.append(call_result_ptr_str);

 ((ResultData*) result)->return_string->append(call_result_ptr_str);

 ((AyncCallThreadData*) data)->result_ready = true;

 ((ResultData*) result)->result_ready = true;

-- a/plugin/icedteanp/IcedTeaPluginRequestProcessor.h Wed Aug 26 

++ b/plugin/icedteanp/IcedTeaPluginRequestProcessor.h Wed Aug 26 

typedef struct struct_thread_data

typedef struct aync_call_thread_data

 std::vector<std::string>* message_parts;

 std::vector<void*> parameters;

 std::string* source;

 std::string result;

} ThreadData;

 bool result_ready;

} AyncCallThreadData;

void* _getMember(void* message_parts, void* result);

void _getMember(void* data);

void* _setMember(void* message_parts, void* result);

void _setMember(void* data);

void* _call(void* data, void* result);

void _call(void* data);

void* _eval(void* data, void* result);

void _eval(void* data);

-- a/plugin/icedteanp/IcedTeaPluginUtils.cc Wed Aug 26 01:14:21 2009 

++ b/plugin/icedteanp/IcedTeaPluginUtils.cc Wed Aug 26 15:06:47 2009 

0400

gchar*

const gchar*

 GCJPluginData* data = (GCJPluginData*) instance->pdata;

 // At the moment, src cannot be securely fetched via NPAPI

 return data->source;

 // See:

}

 // 

 // Since we use the insecure window.location.href attribute to compute

 // source, we cannot use it to make security decisions. Therefore,

 // instance associated source will always return empty

 //GCJPluginData* data = (GCJPluginData*) instance->pdata;

 //return (data->source) ? data->source : "";

 return "http://null.null";

}

-- a/plugin/icedteanp/IcedTeaPluginUtils.h Wed Aug 26 01:14:21 2009 

#if MOZILLA_VERSION_COLLAPSED < 1090200

0400

#else

 str = (char*) 

 sprintf(str, "%s", NPVARIANT_TO_STRING(variant).UTF8Characters);

#endif

0400

++ b/plugin/icedteanp/IcedTeaPluginUtils.h Wed Aug 26 15:06:47 2009 

 static gchar* getSourceFromInstance(NPP instance);

 static const gchar* getSourceFromInstance(NPP instance);

-- a/plugin/icedteanp/IcedTeaScriptablePluginObject.cc Wed Aug 26 

++ b/plugin/icedteanp/IcedTeaScriptablePluginObject.cc Wed Aug 26 

 printf ("** Unimplemented: IcedTeaScriptableJavaObject::construct 

 NPUTF8* method_name = "";

 return false;

}

 // Extract arg type array

 PLUGIN_DEBUG_1ARG("IcedTeaScriptableJavaObject::construct %s. Args 

 for (int i=0; i < argCount; i++)

 {

 IcedTeaPluginUtilities::printNPVariant(args[i]);

 }

 JavaResultData* java_result;

 JavaRequestProcessor java_request = JavaRequestProcessor();

 NPObject* obj;

 std::string class_id = ((IcedTeaScriptableJavaObject*) 

 NPP instance = 

 java_result = java_request.newObject(

 IcedTeaPluginUtilities::getSourceFromInstance(instance),

 class_id,

 args,

 argCount);

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

 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(

 IcedTeaPluginUtilities::getInstanceFromMemberPtr(npobj),

 return_obj_class_id, return_obj_instance_id);

 OBJECT_TO_NPVARIANT(obj, *result);

 PLUGIN_DEBUG_0ARG("IcedTeaScriptableJavaObject::construct 

 return true;

}

-- a/plugin/icedteanp/IcedTeaScriptablePluginObject.h Wed Aug 26 

++ b/plugin/icedteanp/IcedTeaScriptablePluginObject.h Wed Aug 26 

-- a/plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java Wed 

#if MOZILLA_VERSION_COLLAPSED < 1090200

#else

#include <npapi.h>

#include <npruntime.h>

#endif

 // First type full match, second Class -> Primitive

 public FooClass() {}

 public void foo(Boolean b, int i) {

 public FooClass(Boolean b, int i) {}

 }

 public FooClass(Boolean b, Integer i) {}

 // Full match

 public void foo(Boolean b, Integer i) {

 public FooClass(Boolean b, short s) {}

 }

 public FooClass(String s, int i) {}

 // First type full match, second Class -> Primitive ambiguity

 public FooClass(String s, Integer i) {}

 public void foo(Boolean b, short s) {

 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) {}

-- a/plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java 

++ b/plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java 

 } else if (message.startsWith("NewObject")) {

 store.getIdentifier(newArray));

 Integer methodID = parseCall(args[2], null, Integer.class);

 } else if (message.startsWith("NewObjectWithConstructor")) {

 final Constructor m = (Constructor) store.getObject(methodID);

 String[] args = message.split(" ");

 Class[] argTypes = m.getParameterTypes();

 Integer classID = parseCall(args[1], null, Integer.class);

 Integer methodID = parseCall(args[2], null, Integer.class);

 // System.out.println ("NEWOBJ: HERE1");

 Object[] arguments = new Object[argTypes.length];

 final Constructor m = (Constructor) store.getObject(methodID);

 // System.out.println ("NEWOBJ: HERE2");

 Class[] argTypes = m.getParameterTypes();

 for (int i = 0; i < argTypes.length; i++) {

 arguments[i] = parseArgs(args[3 + i], argTypes[i]);

 // System.out.println ("NEWOBJ: HERE1");

 // System.out.println ("NEWOBJ: GOT ARG: " + arguments[i]);

 Object[] arguments = new Object[argTypes.length];

 }

 // System.out.println ("NEWOBJ: HERE2");

 for (int i = 0; i < argTypes.length; i++) {

 final Object[] fArguments = arguments;

 arguments[i] = parseArgs(args[3 + i], argTypes[i]);

 AccessControlContext acc = callContext != null ? callContext : 

 // System.out.println ("NEWOBJ: GOT ARG: " + arguments[i]);

 }

 final Object[] fArguments = arguments;

 AccessControlContext acc = callContext != null ? callContext : 

 Class c = (Class) store.getObject(classID);

 checkPermission(src, c, acc);

 Object ret = AccessController.doPrivileged(new 

 public Object run() {

 try {

 return m.newInstance(fArguments);

 } catch (Throwable t) {

 return t;

 }

 }

 }, acc);

 if (ret instanceof Throwable)

 throw (Throwable) ret;

 store.reference(ret);

 write(reference, "NewObject " + store.getIdentifier(ret));

 } else if (message.startsWith("NewObject")) {

 return m.newInstance(fArguments);

 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],

 null, Integer.class));

 PluginDebug.debug("GOT ARG: " + arguments[i + 1]);

 }

 Object[] matchingConstructorAndArgs = MethodOverloadResolver

 .getMatchingConstructor(arguments);

 if (matchingConstructorAndArgs == null) {

 write(reference,

 "Error: No suitable constructor with matching args found");

 return;

 }

 Object[] castedArgs = new Object[matchingConstructorAndArgs.length - 

 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();

 }

 PluginDebug.debug("Calling constructor on class " + c +

 " with " + collapsedArgs);

 AccessControlContext acc = callContext != null ? callContext : 

 if (!jsSrc.equals("file://") && !jsSrc.equals("[System]") && 

 // NPRuntime does not allow cross-site calling. The code below is kept

 acc.checkPermission(new BrowserReadPermission());

 // in case that changes in the future..

 }

-- a/plugin/icedteanp/java/sun/applet/PluginAppletViewer.java Wed Aug 

 //if (!jsSrc.equals("file://") && !jsSrc.equals("[System]") && 

 // acc.checkPermission(new BrowserReadPermission());

 //}

-- a/plugin/icedteanp/java/sun/applet/PluginCookieInfoRequest.java Wed 

 // For statuses, we cannot have a newline

 status = status.replace("\n", " ");

 List<HttpCookie> cookieObjects = new ArrayList<HttpCookie>();

 String cookieString = new String();

 String encodedURI = cookieInfo.split(" ")[2];

 cookieString = cookieInfo.substring(cookieInfo.indexOf(' ')+1);

 cookieInfo = cookieInfo.substring(cookieInfo.indexOf(' ')+1);

 URI siteURI;

 try

 {

 siteURI = new URI(UrlUtil.decode(encodedURI, "UTF-8"));

 } catch (Exception e)

 {

 e.printStackTrace();

 return;

 }

 if (cookieInfo != null && cookieInfo.length() > 0)

 {

 String[] cookies = cookieInfo.split(";");

 for (int i = 0; i < cookies.length; i++)

 {

 ArrayList l = new ArrayList();

 String cookie = cookies[i];

 cookie = cookie.trim();

 String cookieName;

 String cookieValue;

 if (cookie.indexOf("=") > 0) {

 cookieName = cookie.substring(0, cookie.indexOf("="));

 cookieValue = cookie.substring(cookie.indexOf("=")+1);

 HttpCookie httpCookieObj = new HttpCookie(cookieName, cookieValue);

 httpCookieObj.setPath(siteURI.getPath());

 httpCookieObj.setVersion(0); // force v0

 PluginDebug.debug("Adding cookie info COOKIEN=" + cookieName + " and 

 cookieObjects.add(httpCookieObj);

 }

 }

 }

 public List<HttpCookie> getObject() {

 public String getObject() {

 return this.cookieObjects;

 return this.cookieString;

-- a/plugin/icedteanp/java/sun/applet/PluginMain.java Wed Aug 26 

++ b/plugin/icedteanp/java/sun/applet/PluginMain.java Wed Aug 26 

 CookieManager ckManager = new CookieManager(new PluginCookieStore(), 

 CookieManager ckManager = new PluginCookieManager();

-- /dev/null Thu Jan 01 00:00:00 1970 +0000

++ b/plugin/icedteanp/java/sun/applet/PluginCookieManager.java Wed Aug 

-- a/plugin/icedteanp/java/sun/applet/PluginCookieStore.java Wed Aug 26 

/* PluginCookieManager -- Cookie manager for the plugin

 Copyright (C) 2009 Red Hat

This file is part of IcedTea.

IcedTea is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

IcedTea is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with IcedTea; see the file COPYING. If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library. Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module. An independent module is a module which is not derived from

or based on this library. If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so. If you do not wish to do so, delete this

exception statement from your version. */

package sun.applet;

import java.io.IOException;

import java.net.CookieManager;

import java.net.HttpCookie;

import java.net.URI;

import java.util.Collections;

import java.util.List;

import java.util.Map;

public class PluginCookieManager extends CookieManager

{

 public Map<String, List<String>> get(URI uri,

 Map<String, List<String>> requestHeaders) throws IOException {

 // pre-condition check

 if (uri == null || requestHeaders == null) {

 throw new IllegalArgumentException("Argument is null");

 }

 Map<String, List<String>> cookieMap = new java.util.HashMap<String, 

 String cookies = (String) PluginAppletViewer

 .requestPluginCookieInfo(uri);

 List<String> cookieHeader = new java.util.ArrayList<String>();

 if (cookies != null && cookies.length() > 0)

 cookieHeader.add(cookies);

 // Add anything else that mozilla didn't add

 for (HttpCookie cookie : getCookieStore().get(uri)) {

 // apply path-matches rule (RFC 2965 sec. 3.3.4)

 if (pathMatches(uri.getPath(), cookie.getPath())) {

 cookieHeader.add(cookie.toString());

 }

 }

 cookieMap.put("Cookie", cookieHeader);

 return Collections.unmodifiableMap(cookieMap);

 }

 private boolean pathMatches(String path, String pathToMatchWith) {

 if (path == pathToMatchWith)

 return true;

 if (path == null || pathToMatchWith == null)

 return false;

 if (path.startsWith(pathToMatchWith))

 return true;

 return false;

 }

}