diff --git a/mozilla/modules/plugin/base/public/MANIFEST b/mozilla/modules/plugin/base/public/MANIFEST index f2df2871b22..098ba392335 100644 --- a/mozilla/modules/plugin/base/public/MANIFEST +++ b/mozilla/modules/plugin/base/public/MANIFEST @@ -50,3 +50,5 @@ nsIPluginStreamInfo.h nsIPluginInputStream.h nsIPluginInputStream2.h nsPIPluginHost.h +nsPluginLogging.h + diff --git a/mozilla/modules/plugin/base/public/Makefile.in b/mozilla/modules/plugin/base/public/Makefile.in index b22397a2649..304629d6c52 100644 --- a/mozilla/modules/plugin/base/public/Makefile.in +++ b/mozilla/modules/plugin/base/public/Makefile.in @@ -54,6 +54,7 @@ EXPORTS = \ nsplugindefs.h \ nsICookieStorage.h \ nsPIPluginHost.h \ + nsPluginLogging.h $(NULL) # DEPRECATED -- remove before we ship 5.0 diff --git a/mozilla/modules/plugin/base/public/makefile.win b/mozilla/modules/plugin/base/public/makefile.win index a34f1e5f1c7..2f00f2a8c71 100644 --- a/mozilla/modules/plugin/base/public/makefile.win +++ b/mozilla/modules/plugin/base/public/makefile.win @@ -17,49 +17,50 @@ -DEPTH = ..\..\..\.. +DEPTH = ..\..\..\.. -MODULE = plugin +MODULE = plugin -EXPORTS = \ - nsIEventHandler.h \ - nsIFileUtilities.h \ - nsIMalloc.h \ - nsIPlugin.h \ - nsIPluginInstance.h \ - nsIPluginInstancePeer.h \ - nsIPluginInstancePeer2.h \ - nsIPluginManager2.h \ - nsIPluginTagInfo.h \ - nsIPluginTagInfo2.h \ - nsIWindowlessPlugInstPeer.h \ - nsIPluginStreamListener.h \ - nsIPluginStreamListener2.h \ - nsIPluginStreamInfo.h \ - nsplugin.h \ - nsplugindefs.h \ - nsICookieStorage.h \ - nsPIPluginHost.h +EXPORTS = \ + nsIEventHandler.h \ + nsIFileUtilities.h \ + nsIMalloc.h \ + nsIPlugin.h \ + nsIPluginInstance.h \ + nsIPluginInstancePeer.h \ + nsIPluginInstancePeer2.h \ + nsIPluginManager2.h \ + nsIPluginTagInfo.h \ + nsIPluginTagInfo2.h \ + nsIWindowlessPlugInstPeer.h \ + nsIPluginStreamListener.h \ + nsIPluginStreamListener2.h \ + nsIPluginStreamInfo.h \ + nsplugin.h \ + nsplugindefs.h \ + nsICookieStorage.h \ + nsPIPluginHost.h \ + nsPluginLogging.h # DEPRECATED -- remove before we ship 5.0 EXPORTS = $(EXPORTS) \ - nsIPluginStream.h \ - nsIPluginStreamPeer.h \ - nsIPluginStreamPeer2.h \ - nsISeekablePluginStreamPeer.h \ - nsILiveConnectPlugin.h \ - nsILiveConnectPlugInstPeer.h \ - nsIJRILiveConnectPlugin.h \ - nsIJRILiveConnectPlugInstPeer.h \ + nsIPluginStream.h \ + nsIPluginStreamPeer.h \ + nsIPluginStreamPeer2.h \ + nsISeekablePluginStreamPeer.h \ + nsILiveConnectPlugin.h \ + nsILiveConnectPlugInstPeer.h \ + nsIJRILiveConnectPlugin.h \ + nsIJRILiveConnectPlugInstPeer.h \ nsIPluginInputStream.h \ nsIPluginInputStream2.h -XPIDLSRCS = \ - .\nsIScriptablePlugin.idl \ - .\nsIHTTPHeaderListener.idl \ - .\nsIPluginManager.idl \ - .\nsIPluginViewer.idl \ - $(NULL) +XPIDLSRCS = \ + .\nsIScriptablePlugin.idl \ + .\nsIHTTPHeaderListener.idl \ + .\nsIPluginManager.idl \ + .\nsIPluginViewer.idl \ + $(NULL) include <$(DEPTH)/config/rules.mak> diff --git a/mozilla/modules/plugin/base/public/nsPluginLogging.h b/mozilla/modules/plugin/base/public/nsPluginLogging.h new file mode 100644 index 00000000000..ea848c6d62d --- /dev/null +++ b/mozilla/modules/plugin/base/public/nsPluginLogging.h @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * The contents of this file are subject to the Netscape Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + */ + +/* Plugin Module Logging usage instructions and includes */ +//////////////////////////////////////////////////////////////////////////////// +#ifndef nsPluginLogging_h__ +#define nsPluginLogging_h__ + +#ifdef PR_LOGGING +#include "prlog.h" + +#define PLUGIN_LOGGING 1 // master compile-time switch for pluging logging + +//////////////////////////////////////////////////////////////////////////////// +// Basic Plugin Logging Usage Instructions +// +// 1. Set this environment variable: NSPR_LOG_MODULES=: + +// Choose the and from this list (no quotes): + +// Log Names +#define NPN_LOG_NAME "PluginNPN" +#define NPP_LOG_NAME "PluginNPP" +#define PLUGIN_LOG_NAME "Plugin" + +// Levels +#define PLUGIN_LOG_ALWAYS 1 +#define PLUGIN_LOG_BASIC 3 +#define PLUGIN_LOG_NORMAL 5 +#define PLUGIN_LOG_NOISY 7 +#define PLUGIN_LOG_MAX 9 + +// 2. You can combine logs and levels by seperating them with a comma: +// My favorite Win32 Example: SET NSPR_LOG_MODULES=Plugin:5,PluginNPP:5,PluginNPN:5 + +// 3. Instead of output going to the console, you can log to a file. Additionally, set the +// NSPR_LOG_FILE environment variable to point to the full path of a file. +// My favorite Win32 Example: SET NSPR_LOG_FILE=c:\temp\pluginLog.txt + +// 4. For complete information see the NSPR Reference: +// http://www.mozilla.org/projects/nspr/reference/html/prlog.html + + +#ifdef PLUGIN_LOGGING + +class nsPluginLogging +{ +public: + static PRLogModuleInfo* gNPNLog; // 4.x NP API, calls into navigator + static PRLogModuleInfo* gNPPLog; // 4.x NP API, calls into plugin + static PRLogModuleInfo* gPluginLog; // general plugin log +}; + +#endif // PLUGIN_LOGGING + +#endif // PR_LOGGING + +// Quick-use macros +#ifdef PLUGIN_LOGGING + #define NPN_PLUGIN_LOG(a, b) \ + PR_BEGIN_MACRO \ + PR_LOG(nsPluginLogging::gNPNLog, a, b); \ + PR_LogFlush(); \ + PR_END_MACRO +#else + #define NPN_PLUGIN_LOG(a, b) +#endif + +#ifdef PLUGIN_LOGGING + #define NPP_PLUGIN_LOG(a, b) \ + PR_BEGIN_MACRO \ + PR_LOG(nsPluginLogging::gNPPLog, a, b); \ + PR_LogFlush(); \ + PR_END_MACRO +#else + #define NPP_PLUGIN_LOG(a, b) +#endif + +#ifdef PLUGIN_LOGGING + #define PLUGIN_LOG(a, b) \ + PR_BEGIN_MACRO \ + PR_LOG(nsPluginLogging::gPluginLog, a, b); \ + PR_LogFlush(); \ + PR_END_MACRO +#else + #define PLUGIN_LOG(a, b) +#endif + +#endif // nsPluginLogging_h__ + diff --git a/mozilla/modules/plugin/base/src/ns4xPlugin.cpp b/mozilla/modules/plugin/base/src/ns4xPlugin.cpp index e2ed6e6cf73..af5a4030cc2 100644 --- a/mozilla/modules/plugin/base/src/ns4xPlugin.cpp +++ b/mozilla/modules/plugin/base/src/ns4xPlugin.cpp @@ -32,67 +32,18 @@ #include "nsIPluginStreamListener.h" #include "nsPluginsDir.h" #include "nsPluginSafety.h" +#include "nsIPref.h" +#include "nsPluginLogging.h" #ifdef XP_MAC #include #endif -#include "nsIPref.h" +//////////////////////////////////////////////////////////////////////// +// CID's && IID's static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID); static NS_DEFINE_IID(kCPluginManagerCID, NS_PLUGINMANAGER_CID); - -//////////////////////////////////////////////////////////////////////// - -NPNetscapeFuncs ns4xPlugin::CALLBACKS; -static nsIServiceManager* gServiceMgr = nsnull; -static nsIMemory* gMalloc = nsnull; - -void -ns4xPlugin::CheckClassInitialized(void) -{ - static PRBool initialized = FALSE; - - if (initialized) - return; - - // XXX It'd be nice to make this const and initialize it - // statically... - CALLBACKS.size = sizeof(CALLBACKS); - CALLBACKS.version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; - - CALLBACKS.geturl = NewNPN_GetURLProc(_geturl); - CALLBACKS.posturl = NewNPN_PostURLProc(_posturl); - CALLBACKS.requestread = NewNPN_RequestReadProc(_requestread); - CALLBACKS.newstream = NewNPN_NewStreamProc(_newstream); - CALLBACKS.write = NewNPN_WriteProc(_write); - CALLBACKS.destroystream = NewNPN_DestroyStreamProc(_destroystream); - CALLBACKS.status = NewNPN_StatusProc(_status); - CALLBACKS.uagent = NewNPN_UserAgentProc(_useragent); - CALLBACKS.memalloc = NewNPN_MemAllocProc(_memalloc); - CALLBACKS.memfree = NewNPN_MemFreeProc(_memfree); - CALLBACKS.memflush = NewNPN_MemFlushProc(_memflush); - CALLBACKS.reloadplugins = NewNPN_ReloadPluginsProc(_reloadplugins); - CALLBACKS.getJavaEnv = NewNPN_GetJavaEnvProc(_getJavaEnv); - CALLBACKS.getJavaPeer = NewNPN_GetJavaPeerProc(_getJavaPeer); - CALLBACKS.geturlnotify = NewNPN_GetURLNotifyProc(_geturlnotify); - CALLBACKS.posturlnotify = NewNPN_PostURLNotifyProc(_posturlnotify); - CALLBACKS.getvalue = NewNPN_GetValueProc(_getvalue); - CALLBACKS.setvalue = NewNPN_SetValueProc(_setvalue); - CALLBACKS.invalidaterect = NewNPN_InvalidateRectProc(_invalidaterect); - CALLBACKS.invalidateregion = NewNPN_InvalidateRegionProc(_invalidateregion); - CALLBACKS.forceredraw = NewNPN_ForceRedrawProc(_forceredraw); - - initialized = TRUE; -} - -//////////////////////////////////////////////////////////////////////// -// nsISupports stuff - -NS_IMPL_ADDREF(ns4xPlugin); -NS_IMPL_RELEASE(ns4xPlugin); - -//static NS_DEFINE_IID(kILiveConnectPluginIID, NS_ILIVECONNECTPLUGIN_IID); static NS_DEFINE_IID(kIPluginIID, NS_IPLUGIN_IID); static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID); static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); @@ -103,7 +54,60 @@ static NS_DEFINE_IID(kMemoryCID, NS_MEMORY_CID); static NS_DEFINE_IID(kIMemoryIID, NS_IMEMORY_IID); static NS_DEFINE_IID(kIPluginStreamListenerIID, NS_IPLUGINSTREAMLISTENER_IID); + //////////////////////////////////////////////////////////////////////// +// Globals +NPNetscapeFuncs ns4xPlugin::CALLBACKS; +static nsIServiceManager* gServiceMgr = nsnull; +static nsIMemory* gMalloc = nsnull; + +//////////////////////////////////////////////////////////////////////// +void +ns4xPlugin::CheckClassInitialized(void) +{ + static PRBool initialized = FALSE; + + if (initialized) + return; + + // XXX It'd be nice to make this const and initialize it statically... + CALLBACKS.size = sizeof(CALLBACKS); + CALLBACKS.version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + + CALLBACKS.geturl = NewNPN_GetURLProc(_geturl); + CALLBACKS.posturl = NewNPN_PostURLProc(_posturl); + CALLBACKS.requestread = NewNPN_RequestReadProc(_requestread); + CALLBACKS.newstream = NewNPN_NewStreamProc(_newstream); + CALLBACKS.write = NewNPN_WriteProc(_write); + CALLBACKS.destroystream = NewNPN_DestroyStreamProc(_destroystream); + CALLBACKS.status = NewNPN_StatusProc(_status); + CALLBACKS.uagent = NewNPN_UserAgentProc(_useragent); + CALLBACKS.memalloc = NewNPN_MemAllocProc(_memalloc); + CALLBACKS.memfree = NewNPN_MemFreeProc(_memfree); + CALLBACKS.memflush = NewNPN_MemFlushProc(_memflush); + CALLBACKS.reloadplugins = NewNPN_ReloadPluginsProc(_reloadplugins); + CALLBACKS.getJavaEnv = NewNPN_GetJavaEnvProc(_getJavaEnv); + CALLBACKS.getJavaPeer = NewNPN_GetJavaPeerProc(_getJavaPeer); + CALLBACKS.geturlnotify = NewNPN_GetURLNotifyProc(_geturlnotify); + CALLBACKS.posturlnotify = NewNPN_PostURLNotifyProc(_posturlnotify); + CALLBACKS.getvalue = NewNPN_GetValueProc(_getvalue); + CALLBACKS.setvalue = NewNPN_SetValueProc(_setvalue); + CALLBACKS.invalidaterect = NewNPN_InvalidateRectProc(_invalidaterect); + CALLBACKS.invalidateregion = NewNPN_InvalidateRegionProc(_invalidateregion); + CALLBACKS.forceredraw = NewNPN_ForceRedrawProc(_forceredraw); + + initialized = TRUE; + + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,("NPN callbacks initialized\n")); +} + + +//////////////////////////////////////////////////////////////////////// +// nsISupports stuff +NS_IMPL_ISUPPORTS2(ns4xPlugin, + nsIPlugin, + nsIFactory); + ns4xPlugin::ns4xPlugin(NPPluginFuncs* callbacks, PRLibrary* aLibrary, NP_PLUGINSHUTDOWN aShutdown, nsIServiceManager* serviceMgr) { @@ -115,18 +119,18 @@ ns4xPlugin::ns4xPlugin(NPPluginFuncs* callbacks, PRLibrary* aLibrary, NP_PLUGINS #if defined(XP_WIN) // On Windows (and Mac) we need to keep a direct reference to the fCallbacks and NOT // just copy the struct. See Bugzilla 85334 - + NP_GETENTRYPOINTS pfnGetEntryPoints = (NP_GETENTRYPOINTS)PR_FindSymbol(aLibrary, "NP_GetEntryPoints"); if (!pfnGetEntryPoints) return; - + fCallbacks.size = sizeof(fCallbacks); - + nsresult result = pfnGetEntryPoints(&fCallbacks); NS_ASSERTION( NS_OK == result,"Failed to get callbacks"); - + NS_ASSERTION(HIBYTE(fCallbacks.version) >= NP_VERSION_MAJOR, "callback version is less than NP version"); @@ -145,6 +149,8 @@ ns4xPlugin::ns4xPlugin(NPPluginFuncs* callbacks, PRLibrary* aLibrary, NP_PLUGINS &fCallbacks, &fShutdownEntry), aLibrary); + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPP MainEntryProc called, return=%d\n",error)); + if(error != NPERR_NO_ERROR || ((fCallbacks.version >> 8) < NP_VERSION_MAJOR)) { return; @@ -158,77 +164,49 @@ ns4xPlugin::ns4xPlugin(NPPluginFuncs* callbacks, PRLibrary* aLibrary, NP_PLUGINS } +//////////////////////////////////////////////////////////////////////// ns4xPlugin::~ns4xPlugin(void) { //reset the callbacks list - memset((void*) &fCallbacks, 0, sizeof(fCallbacks)); + memset((void*) &fCallbacks, 0, sizeof(fCallbacks)); } -/* static */ + +//////////////////////////////////////////////////////////////////////// void ns4xPlugin::ReleaseStatics() { NS_IF_RELEASE(gMalloc); } -nsresult -ns4xPlugin::QueryInterface(const nsIID& iid, void** instance) -{ - if (instance == NULL) - return NS_ERROR_NULL_POINTER; - - if (iid.Equals(kIPluginIID)) - { - *instance = (void *)(nsIPlugin *)this; - AddRef(); - return NS_OK; - } - - if (iid.Equals(kIFactoryIID)) - { - *instance = (void *)(nsIFactory *)this; - AddRef(); - return NS_OK; - } - - if (iid.Equals(kISupportsIID)) - { - *instance = (void *)(nsISupports *)this; - AddRef(); - return NS_OK; - } - - return NS_NOINTERFACE; -} #ifdef XP_MAC +//////////////////////////////////////////////////////////////////////// static char* p2cstrdup(StringPtr pstr) { - int len = pstr[0]; - char* cstr = new char[len + 1]; - if (cstr != NULL) { - ::BlockMoveData(pstr + 1, cstr, len); - cstr[len] = '\0'; - } - return cstr; + int len = pstr[0]; + char* cstr = new char[len + 1]; + if (cstr != NULL) { + ::BlockMoveData(pstr + 1, cstr, len); + cstr[len] = '\0'; + } + return cstr; } -void -ns4xPlugin::SetPluginRefNum(short aRefNum) +//////////////////////////////////////////////////////////////////////// +void ns4xPlugin::SetPluginRefNum(short aRefNum) { - fPluginRefNum = aRefNum; + fPluginRefNum = aRefNum; } #endif + //////////////////////////////////////////////////////////////////////// // Static factory method. // - -/* - CreatePlugin() - -------------- - Handles the initialization of old, 4x style plugins. Creates the ns4xPlugin object. - One ns4xPlugin object exists per Plugin (not instance). -*/ +///CreatePlugin() +//-------------- +//Handles the initialization of old, 4x style plugins. Creates the ns4xPlugin object. +//One ns4xPlugin object exists per Plugin (not instance). nsresult ns4xPlugin::CreatePlugin(nsIServiceManager* aServiceMgr, @@ -236,128 +214,112 @@ ns4xPlugin::CreatePlugin(nsIServiceManager* aServiceMgr, PRLibrary* aLibrary, nsIPlugin** aResult) { - CheckClassInitialized(); + CheckClassInitialized(); - // set up the MemAllocator service now because it might be used by the plugin - if (aServiceMgr != nsnull) { - if (nsnull == gMalloc) - aServiceMgr->GetService(kMemoryCID, kIMemoryIID, (nsISupports**)&gMalloc); - } - -#ifdef DEBUG_edburns - printf("debug: edburns ns4xPlugin::CreatePlugin\n"); -#endif + // set up the MemAllocator service now because it might be used by the plugin + if (aServiceMgr != nsnull) { + if (nsnull == gMalloc) + aServiceMgr->GetService(kMemoryCID, kIMemoryIID, (nsISupports**)&gMalloc); + } #ifdef XP_UNIX - ns4xPlugin *plptr; + ns4xPlugin *plptr; - NPPluginFuncs callbacks; - memset((void*) &callbacks, 0, sizeof(callbacks)); - callbacks.size = sizeof(callbacks); + NPPluginFuncs callbacks; + memset((void*) &callbacks, 0, sizeof(callbacks)); + callbacks.size = sizeof(callbacks); -#ifdef DEBUG_edburns - printf("debug: edburns ns4xPlugin::CreatePlugin: cleared callbacks\n"); -#endif + NP_PLUGINSHUTDOWN pfnShutdown = (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); - NP_PLUGINSHUTDOWN pfnShutdown = - (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); + // create the new plugin handler + *aResult = plptr = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); - // create the new plugin handler - *aResult = plptr = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); + if (*aResult == NULL) + return NS_ERROR_OUT_OF_MEMORY; - if (*aResult == NULL) - return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(*aResult); - NS_ADDREF(*aResult); + // we must init here because the plugin may call NPN functions + // when we call into the NP_Initialize entry point - NPN functions + // require that mBrowserManager be set up + plptr->Initialize(); - // we must init here because the plugin may call NPN functions - // when we call into the NP_Initialize entry point - NPN functions - // require that mBrowserManager be set up - plptr->Initialize(); + NP_PLUGINUNIXINIT pfnInitialize = (NP_PLUGINUNIXINIT)PR_FindSymbol(aLibrary, "NP_Initialize"); - NP_PLUGINUNIXINIT pfnInitialize = - (NP_PLUGINUNIXINIT)PR_FindSymbol(aLibrary, "NP_Initialize"); + if (pfnInitialize == NULL) + return NS_ERROR_UNEXPECTED; // XXX Right error? - if (pfnInitialize == NULL) - return NS_ERROR_UNEXPECTED; // XXX Right error? + if (pfnInitialize(&(ns4xPlugin::CALLBACKS),&callbacks) != NS_OK) + return NS_ERROR_UNEXPECTED; - if (pfnInitialize(&(ns4xPlugin::CALLBACKS),&callbacks) != NS_OK) - return NS_ERROR_UNEXPECTED; - -#ifdef DEBUG_edburns - printf("debug: edburns: ns4xPlugin::CreatePlugin: callbacks->newstream: %p\n", - callbacks.newstream); -#endif - - // now copy function table back to ns4xPlugin instance - memcpy((void*) &(plptr->fCallbacks), (void*)&callbacks, sizeof(callbacks)); + // now copy function table back to ns4xPlugin instance + memcpy((void*) &(plptr->fCallbacks), (void*)&callbacks, sizeof(callbacks)); #endif #if defined(XP_PC) && !defined(XP_WIN) - // XXX this probably should be factored out and - // just use trailing XP_WIN. - NP_GETENTRYPOINTS pfnGetEntryPoints = - (NP_GETENTRYPOINTS)PR_FindSymbol(aLibrary, "NP_GetEntryPoints"); + // XXX this probably should be factored out and + // just use trailing XP_WIN. + NP_GETENTRYPOINTS pfnGetEntryPoints = + (NP_GETENTRYPOINTS)PR_FindSymbol(aLibrary, "NP_GetEntryPoints"); - if (pfnGetEntryPoints == NULL) - return NS_ERROR_FAILURE; + if (pfnGetEntryPoints == NULL) + return NS_ERROR_FAILURE; - NPPluginFuncs callbacks; - memset((void*) &callbacks, 0, sizeof(callbacks)); + NPPluginFuncs callbacks; + memset((void*) &callbacks, 0, sizeof(callbacks)); - callbacks.size = sizeof(callbacks); + callbacks.size = sizeof(callbacks); - if (pfnGetEntryPoints(&callbacks) != NS_OK) - return NS_ERROR_FAILURE; // XXX + if (pfnGetEntryPoints(&callbacks) != NS_OK) + return NS_ERROR_FAILURE; // XXX - if (HIBYTE(callbacks.version) < NP_VERSION_MAJOR) - return NS_ERROR_FAILURE; + if (HIBYTE(callbacks.version) < NP_VERSION_MAJOR) + return NS_ERROR_FAILURE; - NP_PLUGINSHUTDOWN pfnShutdown = - (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); + NP_PLUGINSHUTDOWN pfnShutdown = + (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); - // create the new plugin handler - *aResult = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); + // create the new plugin handler + *aResult = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); #elif defined(XP_WIN) - // Note: on Windows, we must use the fCallback because plugins may change - // the function table. The Shockwave installer makes changes in the table while running - *aResult = new ns4xPlugin(nsnull, aLibrary, nsnull, aServiceMgr); + // Note: on Windows, we must use the fCallback because plugins may change + // the function table. The Shockwave installer makes changes in the table while running + *aResult = new ns4xPlugin(nsnull, aLibrary, nsnull, aServiceMgr); #endif #ifdef XP_PC - if (*aResult == NULL) - return NS_ERROR_OUT_OF_MEMORY; + if (*aResult == NULL) + return NS_ERROR_OUT_OF_MEMORY; - NS_ADDREF(*aResult); + NS_ADDREF(*aResult); - // we must init here because the plugin may call NPN functions - // when we call into the NP_Initialize entry point - NPN functions - // require that mBrowserManager be set up - if (NS_FAILED((*aResult)->Initialize())) - { - NS_RELEASE(*aResult); - return NS_ERROR_FAILURE; - } + // we must init here because the plugin may call NPN functions + // when we call into the NP_Initialize entry point - NPN functions + // require that mBrowserManager be set up + if (NS_FAILED((*aResult)->Initialize())) { + NS_RELEASE(*aResult); + return NS_ERROR_FAILURE; + } - // the NP_Initialize entry point was misnamed as NP_PluginInit, - // early in plugin project development. Its correct name is - // documented now, and new developers expect it to work. However, - // I don't want to break the plugins already in the field, so - // we'll accept either name + // the NP_Initialize entry point was misnamed as NP_PluginInit, + // early in plugin project development. Its correct name is + // documented now, and new developers expect it to work. However, + // I don't want to break the plugins already in the field, so + // we'll accept either name - NP_PLUGININIT pfnInitialize = - (NP_PLUGININIT)PR_FindSymbol(aLibrary, "NP_Initialize"); + NP_PLUGININIT pfnInitialize = + (NP_PLUGININIT)PR_FindSymbol(aLibrary, "NP_Initialize"); - if (!pfnInitialize) { - pfnInitialize = - (NP_PLUGININIT)PR_FindSymbol(aLibrary, "NP_PluginInit"); - } + if (!pfnInitialize) { + pfnInitialize = + (NP_PLUGININIT)PR_FindSymbol(aLibrary, "NP_PluginInit"); + } - if (pfnInitialize == NULL) - return NS_ERROR_UNEXPECTED; // XXX Right error? + if (pfnInitialize == NULL) + return NS_ERROR_UNEXPECTED; // XXX Right error? - if (pfnInitialize(&(ns4xPlugin::CALLBACKS)) != NS_OK) - return NS_ERROR_UNEXPECTED; + if (pfnInitialize(&(ns4xPlugin::CALLBACKS)) != NS_OK) + return NS_ERROR_UNEXPECTED; #endif #if defined(XP_MAC) @@ -385,7 +347,7 @@ ns4xPlugin::CreatePlugin(nsIServiceManager* aServiceMgr, } } } - + // if we didn't find it, try locally if (!found) { @@ -431,6 +393,10 @@ ns4xPlugin::CreatePlugin(nsIServiceManager* aServiceMgr, &(ns4xPlugin::CALLBACKS), &callbacks, &pfnShutdown), fLibrary); + + NPP_PLUGIN_LOG(PLUGIN_LOG_BASIC, + ("NPP MainEntryProc called: this=%p, return=%d\n",this,error)); + if(error != NPERR_NO_ERROR) return NS_ERROR_FAILURE; @@ -449,81 +415,78 @@ ns4xPlugin::CreatePlugin(nsIServiceManager* aServiceMgr, *aResult = plugin; NS_ADDREF(*aResult); - if (NS_FAILED((*aResult)->Initialize())) - { + if (NS_FAILED((*aResult)->Initialize())) { NS_RELEASE(*aResult); return NS_ERROR_FAILURE; } - + plugin->SetPluginRefNum(pluginRefNum); #endif // XP_MAC #ifdef XP_BEOS -// I just copied UNIX version. -// Makoto Hamanaka + // I just copied UNIX version. + // Makoto Hamanaka - ns4xPlugin *plptr; + ns4xPlugin *plptr; - NPPluginFuncs callbacks; - memset((void*) &callbacks, 0, sizeof(callbacks)); - callbacks.size = sizeof(callbacks); + NPPluginFuncs callbacks; + memset((void*) &callbacks, 0, sizeof(callbacks)); + callbacks.size = sizeof(callbacks); - NP_PLUGINSHUTDOWN pfnShutdown = - (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); + NP_PLUGINSHUTDOWN pfnShutdown = + (NP_PLUGINSHUTDOWN)PR_FindSymbol(aLibrary, "NP_Shutdown"); - // create the new plugin handler - *aResult = plptr = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); + // create the new plugin handler + *aResult = plptr = new ns4xPlugin(&callbacks, aLibrary, pfnShutdown, aServiceMgr); - if (*aResult == NULL) - return NS_ERROR_OUT_OF_MEMORY; + if (*aResult == NULL) + return NS_ERROR_OUT_OF_MEMORY; - NS_ADDREF(*aResult); + NS_ADDREF(*aResult); - // we must init here because the plugin may call NPN functions - // when we call into the NP_Initialize entry point - NPN functions - // require that mBrowserManager be set up - plptr->Initialize(); + // we must init here because the plugin may call NPN functions + // when we call into the NP_Initialize entry point - NPN functions + // require that mBrowserManager be set up + plptr->Initialize(); - NP_PLUGINUNIXINIT pfnInitialize = - (NP_PLUGINUNIXINIT)PR_FindSymbol(aLibrary, "NP_Initialize"); + NP_PLUGINUNIXINIT pfnInitialize = + (NP_PLUGINUNIXINIT)PR_FindSymbol(aLibrary, "NP_Initialize"); - if (pfnInitialize == NULL) - return NS_ERROR_FAILURE; + if (pfnInitialize == NULL) + return NS_ERROR_FAILURE; - if (pfnInitialize(&(ns4xPlugin::CALLBACKS),&callbacks) != NS_OK) - return NS_ERROR_FAILURE; + if (pfnInitialize(&(ns4xPlugin::CALLBACKS),&callbacks) != NS_OK) + return NS_ERROR_FAILURE; - // now copy function table back to ns4xPlugin instance - memcpy((void*) &(plptr->fCallbacks), (void*)&callbacks, sizeof(callbacks)); + // now copy function table back to ns4xPlugin instance + memcpy((void*) &(plptr->fCallbacks), (void*)&callbacks, sizeof(callbacks)); #endif - return NS_OK; + return NS_OK; } - -/* - CreateInstance() - ---------------- - Creates a ns4xPluginInstance object. -*/ +//////////////////////////////////////////////////////////////////////// +//CreateInstance() +//---------------- +//Creates a ns4xPluginInstance object. nsresult ns4xPlugin :: CreateInstance(nsISupports *aOuter, const nsIID &aIID, void **aResult) -{ - if (aResult == NULL) { - return NS_ERROR_NULL_POINTER; - } +{ + if (aResult == NULL) { + return NS_ERROR_NULL_POINTER; + } + + *aResult = NULL; - *aResult = NULL; - // XXX This is suspicuous! ns4xPluginInstance *inst = new ns4xPluginInstance(&fCallbacks, fLibrary); if (inst == NULL) { - return NS_ERROR_OUT_OF_MEMORY; - } + return NS_ERROR_OUT_OF_MEMORY; + } NS_ADDREF(inst); // Stabilize @@ -531,22 +494,29 @@ nsresult ns4xPlugin :: CreateInstance(nsISupports *aOuter, NS_RELEASE(inst); // Destabilize and avoid leaks. Avoid calling delete - return res; -} + return res; +} + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPlugin :: LockFactory(PRBool aLock) { // Not implemented in simplest case. return NS_OK; } -NS_METHOD ns4xPlugin :: CreatePluginInstance(nsISupports *aOuter, REFNSIID aIID, - const char* aPluginMIMEType, - void **aResult) + +//////////////////////////////////////////////////////////////////////// +NS_METHOD ns4xPlugin :: CreatePluginInstance(nsISupports *aOuter, + REFNSIID aIID, + const char *aPluginMIMEType, + void **aResult) { return CreateInstance(aOuter, aIID, aResult); } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPlugin::Initialize(void) { @@ -555,17 +525,18 @@ ns4xPlugin::Initialize(void) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPlugin::Shutdown(void) { - if (nsnull != fShutdownEntry) - { -#ifdef DEBUG_edburns - printf("shutting down plugin %08x\n",(int)this); -#endif + NPP_PLUGIN_LOG(PLUGIN_LOG_BASIC, + ("NPP Shutdown to be called: this=%p\n",this)); + + if (nsnull != fShutdownEntry) { #ifdef XP_MAC - CallNPP_ShutdownProc(fShutdownEntry); - ::CloseResFile(fPluginRefNum); + CallNPP_ShutdownProc(fShutdownEntry); + ::CloseResFile(fPluginRefNum); #else NS_TRY_SAFE_CALL_VOID(fShutdownEntry(), fLibrary); #endif @@ -576,25 +547,29 @@ ns4xPlugin::Shutdown(void) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPlugin::GetMIMEDescription(const char* *resultingDesc) { -#ifdef DEBUG_edburns - printf("plugin getmimedescription called\n"); -#endif const char* (*npGetMIMEDescrpition)() = (const char* (*)()) PR_FindSymbol(fLibrary, "NP_GetMIMEDescription"); *resultingDesc = npGetMIMEDescrpition ? npGetMIMEDescrpition() : ""; + + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("ns4xPlugin::GetMIMEDescription called: this=%p, result=%s\n",this, *resultingDesc)); + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPlugin::GetValue(nsPluginVariable variable, void *value) { -#ifdef DEBUG_edburns - printf("plugin getvalue %d called\n", variable); -#endif + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("ns4xPlugin::GetValue called: this=%p, variable=%d\n",this,variable)); NPError (*npGetValue)(void*, nsPluginVariable, void*) = (NPError (*)(void*, nsPluginVariable, void*)) PR_FindSymbol(fLibrary, "NP_GetValue"); @@ -607,6 +582,7 @@ ns4xPlugin::GetValue(nsPluginVariable variable, void *value) } } + //////////////////////////////////////////////////////////////////////// // // Static callbacks that get routed back through the new C++ API @@ -615,8 +591,11 @@ ns4xPlugin::GetValue(nsPluginVariable variable, void *value) NPError NP_EXPORT _geturl(NPP npp, const char* relativeURL, const char* target) { - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_GetURL: npp=%p, target=%s, url=%s\n", (void *)npp, target, relativeURL)); + + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; @@ -627,285 +606,306 @@ _geturl(NPP npp, const char* relativeURL, const char* target) return NPERR_INVALID_INSTANCE_ERROR; if(gServiceMgr == nsnull) - return NPERR_GENERIC_ERROR; + return NPERR_GENERIC_ERROR; - nsIPluginStreamListener* listener = nsnull; - if(target == nsnull) - inst->NewStream(&listener); + nsIPluginStreamListener* listener = nsnull; + if(target == nsnull) + inst->NewStream(&listener); nsIPluginManager * pm; gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); - if(pm->GetURL(inst, relativeURL, target, listener) != NS_OK) - return NPERR_GENERIC_ERROR; + if(pm->GetURL(inst, relativeURL, target, listener) != NS_OK) + return NPERR_GENERIC_ERROR; NS_RELEASE(pm); - return NPERR_NO_ERROR; + return NPERR_NO_ERROR; } -NPError NP_EXPORT -_geturlnotify(NPP npp, const char* relativeURL, const char* target, - void* notifyData) -{ - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; - - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - - NS_ASSERTION(inst != NULL, "null instance"); - NS_ASSERTION(gServiceMgr != NULL, "null service manager"); - - if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; - - if(gServiceMgr == nsnull) - return NPERR_GENERIC_ERROR; - - nsIPluginStreamListener* listener = nsnull; - if(target == nsnull) - ((ns4xPluginInstance*)inst)->NewNotifyStream(&listener, notifyData); - - nsIPluginManager * pm; - gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); - - if(pm->GetURL(inst, relativeURL, target, listener) != NS_OK) - return NPERR_GENERIC_ERROR; - - NS_RELEASE(pm); - - return NPERR_NO_ERROR; -} - -NPError NP_EXPORT -_posturlnotify(NPP npp, const char* relativeURL, const char *target, - uint32 len, const char *buf, NPBool file, - void* notifyData) -{ - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; - - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - - NS_ASSERTION(inst != NULL, "null instance"); - NS_ASSERTION(gServiceMgr != NULL, "null service manager"); - - if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; - - if(gServiceMgr == nsnull) - return NPERR_GENERIC_ERROR; - - nsIPluginStreamListener* listener = nsnull; - if(target == nsnull) - ((ns4xPluginInstance*)inst)->NewNotifyStream(&listener, notifyData); - - nsIPluginManager * pm; - gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); - - if(pm->PostURL(inst, relativeURL, len, buf, file, target, listener) != NS_OK) - return NPERR_GENERIC_ERROR; - - NS_RELEASE(pm); - - return NPERR_NO_ERROR; -} - - -NPError NP_EXPORT -_posturl(NPP npp, const char* relativeURL, const char *target, uint32 len, - const char *buf, NPBool file) -{ - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; - - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - - NS_ASSERTION(inst != NULL, "null instance"); - NS_ASSERTION(gServiceMgr != NULL, "null service manager"); - - if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; - - if(gServiceMgr == nsnull) - return NPERR_GENERIC_ERROR; - - nsIPluginStreamListener* listener = nsnull; - if(target == nsnull) - inst->NewStream(&listener); - - nsIPluginManager * pm; - gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); - - if(pm->PostURL(inst, relativeURL, len, buf, file, target, listener) != NS_OK) - return NPERR_GENERIC_ERROR; - - NS_RELEASE(pm); - - return NPERR_NO_ERROR; -} //////////////////////////////////////////////////////////////////////// +NPError NP_EXPORT +_geturlnotify(NPP npp, + const char* relativeURL, + const char* target, + void* notifyData) +{ + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_GetURLNotify: npp=%p, target=%s, notify=%p, url=%s\n", + (void*)npp, target, notifyData, relativeURL)); + + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; + + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + + NS_ASSERTION(inst != NULL, "null instance"); + NS_ASSERTION(gServiceMgr != NULL, "null service manager"); + + if (inst == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if(gServiceMgr == nsnull) + return NPERR_GENERIC_ERROR; + + nsIPluginStreamListener* listener = nsnull; + if(target == nsnull) + ((ns4xPluginInstance*)inst)->NewNotifyStream(&listener, notifyData); + + nsIPluginManager * pm; + gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); + + if(pm->GetURL(inst, relativeURL, target, listener) != NS_OK) + return NPERR_GENERIC_ERROR; + + NS_RELEASE(pm); + + return NPERR_NO_ERROR; +} + + +//////////////////////////////////////////////////////////////////////// +NPError NP_EXPORT +_posturlnotify(NPP npp, + const char *relativeURL, + const char *target, + uint32 len, + const char *buf, + NPBool file, + void *notifyData) +{ + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_PostURLNotify: npp=%p, target=%s, len=%d, file=%d, notify=%p, url=%s, buf=%s\n", + (void*)npp, target, len, file, notifyData, relativeURL, buf)); + + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; + + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + + NS_ASSERTION(inst != NULL, "null instance"); + NS_ASSERTION(gServiceMgr != NULL, "null service manager"); + + if (inst == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if(gServiceMgr == nsnull) + return NPERR_GENERIC_ERROR; + + nsIPluginStreamListener* listener = nsnull; + if(target == nsnull) + ((ns4xPluginInstance*)inst)->NewNotifyStream(&listener, notifyData); + + nsIPluginManager * pm; + gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); + + if(pm->PostURL(inst, relativeURL, len, buf, file, target, listener) != NS_OK) + return NPERR_GENERIC_ERROR; + + NS_RELEASE(pm); + + return NPERR_NO_ERROR; +} + + +//////////////////////////////////////////////////////////////////////// +NPError NP_EXPORT +_posturl(NPP npp, + const char *relativeURL, + const char *target, + uint32 len, + const char *buf, + NPBool file) +{ + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_PostURL: npp=%p, target=%s, file=%d, len=%d, url=%s, buf=%s\n", + (void*)npp, target, file, len, relativeURL, buf)); + + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; + + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + + NS_ASSERTION(inst != NULL, "null instance"); + NS_ASSERTION(gServiceMgr != NULL, "null service manager"); + + if (inst == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + if(gServiceMgr == nsnull) + return NPERR_GENERIC_ERROR; + + nsIPluginStreamListener* listener = nsnull; + if(target == nsnull) + inst->NewStream(&listener); + + nsIPluginManager * pm; + gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); + + if(pm->PostURL(inst, relativeURL, len, buf, file, target, listener) != NS_OK) + return NPERR_GENERIC_ERROR; + + NS_RELEASE(pm); + + return NPERR_NO_ERROR; +} + + +//////////////////////////////////////////////////////////////////////// +// A little helper class used to wrap up plugin manager streams (that is, +// streams from the plugin to the browser). -/** - * A little helper class used to wrap up plugin manager streams (that is, - * streams from the plugin to the browser). - */ class ns4xStreamWrapper { protected: - nsIOutputStream *fStream; - NPStream fNPStream; + nsIOutputStream *fStream; + NPStream fNPStream; public: - ns4xStreamWrapper(nsIOutputStream* stream); - ~ns4xStreamWrapper(); + ns4xStreamWrapper(nsIOutputStream* stream); + ~ns4xStreamWrapper(); - void GetStream(nsIOutputStream* &result); + void GetStream(nsIOutputStream* &result); - NPStream* + NPStream* GetNPStream(void) { - return &fNPStream; - }; + return &fNPStream; + }; }; ns4xStreamWrapper::ns4xStreamWrapper(nsIOutputStream* stream) - : fStream(stream) + : fStream(stream) { - NS_ASSERTION(stream != NULL, "bad stream"); + NS_ASSERTION(stream != NULL, "bad stream"); - fStream = stream; - NS_ADDREF(fStream); + fStream = stream; + NS_ADDREF(fStream); - memset(&fNPStream, 0, sizeof(fNPStream)); - fNPStream.ndata = (void*) this; + memset(&fNPStream, 0, sizeof(fNPStream)); + fNPStream.ndata = (void*) this; } ns4xStreamWrapper::~ns4xStreamWrapper(void) { - fStream->Close(); - NS_IF_RELEASE(fStream); + fStream->Close(); + NS_IF_RELEASE(fStream); } - void ns4xStreamWrapper::GetStream(nsIOutputStream* &result) { - result = fStream; - NS_IF_ADDREF(fStream); + result = fStream; + NS_IF_ADDREF(fStream); } + //////////////////////////////////////////////////////////////////////// - - NPError NP_EXPORT _newstream(NPP npp, NPMIMEType type, const char* window, NPStream* *result) { - -#ifdef NS_DEBUG - printf("\nNewStream called \n\n"); -#endif + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_NewStream: npp=%p, type=%s, window=%s\n", + (void*)npp, (const char *)type, window)); - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - NS_ASSERTION(inst != NULL, "null instance"); + NS_ASSERTION(inst != NULL, "null instance"); - if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; + if (inst == NULL) + return NPERR_INVALID_INSTANCE_ERROR; - nsIOutputStream* stream; - nsIPluginInstancePeer *peer; - - if (NS_OK == inst->GetPeer(&peer)) - { - if (peer->NewStream((const char*) type, window, &stream) != NS_OK) - { - NS_RELEASE(peer); - return NPERR_GENERIC_ERROR; - } - - ns4xStreamWrapper* wrapper = new ns4xStreamWrapper(stream); - - if (wrapper == NULL) - { - NS_RELEASE(peer); - NS_RELEASE(stream); - return NPERR_OUT_OF_MEMORY_ERROR; - } - - (*result) = wrapper->GetNPStream(); + nsIOutputStream* stream; + nsIPluginInstancePeer *peer; + if (NS_OK == inst->GetPeer(&peer)) { + if (peer->NewStream((const char*) type, window, &stream) != NS_OK) { NS_RELEASE(peer); - - return NPERR_NO_ERROR; - } - else return NPERR_GENERIC_ERROR; + } + + ns4xStreamWrapper* wrapper = new ns4xStreamWrapper(stream); + + if (wrapper == NULL) { + NS_RELEASE(peer); + NS_RELEASE(stream); + return NPERR_OUT_OF_MEMORY_ERROR; + } + + (*result) = wrapper->GetNPStream(); + + NS_RELEASE(peer); + + return NPERR_NO_ERROR; + } + else + return NPERR_GENERIC_ERROR; } + +//////////////////////////////////////////////////////////////////////// int32 NP_EXPORT _write(NPP npp, NPStream *pstream, int32 len, void *buffer) { -#ifdef NS_DEBUG - printf("\nWrite called by plugin: \n%s\n", buffer); -#endif + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_Write: npp=%p, url=%s, len=%d, buffer=%s\n", + (void*)npp, pstream->url, len, (char*)buffer)); - // negative return indicates failure to the plugin - if(!npp) - return -1; + // negative return indicates failure to the plugin + if(!npp) + return -1; ns4xStreamWrapper* wrapper = (ns4xStreamWrapper*) pstream->ndata; NS_ASSERTION(wrapper != NULL, "null stream"); if (wrapper == NULL) - return -1; + return -1; nsIOutputStream* stream; wrapper->GetStream(stream); - + PRUint32 count = 0; nsresult rv = stream->Write((char *)buffer, len, &count); NS_RELEASE(stream); if(rv != NS_OK) - return -1; + return -1; return (int32)count; } + +//////////////////////////////////////////////////////////////////////// NPError NP_EXPORT _destroystream(NPP npp, NPStream *pstream, NPError reason) { + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_DestroyStream: npp=%p, url=%s, reason=%d\n", + (void*)npp, pstream->url, (int)reason)); - -#ifdef NS_DEBUG - printf("\nDestroy Stream called \n\n"); -#endif - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; - nsISupports* stream = (nsISupports*) pstream->ndata; - nsIPluginStreamListener* listener; + nsISupports* stream = (nsISupports*) pstream->ndata; + nsIPluginStreamListener* listener; - // DestroyStream can kill two kinds of streams: NPP derived and - // NPN derived. - // check to see if they're trying to kill a NPP stream - if(stream->QueryInterface(kIPluginStreamListenerIID, (void**)&listener) == NS_OK) - { - // XXX we should try to kill this listener here somehow - NS_RELEASE(listener); - return NPERR_NO_ERROR; - } + // DestroyStream can kill two kinds of streams: NPP derived and + // NPN derived. + // check to see if they're trying to kill a NPP stream + if(stream->QueryInterface(kIPluginStreamListenerIID, (void**)&listener) == NS_OK) { + // XXX we should try to kill this listener here somehow + NS_RELEASE(listener); + return NPERR_NO_ERROR; + } ns4xStreamWrapper* wrapper = (ns4xStreamWrapper*) pstream->ndata; - NS_ASSERTION(wrapper != NULL, "null wrapper"); if (wrapper == NULL) - return NPERR_INVALID_PARAM; + return NPERR_INVALID_PARAM; // This will release the wrapped nsIOutputStream. delete wrapper; @@ -913,50 +913,63 @@ _destroystream(NPP npp, NPStream *pstream, NPError reason) return NPERR_NO_ERROR; } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _status(NPP npp, const char *message) { - if(!npp) - return; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_Status: npp=%p, message=%s\n", (void*)npp, message)); - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + if(!npp) + return; - NS_ASSERTION(inst != NULL, "null instance"); + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + NS_ASSERTION(inst != NULL, "null instance"); - if (inst == NULL) - return; + if (inst == NULL) + return; - nsIPluginInstancePeer *peer; + nsIPluginInstancePeer *peer; - if (NS_OK == inst->GetPeer(&peer)) - { - peer->ShowStatus(message); - NS_RELEASE(peer); - } + if (NS_OK == inst->GetPeer(&peer)){ + peer->ShowStatus(message); + NS_RELEASE(peer); + } } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _memfree (void *ptr) { - if(ptr) - gMalloc->Free(ptr); + NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemFree: ptr=%p\n", ptr)); + + if(ptr) + gMalloc->Free(ptr); } + +//////////////////////////////////////////////////////////////////////// uint32 NP_EXPORT _memflush(uint32 size) { - gMalloc->HeapMinimize(PR_TRUE); + NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemFlush: size=%d\n", size)); - return 0; + gMalloc->HeapMinimize(PR_TRUE); + return 0; } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _reloadplugins(NPBool reloadPages) { + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_ReloadPlugins: reloadPages=%d\n", reloadPages)); NS_ASSERTION(gServiceMgr != NULL, "null service manager"); if(gServiceMgr == nsnull) - return; + return; nsIPluginManager * pm; gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); @@ -966,43 +979,51 @@ _reloadplugins(NPBool reloadPages) NS_RELEASE(pm); } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _invalidaterect(NPP npp, NPRect *invalidRect) { - if(!npp) - return; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_InvalidateRect: npp=%p, top=%d, left=%d, bottom=%d, right=%d\n", + (void *)npp, invalidRect->top, invalidRect->left, invalidRect->bottom, invalidRect->right)); - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + if(!npp) + return; - NS_ASSERTION(inst != NULL, "null instance"); + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - if (inst == NULL) - return; + NS_ASSERTION(inst != NULL, "null instance"); - nsIPluginInstancePeer *peer; - nsIWindowlessPluginInstancePeer *wpeer; + if (inst == NULL) + return; - if (NS_OK == inst->GetPeer(&peer)) - { - if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) - { - // XXX nsRect & NPRect are structurally equivalent - wpeer->InvalidateRect((nsPluginRect *)invalidRect); - NS_RELEASE(wpeer); - } + nsIPluginInstancePeer *peer; + nsIWindowlessPluginInstancePeer *wpeer; - NS_RELEASE(peer); + if (NS_OK == inst->GetPeer(&peer)) { + if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) { + // XXX nsRect & NPRect are structurally equivalent + wpeer->InvalidateRect((nsPluginRect *)invalidRect); + NS_RELEASE(wpeer); } + NS_RELEASE(peer); + } } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _invalidateregion(NPP npp, NPRegion invalidRegion) { - if(!npp) - return; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPN_InvalidateRegion: npp=%p, region=%p\n", + (void*)npp, (void*)invalidRegion)); + + if(!npp) + return; nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; - NS_ASSERTION(inst != NULL, "null instance"); if (inst == NULL) @@ -1011,10 +1032,8 @@ _invalidateregion(NPP npp, NPRegion invalidRegion) nsIPluginInstancePeer *peer; nsIWindowlessPluginInstancePeer *wpeer; - if (NS_OK == inst->GetPeer(&peer)) - { - if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) - { + if (NS_OK == inst->GetPeer(&peer)) { + if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) { // XXX nsRegion & NPRegion are typedef'd to the same thing wpeer->InvalidateRegion((nsPluginRegion)invalidRegion); NS_RELEASE(wpeer); @@ -1024,41 +1043,45 @@ _invalidateregion(NPP npp, NPRegion invalidRegion) } } + +//////////////////////////////////////////////////////////////////////// void NP_EXPORT _forceredraw(NPP npp) { - if(!npp) - return; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_ForceDraw: npp=%p\n", (void*)npp)); - nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + if(!npp) + return; - NS_ASSERTION(inst != NULL, "null instance"); + nsIPluginInstance *inst = (nsIPluginInstance *) npp->ndata; + NS_ASSERTION(inst != NULL, "null instance"); - if (inst == NULL) - return; + if (inst == NULL) + return; - nsIPluginInstancePeer *peer; - nsIWindowlessPluginInstancePeer *wpeer; + nsIPluginInstancePeer *peer; + nsIWindowlessPluginInstancePeer *wpeer; - if (NS_OK == inst->GetPeer(&peer)) - { - if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) - { - wpeer->ForceRedraw(); - NS_RELEASE(wpeer); - } - - NS_RELEASE(peer); + if (NS_OK == inst->GetPeer(&peer)) { + if (NS_OK == peer->QueryInterface(kIWindowlessPluginInstancePeerIID, (void **)&wpeer)) { + wpeer->ForceRedraw(); + NS_RELEASE(wpeer); } + NS_RELEASE(peer); + } } + +//////////////////////////////////////////////////////////////////////// NPError NP_EXPORT _getvalue(NPP npp, NPNVariable variable, void *result) { + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetValue: npp=%p, var=%d\n", (void*)npp, (int)variable)); + nsresult res; if(!npp || !npp->ndata) - return NPERR_INVALID_INSTANCE_ERROR; + return NPERR_INVALID_INSTANCE_ERROR; switch(variable) { @@ -1070,36 +1093,32 @@ _getvalue(NPP npp, NPNVariable variable, void *result) #ifdef XP_PC case NPNVnetscapeWindow : - { - ns4xPluginInstance *inst = (ns4xPluginInstance *) npp->ndata; - nsIPluginInstancePeer *peer; - - if (NS_SUCCEEDED(inst->GetPeer(&peer)) && peer) - { - res = peer->GetValue(nsPluginInstancePeerVariable_NetscapeWindow, result); - NS_RELEASE(peer); - return res; - } - - return NPERR_GENERIC_ERROR; - } + { + ns4xPluginInstance *inst = (ns4xPluginInstance *) npp->ndata; + nsIPluginInstancePeer *peer; + + if (NS_SUCCEEDED(inst->GetPeer(&peer)) && peer) { + res = peer->GetValue(nsPluginInstancePeerVariable_NetscapeWindow, result); + NS_RELEASE(peer); + return res; + } + return NPERR_GENERIC_ERROR; + } #endif case NPNVjavascriptEnabledBool: - { - *(NPBool*)result = PR_TRUE; - - nsCOMPtr prefs(do_GetService(kPrefServiceCID, &res)); - if(NS_SUCCEEDED(res) && (nsnull != prefs)) { - PRBool js; - res = prefs->GetBoolPref("javascript.enabled", &js); - if(NS_SUCCEEDED(res)) - *(NPBool*)result = js; - } + *(NPBool*)result = PR_TRUE; - return NPERR_NO_ERROR; - } + nsCOMPtr prefs(do_GetService(kPrefServiceCID, &res)); + if(NS_SUCCEEDED(res) && (nsnull != prefs)) { + PRBool js; + res = prefs->GetBoolPref("javascript.enabled", &js); + if(NS_SUCCEEDED(res)) + *(NPBool*)result = js; + } + return NPERR_NO_ERROR; + } case NPNVasdEnabledBool: *(NPBool*)result = FALSE; @@ -1110,7 +1129,6 @@ _getvalue(NPP npp, NPNVariable variable, void *result) return NPERR_NO_ERROR; default : return NPERR_GENERIC_ERROR; - } #if 0 @@ -1119,12 +1137,11 @@ _getvalue(NPP npp, NPNVariable variable, void *result) NS_ASSERTION(inst != NULL, "null instance"); if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; + return NPERR_INVALID_INSTANCE_ERROR; nsIPluginInstancePeer *peer; - if (NS_OK == inst->GetPeer(&peer)) - { + if (NS_OK == inst->GetPeer(&peer)) { nsresult rv; // XXX Note that for backwards compatibility, the old NPNVariables @@ -1138,86 +1155,91 @@ _getvalue(NPP npp, NPNVariable variable, void *result) #endif } + +//////////////////////////////////////////////////////////////////////// NPError NP_EXPORT _setvalue(NPP npp, NPPVariable variable, void *result) { - if(!npp) - return NPERR_INVALID_INSTANCE_ERROR; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_SetValue: npp=%p, var=%d\n", (void*)npp, (int)variable)); - ns4xPluginInstance *inst = (ns4xPluginInstance *) npp->ndata; + if(!npp) + return NPERR_INVALID_INSTANCE_ERROR; - NS_ASSERTION(inst != NULL, "null instance"); + ns4xPluginInstance *inst = (ns4xPluginInstance *) npp->ndata; + + NS_ASSERTION(inst != NULL, "null instance"); - if (inst == NULL) - return NPERR_INVALID_INSTANCE_ERROR; + if (inst == NULL) + return NPERR_INVALID_INSTANCE_ERROR; - switch (variable) + switch (variable) + { + case NPPVpluginWindowBool: { - case NPPVpluginWindowBool: - { - NPBool bWindowless = !(*((NPBool *)result)); - return inst->SetWindowless(bWindowless); - } - - case NPPVpluginTransparentBool: - return inst->SetTransparent(*((NPBool *)result)); - - default: - return NPERR_NO_ERROR; + NPBool bWindowless = !(*((NPBool *)result)); + return inst->SetWindowless(bWindowless); } + case NPPVpluginTransparentBool: + return inst->SetTransparent(*((NPBool *)result)); + + default: + return NPERR_NO_ERROR; + } + #if 0 - nsIPluginInstancePeer *peer; - - if (NS_OK == inst->GetPeer(&peer)) - { - nsresult rv; - - // XXX Note that for backwards compatibility, the old NPPVariables - // map correctly to NPPluginVariables. - rv = peer->SetValue((nsPluginInstancePeerVariable)variable, result); - NS_RELEASE(peer); - return rv; - } - else - return NS_ERROR_UNEXPECTED; + nsIPluginInstancePeer *peer; + + if (NS_OK == inst->GetPeer(&peer)) { + nsresult rv; + + // XXX Note that for backwards compatibility, the old NPPVariables + // map correctly to NPPluginVariables. + rv = peer->SetValue((nsPluginInstancePeerVariable)variable, result); + NS_RELEASE(peer); + return rv; + } + else + return NS_ERROR_UNEXPECTED; #endif } + +//////////////////////////////////////////////////////////////////////// NPError NP_EXPORT _requestread(NPStream *pstream, NPByteRange *rangeList) { -#ifdef NS_DEBUG - printf("\nRequestRead called by plugin: "); - for(NPByteRange * range = rangeList; range != nsnull; range = range->next) - { - printf("%i-%i", range->offset, range->offset + range->length - 1); - if(range->next) - printf(","); - } - printf("\n\n"); -#endif + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_RequestRead: stream=%p\n", (void*)pstream)); +#ifdef PLUGIN_LOGGING + for(NPByteRange * range = rangeList; range != nsnull; range = range->next) + PR_LOG(nsPluginLogging::gNPNLog,PLUGIN_LOG_NOISY, + ("%i-%i", range->offset, range->offset + range->length - 1)); + + PR_LOG(nsPluginLogging::gNPNLog,PLUGIN_LOG_NOISY, ("\n\n")); + PR_LogFlush(); +#endif + if(!pstream || !rangeList || !pstream->ndata) return NPERR_INVALID_PARAM; - + nsresult res = NS_OK; ns4xPluginStreamListener * streamlistener = (ns4xPluginStreamListener *)pstream->ndata; if(NS_FAILED(res)) return NPERR_GENERIC_ERROR; - + nsPluginStreamType streamtype = nsPluginStreamType_Normal; streamlistener->GetStreamType(&streamtype); - + if(streamtype != nsPluginStreamType_Seek) return NPERR_STREAM_NOT_SEEKABLE; - + if(streamlistener->mStreamInfo) streamlistener->mStreamInfo->RequestRead((nsByteRange *)rangeList); - + return NS_OK; } @@ -1233,50 +1255,65 @@ _requestread(NPStream *pstream, NPByteRange *rangeList) #endif +//////////////////////////////////////////////////////////////////////// JRIEnv* NP_EXPORT _getJavaEnv(void) { - return NULL; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetJavaEnv\n")); + + return NULL; } + +//////////////////////////////////////////////////////////////////////// const char * NP_EXPORT _useragent(NPP npp) { + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_UserAgent: npp=%p\n", (void*)npp)); + NS_ASSERTION(gServiceMgr != NULL, "null service manager"); if (gServiceMgr == NULL) return NULL; - + char *retstr; - + nsIPluginManager * pm; gServiceMgr->GetService(kPluginManagerCID, kIPluginManagerIID, (nsISupports**)&pm); - + pm->UserAgent((const char **)&retstr); - + NS_RELEASE(pm); - + return retstr; } + +//////////////////////////////////////////////////////////////////////// void * NP_EXPORT _memalloc (uint32 size) { - return gMalloc->Alloc(size); + NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemAlloc: size=%d\n", size)); + + return gMalloc->Alloc(size); } + +//////////////////////////////////////////////////////////////////////// java_lang_Class* NP_EXPORT _getJavaClass(void* handle) { - return NULL; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetJavaClass\n")); + + return NULL; } - +//////////////////////////////////////////////////////////////////////// jref NP_EXPORT _getJavaPeer(NPP npp) { - return NULL; + NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetJavaPeer: npp=%p\n", (void*)npp)); + + return NULL; } - -// eof diff --git a/mozilla/modules/plugin/base/src/ns4xPluginInstance.cpp b/mozilla/modules/plugin/base/src/ns4xPluginInstance.cpp index 9bf0819f486..fba31e5a4b8 100644 --- a/mozilla/modules/plugin/base/src/ns4xPluginInstance.cpp +++ b/mozilla/modules/plugin/base/src/ns4xPluginInstance.cpp @@ -20,13 +20,16 @@ * Contributor(s): */ -#include "ns4xPluginInstance.h" -#include "ns4xPluginStreamListener.h" -#include "nsPluginHostImpl.h" - #include "prlog.h" #include "prmem.h" #include "nscore.h" +#include "ns4xPlugin.h" +#include "ns4xPluginInstance.h" +#include "ns4xPluginStreamListener.h" +#include "nsPluginHostImpl.h" +#include "nsPluginSafety.h" +#include "nsIPref.h" // needed for NS_TRY_SAFE_CALL_* +#include "nsPluginLogging.h" #if defined(MOZ_WIDGET_GTK) #include @@ -34,18 +37,24 @@ #include "gtkxtbin.h" #endif -#include "nsPluginSafety.h" -#include "nsIPref.h" // needed for NS_TRY_SAFE_CALL_* +//////////////////////////////////////////////////////////////////////// +// CID's && IID's static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID); // needed for NS_TRY_SAFE_CALL_* static NS_DEFINE_IID(kCPluginManagerCID, NS_PLUGINMANAGER_CID); +static NS_DEFINE_IID(kIPluginStreamListenerIID, NS_IPLUGINSTREAMLISTENER_IID); +static NS_DEFINE_IID(kIPluginStreamListener2IID, NS_IPLUGINSTREAMLISTENER2_IID); +static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID); +static NS_DEFINE_IID(kIPluginTagInfoIID, NS_IPLUGINTAGINFO_IID); +static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); /////////////////////////////////////////////////////////////////////////////// // ns4xPluginStreamListener Methods -/////////////////////////////////////////////////////////////////////////////// -static NS_DEFINE_IID(kIPluginStreamListenerIID, NS_IPLUGINSTREAMLISTENER_IID); -static NS_DEFINE_IID(kIPluginStreamListener2IID, NS_IPLUGINSTREAMLISTENER2_IID); +NS_IMPL_ISUPPORTS2(ns4xPluginStreamListener, nsIPluginStreamListener, + nsIPluginStreamListener2); + +/////////////////////////////////////////////////////////////////////////////// ns4xPluginStreamListener::ns4xPluginStreamListener(nsIPluginInstance* inst, void* notifyData) @@ -65,6 +74,8 @@ ns4xPluginStreamListener::ns4xPluginStreamListener(nsIPluginInstance* inst, NS_IF_ADDREF(mInst); } + +/////////////////////////////////////////////////////////////////////////////// ns4xPluginStreamListener::~ns4xPluginStreamListener(void) { // remove itself from the instance stream list @@ -86,6 +97,8 @@ ns4xPluginStreamListener::~ns4xPluginStreamListener(void) NS_IF_RELEASE(mInst); } + +/////////////////////////////////////////////////////////////////////////////// nsresult ns4xPluginStreamListener::CleanUpStream() { if(!mStreamStarted || mStreamCleanedUp) @@ -111,14 +124,15 @@ nsresult ns4xPluginStreamListener::CleanUpStream() PRLibrary* lib = nsnull; lib = mInst->fLibrary; -#ifdef NS_DEBUG - printf("calling NPP_DestroyStream\n"); -#endif - NS_TRY_SAFE_CALL_RETURN(error, CallNPP_DestroyStreamProc(callbacks->destroystream, npp, &mNPStream, NPRES_DONE), lib); + + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP DestroyStream called: this=%p, npp=%p, return=%d, url=%s\n", + this, npp, error, mNPStream.url)); + if(error != NPERR_NO_ERROR) return NS_ERROR_FAILURE; } @@ -138,6 +152,10 @@ nsresult ns4xPluginStreamListener::CleanUpStream() mNPStream.url, nsPluginReason_Done, mNotifyData), lib); + + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP URLNotify called: this=%p, npp=%p, notify=%p, url=%s\n", + this, npp, mNotifyData, mNPStream.url)); } // lets get rid of the buffer if we made one globally @@ -152,9 +170,8 @@ nsresult ns4xPluginStreamListener::CleanUpStream() return NS_OK; } -NS_IMPL_ISUPPORTS2(ns4xPluginStreamListener, nsIPluginStreamListener, - nsIPluginStreamListener2); +/////////////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginStreamListener::OnStartBinding(nsIPluginStreamInfo* pluginInfo) { @@ -198,6 +215,11 @@ ns4xPluginStreamListener::OnStartBinding(nsIPluginStreamInfo* pluginInfo) &mNPStream, seekable, &streamType), lib); + + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP NewStream called: this=%p, npp=%p, mime=%s, seek=%d, type=%d, return=%d, url=%s\n", + this, npp, (char *)contentType, seekable, streamType, error, mNPStream.url)); + if(error != NPERR_NO_ERROR) return NS_ERROR_FAILURE; @@ -232,6 +254,8 @@ ns4xPluginStreamListener::OnStartBinding(nsIPluginStreamInfo* pluginInfo) return NS_OK; } + +/////////////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, nsIInputStream* input, @@ -296,6 +320,10 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, npp, &mNPStream), lib); + NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("NPP WriteReady called: this=%p, npp=%p, return(towrite)=%d, url=%s\n", + this, npp, numtowrite, mNPStream.url)); + // if WriteReady returned 0, the plugin is not ready to handle // the data, return FAILURE for now if (numtowrite <= 0) { @@ -324,6 +352,11 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, mPosition, numtowrite, (void *)mStreamBuffer), lib); + + NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("NPP Write called: this=%p, npp=%p, pos=%d, len=%d, buf=%s, return(written)=%d, url=%s\n", + this, npp, mPosition, numtowrite, (char *)mStreamBuffer, writeCount, mNPStream.url)); + if (writeCount < 0) { rv = NS_ERROR_FAILURE; goto error; @@ -353,6 +386,8 @@ error: return rv; } + +/////////////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, nsIInputStream* input, @@ -426,6 +461,10 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, npp, &mNPStream), lib); + NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("NPP WriteReady called: this=%p, npp=%p, return(towrite)=%d, url=%s\n", + this, npp, numtowrite, mNPStream.url)); + // if WriteReady returned 0, the plugin is not ready to handle // the data, return FAILURE for now if (numtowrite <= 0) { @@ -447,9 +486,8 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, { PRLibrary* lib = mInst->fLibrary; -#ifdef DEBUG_dougt +#if 0 // useful for debugging problems with byte range buffers printf("> %d - %d \n", sourceOffset + writeCount + mPosition, numtowrite); -#if 0 nsCString x; x.Append("d:\\parts\\"); x.AppendInt(sourceOffset); @@ -458,7 +496,6 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, fd = PR_Open(x, PR_CREATE_FILE |PR_SYNC| PR_APPEND | PR_RDWR, 777); PR_Write(fd, mStreamBuffer, numtowrite); PR_Close(fd); -#endif #endif NS_TRY_SAFE_CALL_RETURN(writeCount, CallNPP_WriteProc(callbacks->write, @@ -467,6 +504,11 @@ ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo* pluginInfo, sourceOffset + writeCount + mPosition, numtowrite, (void *)mStreamBuffer), lib); + + NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("NPP Write called: this=%p, npp=%p, pos=%d, len=%d, buf=%s, return(written)=%d, url=%s\n", + this, npp, mPosition, numtowrite, (char *)mStreamBuffer, writeCount, mNPStream.url)); + if (writeCount < 0) { rv = NS_ERROR_FAILURE; goto error; @@ -496,6 +538,8 @@ error: return rv; } + +/////////////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginStreamListener::OnFileAvailable(nsIPluginStreamInfo* pluginInfo, const char* fileName) @@ -524,18 +568,20 @@ ns4xPluginStreamListener::OnFileAvailable(nsIPluginStreamInfo* pluginInfo, npp, &mNPStream, fileName), lib); - + + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP StreamAsFile called: this=%p, npp=%p, url=%s, file=%s\n", + this, npp, mNPStream.url, fileName)); + return NS_OK; } + +/////////////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginStreamListener::OnStopBinding(nsIPluginStreamInfo* pluginInfo, nsresult status) { -#ifdef NS_DEBUG - printf("ns4xPluginStreamListener::OnStopBinding\n"); -#endif - if(!mInst || !mInst->IsStarted()) return NS_ERROR_FAILURE; @@ -563,43 +609,54 @@ ns4xPluginStreamListener::GetStreamType(nsPluginStreamType *result) return NS_OK; } -///////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// nsInstanceStream::nsInstanceStream() { mNext = nsnull; mPluginStreamListener = nsnull; } + +/////////////////////////////////////////////////////////////////////////////// nsInstanceStream::~nsInstanceStream() { } + +/////////////////////////////////////////////////////////////////////////////// + +NS_IMPL_ISUPPORTS2(ns4xPluginInstance, nsIPluginInstance, nsIScriptablePlugin) + +/////////////////////////////////////////////////////////////////////////////// + ns4xPluginInstance :: ns4xPluginInstance(NPPluginFuncs* callbacks, PRLibrary* aLibrary) - : fCallbacks(callbacks) + : fCallbacks(callbacks) { - NS_INIT_REFCNT(); + NS_INIT_REFCNT(); - NS_ASSERTION(fCallbacks != NULL, "null callbacks"); + NS_ASSERTION(fCallbacks != NULL, "null callbacks"); - // Initialize the NPP structure. + // Initialize the NPP structure. - fNPP.pdata = NULL; - fNPP.ndata = this; + fNPP.pdata = NULL; + fNPP.ndata = this; - fLibrary = aLibrary; - mWindowless = PR_FALSE; - mTransparent = PR_FALSE; - mStarted = PR_FALSE; - mStreams = nsnull; + fLibrary = aLibrary; + mWindowless = PR_FALSE; + mTransparent = PR_FALSE; + mStarted = PR_FALSE; + mStreams = nsnull; + + PLUGIN_LOG(PLUGIN_LOG_BASIC, ("ns4xPluginInstance ctor: this=%p\n",this)); } +/////////////////////////////////////////////////////////////////////////////// ns4xPluginInstance :: ~ns4xPluginInstance(void) { -#ifdef NS_DEBUG - printf("ns4xPluginInstance::~ns4xPluginInstance()\n"); -#endif + PLUGIN_LOG(PLUGIN_LOG_BASIC, ("ns4xPluginInstance dtor: this=%p\n",this)); + #if defined(MOZ_WIDGET_GTK) if (mXtBin) gtk_widget_destroy(mXtBin); @@ -613,31 +670,27 @@ ns4xPluginInstance :: ~ns4xPluginInstance(void) } } + +/////////////////////////////////////////////////////////////////////////////// PRBool ns4xPluginInstance :: IsStarted(void) { - return mStarted; + return mStarted; } -//////////////////////////////////////////////////////////////////////// - -NS_IMPL_ISUPPORTS2(ns4xPluginInstance, nsIPluginInstance, nsIScriptablePlugin) - -static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID); -static NS_DEFINE_IID(kIPluginTagInfoIID, NS_IPLUGINTAGINFO_IID); -static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); - //////////////////////////////////////////////////////////////////////// - NS_IMETHODIMP ns4xPluginInstance::Initialize(nsIPluginInstancePeer* peer) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Initialize this=%p\n",this)); + #ifdef MOZ_WIDGET_GTK mXtBin = nsnull; #endif return InitializePlugin(peer); } +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance::GetPeer(nsIPluginInstancePeer* *resultingPeer) { *resultingPeer = mPeer; @@ -646,11 +699,10 @@ NS_IMETHODIMP ns4xPluginInstance::GetPeer(nsIPluginInstancePeer* *resultingPeer) return NS_OK; } +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance::Start(void) { -#ifdef NS_DEBUG - printf("Inside ns4xPluginInstance::Start(void)...\n"); -#endif + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Start this=%p\n",this)); if(mStarted) return NS_OK; @@ -658,13 +710,13 @@ NS_IMETHODIMP ns4xPluginInstance::Start(void) return InitializePlugin(mPeer); } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance::Stop(void) { - NPError error; + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Stop this=%p\n",this)); -#ifdef NS_DEBUG - printf("ns4xPluginInstance::Stop()\n"); -#endif + NPError error; #ifdef MOZ_WIDGET_GTK if (mXtBin) @@ -692,6 +744,9 @@ NS_IMETHODIMP ns4xPluginInstance::Stop(void) NS_TRY_SAFE_CALL_RETURN(error, CallNPP_DestroyProc(fCallbacks->destroy, &fNPP, &sdata), fLibrary); + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP Destroy called: this=%p, npp=%p, return=%d\n", this, fNPP, error)); + mStarted = PR_FALSE; if(error != NPERR_NO_ERROR) return NS_ERROR_FAILURE; @@ -699,6 +754,8 @@ NS_IMETHODIMP ns4xPluginInstance::Stop(void) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance::InitializePlugin(nsIPluginInstancePeer* peer) { PRUint16 count = 0; @@ -737,7 +794,11 @@ nsresult ns4xPluginInstance::InitializePlugin(nsIPluginInstancePeer* peer) (char**)names, (char**)values, NULL), fLibrary); - + + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP New called: this=%p, npp=%p, mime=%s, mode=%d, argc=%d, return=%d\n", + this, fNPP, mimetype, mode, count, error)); + if(error != NPERR_NO_ERROR) rv = NS_ERROR_FAILURE; @@ -746,12 +807,18 @@ nsresult ns4xPluginInstance::InitializePlugin(nsIPluginInstancePeer* peer) return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance::Destroy(void) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::Destroy this=%p\n",this)); + // destruction is handled in the Stop call return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance::SetWindow(nsPluginWindow* window) { #ifdef MOZ_WIDGET_GTK @@ -759,11 +826,6 @@ NS_IMETHODIMP ns4xPluginInstance::SetWindow(nsPluginWindow* window) #endif // XXX 4.x plugins don't want a SetWindow(NULL). - -#ifdef NS_DEBUG - printf("Inside ns4xPluginInstance::SetWindow(%p)...\n", window); -#endif - if (!window || !mStarted) return NS_OK; @@ -844,35 +906,35 @@ NS_IMETHODIMP ns4xPluginInstance::SetWindow(nsPluginWindow* window) if (fCallbacks->setwindow) { // XXX Turns out that NPPluginWindow and NPWindow are structurally // identical (on purpose!), so there's no need to make a copy. - -#ifdef NS_DEBUG - printf("About to call CallNPP_SetWindowProc()...\n"); - fflush(NULL); -#endif + + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("ns4xPluginInstance::SetWindow (about to call it) this=%p\n",this)); NS_TRY_SAFE_CALL_RETURN(error, CallNPP_SetWindowProc(fCallbacks->setwindow, &fNPP, (NPWindow*) window), fLibrary); + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP SetWindow called: this=%p, [x=%d,y=%d,w=%d,h=%d], clip[t=%d,b=%d,l=%d,r=%d], return=%d\n", + this, fNPP, window->x, window->y, window->width, window->height, + window->clipRect.top, window->clipRect.bottom, window->clipRect.left, window->clipRect.right, error)); // XXX In the old code, we'd just ignore any errors coming // back from the plugin's SetWindow(). Is this the correct // behavior?!? } - -#ifdef NS_DEBUG - printf("Falling out of ns4xPluginInstance::SetWindow()...\n"); -#endif return NS_OK; } -/* NOTE: the caller must free the stream listener */ +//////////////////////////////////////////////////////////////////////// +/* NOTE: the caller must free the stream listener */ NS_IMETHODIMP ns4xPluginInstance::NewStream(nsIPluginStreamListener** listener) { return NewNotifyStream(listener, nsnull); } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance::NewNotifyStream(nsIPluginStreamListener** listener, void* notifyData) { ns4xPluginStreamListener* stream = new ns4xPluginStreamListener(this, notifyData); @@ -933,13 +995,19 @@ NS_IMETHODIMP ns4xPluginInstance::HandleEvent(nsPluginEvent* event, PRBool* hand &fNPP, (void*)&npEvent), fLibrary); #endif - + + NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("NPP HandleEvent called: this=%p, npp=%p, event=%d, return=%d\n", + this, fNPP, event->event, res)); + *handled = res; } return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP ns4xPluginInstance :: GetValue(nsPluginInstanceVariable variable, void *value) { @@ -970,9 +1038,15 @@ NS_IMETHODIMP ns4xPluginInstance :: GetValue(nsPluginInstanceVariable variable, } } + NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("NPP GetValue called: this=%p, npp=%p, var=%d, value=%d, return=%d\n", + this, fNPP, variable, value, res)); + return res; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance::GetNPP(NPP* aNPP) { if(aNPP != nsnull) @@ -983,6 +1057,8 @@ nsresult ns4xPluginInstance::GetNPP(NPP* aNPP) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance::GetCallbacks(const NPPluginFuncs ** aCallbacks) { if(aCallbacks != nsnull) @@ -993,18 +1069,23 @@ nsresult ns4xPluginInstance::GetCallbacks(const NPPluginFuncs ** aCallbacks) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance :: SetWindowless(PRBool aWindowless) { mWindowless = aWindowless; return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult ns4xPluginInstance :: SetTransparent(PRBool aTransparent) { mTransparent = aTransparent; return NS_OK; } +//////////////////////////////////////////////////////////////////////// /* readonly attribute nsQIResult scriptablePeer; */ NS_IMETHODIMP ns4xPluginInstance :: GetScriptablePeer(void * *aScriptablePeer) { @@ -1015,6 +1096,8 @@ NS_IMETHODIMP ns4xPluginInstance :: GetScriptablePeer(void * *aScriptablePeer) return GetValue(nsPluginInstanceVariable_ScriptableInstance, aScriptablePeer); } + +//////////////////////////////////////////////////////////////////////// /* readonly attribute nsIIDPtr scriptableInterface; */ NS_IMETHODIMP ns4xPluginInstance :: GetScriptableInterface(nsIID * *aScriptableInterface) { diff --git a/mozilla/modules/plugin/base/src/nsPluginHostImpl.cpp b/mozilla/modules/plugin/base/src/nsPluginHostImpl.cpp index 77072e5c97e..2618f48c690 100644 --- a/mozilla/modules/plugin/base/src/nsPluginHostImpl.cpp +++ b/mozilla/modules/plugin/base/src/nsPluginHostImpl.cpp @@ -22,6 +22,8 @@ * Håkan Waara */ +/* nsPluginHostImpl.cpp - bulk of code for managing plugins */ + #include "nscore.h" #include "nsPluginHostImpl.h" #include "nsPluginProxyImpl.h" @@ -30,7 +32,6 @@ #include "prmem.h" #include "ns4xPlugin.h" #include "nsPluginInstancePeer.h" - #include "nsIPlugin.h" #include "nsIJVMPlugin.h" #include "nsIPluginStreamListener.h" @@ -60,7 +61,7 @@ #include "nsIScriptablePlugin.h" #include "nsICachingChannel.h" #include "nsHashtable.h" - +#include "nsPluginLogging.h" #include "nsAppDirectoryServiceDefs.h" // Friggin' X11 has to "#define None". Lame! @@ -144,6 +145,8 @@ #define REL_PLUGIN_DLL "rel:" PLUGIN_DLL +//////////////////////////////////////////////////////////////////////// +// CID's && IID's static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID); static NS_DEFINE_IID(kIPluginInstancePeerIID, NS_IPLUGININSTANCEPEER_IID); static NS_DEFINE_IID(kIPluginStreamInfoIID, NS_IPLUGINSTREAMINFO_IID); @@ -155,22 +158,23 @@ static NS_DEFINE_CID(kCookieServiceCID, NS_COOKIESERVICE_CID); static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID); static NS_DEFINE_IID(kIRequestObserverIID, NS_IREQUESTOBSERVER_IID); - static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID); static NS_DEFINE_CID(kHttpHandlerCID, NS_HTTPPROTOCOLHANDLER_CID); static NS_DEFINE_CID(kIHttpHeaderVisitorIID, NS_IHTTPHEADERVISITOR_IID); static NS_DEFINE_CID(kStreamConverterServiceCID, NS_STREAMCONVERTERSERVICE_CID); - static NS_DEFINE_IID(kIFileUtilitiesIID, NS_IFILEUTILITIES_IID); static NS_DEFINE_IID(kIOutputStreamIID, NS_IOUTPUTSTREAM_IID); - static NS_DEFINE_CID(kRegistryCID, NS_REGISTRY_CID); - // for the dialog static NS_DEFINE_IID(kStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID); - static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID); +#ifdef PLUGIN_LOGGING +PRLogModuleInfo* nsPluginLogging::gNPNLog = nsnull; +PRLogModuleInfo* nsPluginLogging::gNPPLog = nsnull; +PRLogModuleInfo* nsPluginLogging::gPluginLog = nsnull; +#endif + #define PLUGIN_PROPERTIES_URL "chrome://global/locale/downloadProgress.properties" #define PLUGIN_REGIONAL_URL "chrome://global-region/locale/region.properties" @@ -206,6 +210,7 @@ static const char *hashValue = "value"; #define NS_MIME_TYPES_HASH_NUM (20) +//////////////////////////////////////////////////////////////////////// void DisplayNoDefaultPluginDialog(const char *mimeType) { nsresult rv; @@ -301,6 +306,8 @@ void DisplayNoDefaultPluginDialog(const char *mimeType) return; } + +//////////////////////////////////////////////////////////////////////// nsActivePlugin::nsActivePlugin(nsPluginTag* aPluginTag, nsIPluginInstance* aInstance, char * url, @@ -324,6 +331,8 @@ nsActivePlugin::nsActivePlugin(nsPluginTag* aPluginTag, mStreams = new nsVoidArray(); // create a new stream array } + +//////////////////////////////////////////////////////////////////////// nsActivePlugin::~nsActivePlugin() { mPluginTag = nsnull; @@ -352,6 +361,8 @@ nsActivePlugin::~nsActivePlugin() PL_strfree(mURL); } + +//////////////////////////////////////////////////////////////////////// void nsActivePlugin::setStopped(PRBool stopped) { mStopped = stopped; @@ -376,6 +387,8 @@ void nsActivePlugin::setStopped(PRBool stopped) } + +//////////////////////////////////////////////////////////////////////// nsActivePluginList::nsActivePluginList() { mFirst = nsnull; @@ -383,6 +396,8 @@ nsActivePluginList::nsActivePluginList() mCount = 0; } + +//////////////////////////////////////////////////////////////////////// nsActivePluginList::~nsActivePluginList() { if(mFirst == nsnull) @@ -390,6 +405,8 @@ nsActivePluginList::~nsActivePluginList() shut(); } + +//////////////////////////////////////////////////////////////////////// void nsActivePluginList::shut() { if(mFirst == nsnull) @@ -409,6 +426,8 @@ void nsActivePluginList::shut() mLast = nsnull; } + +//////////////////////////////////////////////////////////////////////// PRInt32 nsActivePluginList::add(nsActivePlugin * plugin) { if (mFirst == nsnull) @@ -427,6 +446,8 @@ PRInt32 nsActivePluginList::add(nsActivePlugin * plugin) return mCount; } + +//////////////////////////////////////////////////////////////////////// PRBool nsActivePluginList::IsLastInstance(nsActivePlugin * plugin) { if(!plugin) @@ -443,6 +464,8 @@ PRBool nsActivePluginList::IsLastInstance(nsActivePlugin * plugin) return PR_TRUE; } + +//////////////////////////////////////////////////////////////////////// PRBool nsActivePluginList::remove(nsActivePlugin * plugin, PRBool * aUnloadLibraryLater) { if(mFirst == nsnull) @@ -502,6 +525,8 @@ PRBool nsActivePluginList::remove(nsActivePlugin * plugin, PRBool * aUnloadLibra return PR_FALSE; } + +//////////////////////////////////////////////////////////////////////// void nsActivePluginList::stopRunning() { if(mFirst == nsnull) @@ -532,6 +557,8 @@ void nsActivePluginList::stopRunning() } } + +//////////////////////////////////////////////////////////////////////// void nsActivePluginList::removeAllStopped() { if(mFirst == nsnull) @@ -556,6 +583,8 @@ void nsActivePluginList::removeAllStopped() return; } + +//////////////////////////////////////////////////////////////////////// nsActivePlugin * nsActivePluginList::find(nsIPluginInstance* instance) { for(nsActivePlugin * p = mFirst; p != nsnull; p = p->mNext) @@ -607,6 +636,8 @@ nsActivePlugin * nsActivePluginList::find(char * mimetype) return nsnull; } + +//////////////////////////////////////////////////////////////////////// nsActivePlugin * nsActivePluginList::findStopped(char * url) { for(nsActivePlugin * p = mFirst; p != nsnull; p = p->mNext) @@ -624,6 +655,8 @@ nsActivePlugin * nsActivePluginList::findStopped(char * url) return nsnull; } + +//////////////////////////////////////////////////////////////////////// PRUint32 nsActivePluginList::getStoppedCount() { PRUint32 stoppedCount = 0; @@ -635,6 +668,8 @@ PRUint32 nsActivePluginList::getStoppedCount() return stoppedCount; } + +//////////////////////////////////////////////////////////////////////// nsActivePlugin * nsActivePluginList::findOldestStopped() { nsActivePlugin * res = nsnull; @@ -663,17 +698,23 @@ nsActivePlugin * nsActivePluginList::findOldestStopped() return res; } + +//////////////////////////////////////////////////////////////////////// nsUnusedLibrary::nsUnusedLibrary(PRLibrary * aLibrary) { mLibrary = aLibrary; } + +//////////////////////////////////////////////////////////////////////// nsUnusedLibrary::~nsUnusedLibrary() { if(mLibrary) PR_UnloadLibrary(mLibrary); } + +//////////////////////////////////////////////////////////////////////// nsPluginTag::nsPluginTag() { mNext = nsnull; @@ -692,17 +733,21 @@ nsPluginTag::nsPluginTag() mFullPath = nsnull; } + +//////////////////////////////////////////////////////////////////////// inline char* new_str(const char* str) { if(str == nsnull) return nsnull; - char* result = new char[strlen(str) + 1]; - if (result != nsnull) - return strcpy(result, str); - return result; + char* result = new char[strlen(str) + 1]; + if (result != nsnull) + return strcpy(result, str); + return result; } + +//////////////////////////////////////////////////////////////////////// nsPluginTag::nsPluginTag(nsPluginTag* aPluginTag) { mNext = nsnull; @@ -733,7 +778,7 @@ nsPluginTag::nsPluginTag(nsPluginTag* aPluginTag) mExtensionsArray = new char*[mVariants]; for (int i = 0; i < mVariants; i++) mExtensionsArray[i] = new_str(aPluginTag->mExtensionsArray[i]); - } + } mLibrary = nsnull; mCanUnloadLibrary = PR_TRUE; @@ -744,6 +789,8 @@ nsPluginTag::nsPluginTag(nsPluginTag* aPluginTag) mFullPath = new_str(aPluginTag->mFullPath); } + +//////////////////////////////////////////////////////////////////////// nsPluginTag::nsPluginTag(nsPluginInfo* aPluginInfo) { mNext = nsnull; @@ -774,7 +821,7 @@ nsPluginTag::nsPluginTag(nsPluginInfo* aPluginInfo) mExtensionsArray = new char*[mVariants]; for (int i = 0; i < mVariants; i++) mExtensionsArray[i] = new_str(aPluginInfo->fExtensionArray[i]); - } + } mFileName = new_str(aPluginInfo->fFileName); mFullPath = new_str(aPluginInfo->fFullPath); @@ -787,6 +834,8 @@ nsPluginTag::nsPluginTag(nsPluginInfo* aPluginInfo) } + +//////////////////////////////////////////////////////////////////////// nsPluginTag::nsPluginTag(const char* aName, const char* aDescription, const char* aFileName, @@ -839,24 +888,24 @@ nsPluginTag::~nsPluginTag() } if (nsnull != mMimeTypeArray) { - for (int i = 0; i < mVariants; i++) - delete[] mMimeTypeArray[i]; + for (int i = 0; i < mVariants; i++) + delete[] mMimeTypeArray[i]; delete[] (mMimeTypeArray); mMimeTypeArray = nsnull; } if (nsnull != mMimeDescriptionArray) { - for (int i = 0; i < mVariants; i++) - delete[] mMimeDescriptionArray[i]; + for (int i = 0; i < mVariants; i++) + delete[] mMimeDescriptionArray[i]; delete[] (mMimeDescriptionArray); mMimeDescriptionArray = nsnull; } if (nsnull != mExtensionsArray) { - for (int i = 0; i < mVariants; i++) - delete[] mExtensionsArray[i]; + for (int i = 0; i < mVariants; i++) + delete[] mExtensionsArray[i]; delete[] (mExtensionsArray); mExtensionsArray = nsnull; @@ -876,6 +925,8 @@ nsPluginTag::~nsPluginTag() } + +//////////////////////////////////////////////////////////////////////// void nsPluginTag::TryUnloadPlugin(PRBool aForceShutdown) { PRBool isXPCOM = PR_FALSE; @@ -903,73 +954,75 @@ void nsPluginTag::TryUnloadPlugin(PRBool aForceShutdown) mLibrary = nsnull; } + +//////////////////////////////////////////////////////////////////////// class nsPluginStreamListenerPeer; class nsPluginStreamInfo : public nsIPluginStreamInfo { public: - nsPluginStreamInfo(); - virtual ~nsPluginStreamInfo(); + nsPluginStreamInfo(); + virtual ~nsPluginStreamInfo(); - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS - // nsIPluginStreamInfo interface + // nsIPluginStreamInfo interface - NS_IMETHOD - GetContentType(nsMIMEType* result); + NS_IMETHOD + GetContentType(nsMIMEType* result); - NS_IMETHOD - IsSeekable(PRBool* result); + NS_IMETHOD + IsSeekable(PRBool* result); - NS_IMETHOD - GetLength(PRUint32* result); + NS_IMETHOD + GetLength(PRUint32* result); - NS_IMETHOD - GetLastModified(PRUint32* result); + NS_IMETHOD + GetLastModified(PRUint32* result); - NS_IMETHOD - GetURL(const char** result); + NS_IMETHOD + GetURL(const char** result); - NS_IMETHOD - RequestRead(nsByteRange* rangeList); + NS_IMETHOD + RequestRead(nsByteRange* rangeList); - // local methods + // local methods - void - SetContentType(const nsMIMEType contentType); + void + SetContentType(const nsMIMEType contentType); - void - SetSeekable(const PRBool seekable); + void + SetSeekable(const PRBool seekable); - void - SetLength(const PRUint32 length); + void + SetLength(const PRUint32 length); - void - SetLastModified(const PRUint32 modified); + void + SetLastModified(const PRUint32 modified); - void - SetURL(const char* url); + void + SetURL(const char* url); - void - SetPluginInstance(nsIPluginInstance * aPluginInstance); - - void - SetPluginStreamListenerPeer(nsPluginStreamListenerPeer * aPluginStreamListenerPeer); + void + SetPluginInstance(nsIPluginInstance * aPluginInstance); - void - MakeByteRangeString(nsByteRange* aRangeList, char** string, PRInt32 *numRequests); + void + SetPluginStreamListenerPeer(nsPluginStreamListenerPeer * aPluginStreamListenerPeer); - void - SetLocalCachedFile(const char* path); + void + MakeByteRangeString(nsByteRange* aRangeList, char** string, PRInt32 *numRequests); - void - GetLocalCachedFile(char** path); + void + SetLocalCachedFile(const char* path); - void - SetLocalCachedFileStream(nsIOutputStream *stream); + void + GetLocalCachedFile(char** path); - void - GetLocalCachedFileStream(nsIOutputStream **stream); + void + SetLocalCachedFileStream(nsIOutputStream *stream); + + void + GetLocalCachedFileStream(nsIOutputStream **stream); private: @@ -985,6 +1038,7 @@ private: PRBool mLocallyCached; }; + /////////////////////////////////////////////////////////////////////////////////////////////////// class nsPluginStreamListenerPeer : public nsIStreamListener, @@ -1040,8 +1094,8 @@ private: * plugin's OnStartBinding if, for some reason, it has not already * been called. */ - PRPackedBool mStartBinding; - PRPackedBool mHaveFiredOnStartRequest; + PRPackedBool mStartBinding; + PRPackedBool mHaveFiredOnStartRequest; // these get passed to the plugin stream listener char *mMIMEType; PRUint32 mLength; @@ -1058,6 +1112,8 @@ public: }; + +//////////////////////////////////////////////////////////////////////// nsPluginStreamInfo::nsPluginStreamInfo() { NS_INIT_REFCNT(); @@ -1074,6 +1130,8 @@ nsPluginStreamInfo::nsPluginStreamInfo() mLocallyCached = PR_FALSE; } + +//////////////////////////////////////////////////////////////////////// nsPluginStreamInfo::~nsPluginStreamInfo() { if(mContentType != nsnull) @@ -1097,8 +1155,10 @@ nsPluginStreamInfo::~nsPluginStreamInfo() NS_IF_RELEASE(mPluginInstance); } +//////////////////////////////////////////////////////////////////////// NS_IMPL_ADDREF(nsPluginStreamInfo) NS_IMPL_RELEASE(nsPluginStreamInfo) +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamInfo::QueryInterface(const nsIID& aIID, void** aInstancePtrResult) @@ -1125,42 +1185,54 @@ nsresult nsPluginStreamInfo::QueryInterface(const nsIID& aIID, return NS_NOINTERFACE; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::GetContentType(nsMIMEType* result) { - *result = mContentType; - return NS_OK; + *result = mContentType; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::IsSeekable(PRBool* result) { - *result = mSeekable; - return NS_OK; + *result = mSeekable; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::GetLength(PRUint32* result) { - *result = mLength; - return NS_OK; + *result = mLength; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::GetLastModified(PRUint32* result) { - *result = mModified; - return NS_OK; + *result = mModified; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::GetURL(const char** result) { - *result = mURL; - return NS_OK; + *result = mURL; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::MakeByteRangeString(nsByteRange* aRangeList, char** rangeRequest, PRInt32 *numRequests) { @@ -1197,6 +1269,8 @@ nsPluginStreamInfo::MakeByteRangeString(nsByteRange* aRangeList, char** rangeReq return; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamInfo::RequestRead(nsByteRange* rangeList) { @@ -1257,60 +1331,73 @@ nsPluginStreamInfo::RequestRead(nsByteRange* rangeList) return channel->AsyncOpen(converter, container); } -// local methods +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetContentType(const nsMIMEType contentType) -{ - if(mContentType != nsnull) - PL_strfree(mContentType); +{ + if(mContentType != nsnull) + PL_strfree(mContentType); - mContentType = PL_strdup(contentType); + mContentType = PL_strdup(contentType); } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetSeekable(const PRBool seekable) { - mSeekable = seekable; + mSeekable = seekable; } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetLength(const PRUint32 length) { - mLength = length; + mLength = length; } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetLastModified(const PRUint32 modified) { - mModified = modified; + mModified = modified; } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetURL(const char* url) -{ - if(mURL != nsnull) - PL_strfree(mURL); +{ + if(mURL != nsnull) + PL_strfree(mURL); - mURL = PL_strdup(url); + mURL = PL_strdup(url); } +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetLocalCachedFile(const char* path) -{ - if(mFilePath != nsnull) - PL_strfree(mFilePath); +{ + if(mFilePath != nsnull) + PL_strfree(mFilePath); - mFilePath = PL_strdup(path); + mFilePath = PL_strdup(path); } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::GetLocalCachedFile(char** path) -{ - *path = PL_strdup(mFilePath); +{ + *path = PL_strdup(mFilePath); } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetLocalCachedFileStream(nsIOutputStream *stream) { @@ -1318,6 +1405,8 @@ nsPluginStreamInfo::SetLocalCachedFileStream(nsIOutputStream *stream) mLocallyCached = PR_TRUE; } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::GetLocalCachedFileStream(nsIOutputStream **stream) { @@ -1325,19 +1414,24 @@ nsPluginStreamInfo::GetLocalCachedFileStream(nsIOutputStream **stream) NS_IF_ADDREF(*stream = mFileCacheOutputStream); } + +//////////////////////////////////////////////////////////////////////// void nsPluginStreamInfo::SetPluginInstance(nsIPluginInstance * aPluginInstance) { NS_IF_ADDREF(mPluginInstance = aPluginInstance); } -void + +//////////////////////////////////////////////////////////////////////// +void nsPluginStreamInfo::SetPluginStreamListenerPeer(nsPluginStreamListenerPeer * aPluginStreamListenerPeer) { // not addref'd - nsPluginStreamInfo is owned by mPluginStreamListenerPeer mPluginStreamListenerPeer = aPluginStreamListenerPeer; } + /////////////////////////////////////////////////////////////////////////////////////////////////// class nsPluginCacheListener : public nsIStreamListener @@ -1355,6 +1449,8 @@ private: nsPluginStreamListenerPeer* mListener; }; + +//////////////////////////////////////////////////////////////////////// nsPluginCacheListener::nsPluginCacheListener(nsPluginStreamListenerPeer* aListener) { NS_INIT_REFCNT(); @@ -1363,19 +1459,25 @@ nsPluginCacheListener::nsPluginCacheListener(nsPluginStreamListenerPeer* aListen NS_ADDREF(mListener); } + +//////////////////////////////////////////////////////////////////////// nsPluginCacheListener::~nsPluginCacheListener() { NS_IF_RELEASE(mListener); } -NS_IMPL_ISUPPORTS(nsPluginCacheListener, kIStreamListenerIID); +//////////////////////////////////////////////////////////////////////// +NS_IMPL_ISUPPORTS(nsPluginCacheListener, kIStreamListenerIID); +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginCacheListener::OnStartRequest(nsIRequest *request, nsISupports* ctxt) { return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginCacheListener::OnDataAvailable(nsIRequest *request, nsISupports* ctxt, nsIInputStream* aIStream, @@ -1399,6 +1501,8 @@ nsPluginCacheListener::OnDataAvailable(nsIRequest *request, nsISupports* ctxt, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginCacheListener::OnStopRequest(nsIRequest *request, nsISupports* aContext, @@ -1430,16 +1534,19 @@ nsPluginStreamListenerPeer::nsPluginStreamListenerPeer() mDataForwardToRequest = nsnull; } + +//////////////////////////////////////////////////////////////////////// nsPluginStreamListenerPeer::~nsPluginStreamListenerPeer() { -#ifdef NS_DEBUG - if(mURL != nsnull) - { - char* spec; - (void)mURL->GetSpec(&spec); - printf("killing stream for %s\n", mURL ? spec : "(unknown URL)"); - nsCRT::free(spec); - } +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(mURL != nsnull) (void)mURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginStreamListenerPeer::dtor url=%s, POST_file=%s\n", urlSpec, mLocalFile)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); #endif NS_IF_RELEASE(mURL); @@ -1462,24 +1569,30 @@ nsPluginStreamListenerPeer::~nsPluginStreamListenerPeer() delete mDataForwardToRequest; } + +//////////////////////////////////////////////////////////////////////// NS_IMPL_ISUPPORTS3(nsPluginStreamListenerPeer, nsIStreamListener, nsIRequestObserver, nsIHttpHeaderVisitor) - +//////////////////////////////////////////////////////////////////////// /* Called as a result of GetURL and PostURL */ - +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::Initialize(nsIURI *aURL, nsIPluginInstance *aInstance, nsIPluginStreamListener* aListener, PRInt32 requestCount) { -#ifdef NS_DEBUG - char* spec; - (void)aURL->GetSpec(&spec); - printf("created stream for %s\n", spec); - nsCRT::free(spec); +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginStreamListenerPeer::Initialize instance=%p, url=%s\n", aInstance, urlSpec)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); #endif mURL = aURL; @@ -1508,41 +1621,43 @@ nsresult nsPluginStreamListenerPeer::Initialize(nsIURI *aURL, return NS_OK; } + /* - Called by NewEmbededPluginStream() - if this is called, we weren't + Called by NewEmbededPluginStream() - if this is called, we weren't able to load the plugin, so we need to load it later once we figure out the mimetype. In order to load it later, we need the plugin host and instance owner. */ - +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::InitializeEmbeded(nsIURI *aURL, nsIPluginInstance* aInstance, nsIPluginInstanceOwner *aOwner, nsIPluginHost *aHost) { -#ifdef NS_DEBUG - char* spec; - (void)aURL->GetSpec(&spec); - printf("created stream for %s\n", spec); - nsCRT::free(spec); +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginStreamListenerPeer::InitializeEmbeded url=%s\n", urlSpec)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); #endif mURL = aURL; NS_ADDREF(mURL); - if(aInstance != nsnull) - { + if(aInstance != nsnull) { NS_ASSERTION(mInstance == nsnull, "nsPluginStreamListenerPeer::InitializeEmbeded mInstance != nsnull"); - mInstance = aInstance; - NS_ADDREF(mInstance); - } - else - { - mOwner = aOwner; - NS_IF_ADDREF(mOwner); + mInstance = aInstance; + NS_ADDREF(mInstance); + } else { + mOwner = aOwner; + NS_IF_ADDREF(mOwner); - mHost = aHost; - NS_IF_ADDREF(mHost); + mHost = aHost; + NS_IF_ADDREF(mHost); } mPluginStreamInfo = new nsPluginStreamInfo(); @@ -1560,14 +1675,13 @@ nsresult nsPluginStreamListenerPeer::InitializeEmbeded(nsIURI *aURL, return NS_OK; } -/* Called by NewFullPagePluginStream() */ +/* Called by NewFullPagePluginStream() */ +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIPluginInstance *aInstance) { -#ifdef NS_DEBUG - printf("created stream for (unknown URL)\n"); - printf("Inside nsPluginStreamListenerPeer::InitializeFullPage...\n"); -#endif + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginStreamListenerPeer::InitializeFullPage instance=%p\n",aInstance)); NS_ASSERTION(mInstance == nsnull, "nsPluginStreamListenerPeer::InitializeFullPage mInstance != nsnull"); mInstance = aInstance; @@ -1589,6 +1703,7 @@ nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIPluginInstance *aInst } +//////////////////////////////////////////////////////////////////////// // SetupPluginCacheFile is called if we have to save the stream to disk. // the most likely cause for this is either there is no disk cache available // or the stream is coming from a https server. @@ -1648,6 +1763,8 @@ nsPluginStreamListenerPeer::SetupPluginCacheFile(nsIChannel* channel) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aContext) { @@ -1683,7 +1800,19 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aCo if (NS_FAILED(rv)) return rv; if (nsnull != aContentType) - mPluginStreamInfo->SetContentType(aContentType); + mPluginStreamInfo->SetContentType(aContentType); + +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NOISY, + ("nsPluginStreamListenerPeer::OnStartRequest request=%p mime=%s, url=%s\n", + request, aContentType, urlSpec)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); +#endif nsPluginWindow *window = nsnull; @@ -1711,7 +1840,7 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aCo if (NS_OK == rv) { - // GetInstance() adds a ref + // GetInstance() adds a ref mOwner->GetInstance(mInstance); if (nsnull != mInstance) @@ -1754,6 +1883,7 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request, nsISupports* aCo } +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIRequest *request, nsISupports* aContext, PRUint32 aProgress, @@ -1763,6 +1893,8 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIRequest *request, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIRequest *request, nsISupports* aContext, nsresult aStatus, @@ -1772,7 +1904,7 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIRequest *request, } - +//////////////////////////////////////////////////////////////////////// class nsPRUintKey : public nsHashKey { protected: PRUint32 mKey; @@ -1793,14 +1925,13 @@ public: }; +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request, nsISupports* aContext, nsIInputStream *aIStream, PRUint32 sourceOffset, PRUint32 aLength) { - - if(mAbort) { PRUint32 magicNumber = 0; // set it to something that is not the magic number. @@ -1828,11 +1959,14 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request, return rv; if(!mPStreamListener) - return NS_ERROR_FAILURE; + return NS_ERROR_FAILURE; char* urlString; aURL->GetSpec(&urlString); mPluginStreamInfo->SetURL(urlString); + PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("nsPluginStreamListenerPeer::OnDataAvailable request=%p, offset=%d, length=%d, url=%s\n", + request, sourceOffset, aLength, urlString)); nsCRT::free(urlString); // if the plugin has requested an AsFileOnly stream, then don't @@ -1905,6 +2039,8 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIRequest *request, nsISupports* aContext, nsresult aStatus) @@ -1925,6 +2061,10 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIRequest *request, } } + PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("nsPluginStreamListenerPeer::OnStopAvailable request=%p, cachefile=%s\n", + request, pathAndFilename)); + // If we are writting the stream to disk ourselves, lets close it nsCOMPtr outStream; mPluginStreamInfo->GetLocalCachedFileStream(getter_AddRefs(outStream)); @@ -2021,8 +2161,9 @@ NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIRequest *request, return NS_OK; } -// private methods for nsPluginStreamListenerPeer +//////////////////////////////////////////////////////////////////////// +// private methods for nsPluginStreamListenerPeer nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURI* aURL) { nsPluginCacheListener* cacheListener = new nsPluginCacheListener(this); @@ -2030,6 +2171,8 @@ nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURI* aURL) return NS_OpenURI(cacheListener, nsnull, aURL, nsnull); } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request, nsIURI* aURL) { @@ -2041,10 +2184,10 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request, // with GetURL or PostURL (i.e. it's the initial stream we // send to the plugin as determined by the SRC or DATA attribute) if(mPStreamListener == nsnull && mInstance != nsnull) - rv = mInstance->NewStream(&mPStreamListener); + rv = mInstance->NewStream(&mPStreamListener); if(rv != NS_OK) - return rv; + return rv; if(mPStreamListener == nsnull) return NS_ERROR_NULL_POINTER; @@ -2082,18 +2225,18 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request, mPluginStreamInfo->GetLength(&length); if (bSeekable && length == -1 && httpChannel) { nsXPIDLCString tmp; - httpChannel->GetResponseHeader("Content-Length", getter_Copies(tmp)); + httpChannel->GetResponseHeader("Content-Length", getter_Copies(tmp)); if (tmp.get()) { PRInt32 ignore; nsCString lenString (tmp.get()); - length = lenString.ToInteger(&ignore); - mPluginStreamInfo->SetLength(length); + length = lenString.ToInteger(&ignore); + mPluginStreamInfo->SetLength(length); } } if (length == -1) - mPluginStreamInfo->SetSeekable(PR_FALSE); + mPluginStreamInfo->SetSeekable(PR_FALSE); - // we require a content len + // we require a content len // get Last-Modified header for plugin info if (httpChannel) { @@ -2128,6 +2271,8 @@ nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request, return rv; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::OnFileAvailable(const char* aFilename) { @@ -2139,6 +2284,8 @@ nsPluginStreamListenerPeer::OnFileAvailable(const char* aFilename) return rv; } + +//////////////////////////////////////////////////////////////////////// nsILoadGroup* nsPluginStreamListenerPeer::GetLoadGroup() { @@ -2152,6 +2299,8 @@ nsPluginStreamListenerPeer::GetLoadGroup() return loadGroup; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginStreamListenerPeer::VisitHeader(const char *header, const char *value) { @@ -2162,6 +2311,8 @@ nsPluginStreamListenerPeer::VisitHeader(const char *header, const char *value) return listener->NewResponseHeader(header, value); } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginStreamListenerPeer::SetLocalFile(const char* aFilename) { NS_ENSURE_ARG_POINTER(aFilename); @@ -2202,10 +2353,26 @@ nsPluginHostImpl::nsPluginHostImpl() obsService->AddObserver(this, NS_LITERAL_STRING("quit-application").get()); obsService->AddObserver(this, NS_ConvertASCIItoUCS2(NS_XPCOM_SHUTDOWN_OBSERVER_ID).get()); } + +#ifdef PLUGIN_LOGGING + nsPluginLogging::gNPNLog = PR_NewLogModule(NPN_LOG_NAME); + nsPluginLogging::gNPPLog = PR_NewLogModule(NPP_LOG_NAME); + nsPluginLogging::gPluginLog = PR_NewLogModule(PLUGIN_LOG_NAME); + + PR_LOG(nsPluginLogging::gNPNLog, PLUGIN_LOG_ALWAYS,("NPN Logging Active!\n")); + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_ALWAYS,("General Plugin Logging Active! (nsPluginHostImpl::ctor)\n")); + PR_LOG(nsPluginLogging::gNPPLog, PLUGIN_LOG_ALWAYS,("NPP Logging Active!\n")); + + PR_LogFlush(); +#endif } + +//////////////////////////////////////////////////////////////////////// nsPluginHostImpl::~nsPluginHostImpl() { + PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("nsPluginHostImpl::dtor\n")); + #ifdef NS_DEBUG printf("nsPluginHostImpl dtor\n"); #endif @@ -2218,6 +2385,7 @@ nsPluginHostImpl::~nsPluginHostImpl() Destroy(); } +//////////////////////////////////////////////////////////////////////// NS_IMPL_ISUPPORTS7(nsPluginHostImpl, nsIPluginManager, nsIPluginManager2, @@ -2226,7 +2394,7 @@ NS_IMPL_ISUPPORTS7(nsPluginHostImpl, nsICookieStorage, nsIObserver, nsPIPluginHost); - +//////////////////////////////////////////////////////////////////////// NS_METHOD nsPluginHostImpl::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult) { @@ -2245,6 +2413,8 @@ nsPluginHostImpl::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult) return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetValue(nsPluginManagerVariable aVariable, void *aValue) { nsresult rv = NS_OK; @@ -2267,6 +2437,8 @@ NS_IMETHODIMP nsPluginHostImpl::GetValue(nsPluginManagerVariable aVariable, void return rv; } + +//////////////////////////////////////////////////////////////////////// PRBool nsPluginHostImpl::IsRunningPlugin(nsPluginTag * plugin) { if(!plugin) @@ -2287,6 +2459,8 @@ PRBool nsPluginHostImpl::IsRunningPlugin(nsPluginTag * plugin) return PR_FALSE; } + +//////////////////////////////////////////////////////////////////////// void nsPluginHostImpl::AddToUnusedLibraryList(PRLibrary * aLibrary) { NS_ASSERTION(aLibrary, "nsPluginHostImpl::AddToUnusedLibraryList: Nothing to add"); @@ -2301,6 +2475,8 @@ void nsPluginHostImpl::AddToUnusedLibraryList(PRLibrary * aLibrary) } } + +//////////////////////////////////////////////////////////////////////// // this will unload loaded but no longer needed libs which are // gathered in mUnusedLibraries list, see bug #61388 void nsPluginHostImpl::CleanUnusedLibraries() @@ -2316,8 +2492,14 @@ void nsPluginHostImpl::CleanUnusedLibraries() } } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::ReloadPlugins(PRBool reloadPages) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::ReloadPlugins Begin reloadPages=%d, active_instance_count=%d\n", + reloadPages, mActivePluginList.mCount)); + // we are re-scanning plugins. New plugins may have been added, also some // plugins may have been removed, so we should probably shut everything down // but don't touch running (active and not stopped) plugins @@ -2375,11 +2557,17 @@ nsresult nsPluginHostImpl::ReloadPlugins(PRBool reloadPages) // load them again nsresult rv = LoadPlugins(); + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::ReloadPlugins End active_instance_count=%d\n", + mActivePluginList.mCount)); + return rv; } #define NS_RETURN_UASTRING_SIZE 128 + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::UserAgent(const char **retstring) { static char resultString[NS_RETURN_UASTRING_SIZE]; @@ -2408,28 +2596,34 @@ nsresult nsPluginHostImpl::UserAgent(const char **retstring) else *retstring = nsnull; + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("nsPluginHostImpl::UserAgent return=%s\n", *retstring)); + return res; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetURL(nsISupports* pluginInst, - const char* url, - const char* target, - nsIPluginStreamListener* streamListener, - const char* altHost, - const char* referrer, - PRBool forceJSEnabled) + const char* url, + const char* target, + nsIPluginStreamListener* streamListener, + const char* altHost, + const char* referrer, + PRBool forceJSEnabled) { return GetURLWithHeaders(pluginInst, url, target, streamListener, altHost, referrer, forceJSEnabled, nsnull, nsnull); } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetURLWithHeaders(nsISupports* pluginInst, - const char* url, - const char* target, - nsIPluginStreamListener* streamListener, - const char* altHost, - const char* referrer, - PRBool forceJSEnabled, + const char* url, + const char* target, + nsIPluginStreamListener* streamListener, + const char* altHost, + const char* referrer, + PRBool forceJSEnabled, PRUint32 getHeadersLength, const char* getHeaders) { @@ -2440,7 +2634,7 @@ NS_IMETHODIMP nsPluginHostImpl::GetURLWithHeaders(nsISupports* pluginInst, // we can only send a stream back to the plugin (as specified by a // null target) if we also have a nsIPluginStreamListener to talk to also if(target == nsnull && streamListener == nsnull) - return NS_ERROR_ILLEGAL_VALUE; + return NS_ERROR_ILLEGAL_VALUE; rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance); @@ -2484,18 +2678,20 @@ NS_IMETHODIMP nsPluginHostImpl::GetURLWithHeaders(nsISupports* pluginInst, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::PostURL(nsISupports* pluginInst, - const char* url, - PRUint32 postDataLen, - const char* postData, - PRBool isFile, - const char* target, - nsIPluginStreamListener* streamListener, - const char* altHost, - const char* referrer, - PRBool forceJSEnabled, - PRUint32 postHeadersLength, - const char* postHeaders) + const char* url, + PRUint32 postDataLen, + const char* postData, + PRBool isFile, + const char* target, + nsIPluginStreamListener* streamListener, + const char* altHost, + const char* referrer, + PRBool forceJSEnabled, + PRUint32 postHeadersLength, + const char* postHeaders) { nsAutoString string; string.AssignWithConversion(url); nsIPluginInstance *instance; @@ -2505,7 +2701,7 @@ NS_IMETHODIMP nsPluginHostImpl::PostURL(nsISupports* pluginInst, // by a null target) if we also have a nsIPluginStreamListener // to talk to also if(target == nsnull && streamListener == nsnull) - return NS_ERROR_ILLEGAL_VALUE; + return NS_ERROR_ILLEGAL_VALUE; rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance); @@ -2556,6 +2752,8 @@ NS_IMETHODIMP nsPluginHostImpl::PostURL(nsISupports* pluginInst, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::RegisterPlugin(REFNSIID aCID, const char* aPluginName, const char* aDescription, @@ -2564,6 +2762,8 @@ NS_IMETHODIMP nsPluginHostImpl::RegisterPlugin(REFNSIID aCID, const char** aFileExtensions, PRInt32 aCount) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("nsPluginHostImpl::RegisterPlugin name=%s\n",aPluginName)); + nsCOMPtr registry = do_CreateInstance(kRegistryCID); if (! registry) return NS_ERROR_FAILURE; @@ -2602,6 +2802,8 @@ NS_IMETHODIMP nsPluginHostImpl::RegisterPlugin(REFNSIID aCID, return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::UnregisterPlugin(REFNSIID aCID) { nsCOMPtr registry = do_CreateInstance(kRegistryCID); @@ -2623,27 +2825,36 @@ NS_IMETHODIMP nsPluginHostImpl::UnregisterPlugin(REFNSIID aCID) return registry->RemoveSubtree(nsIRegistry::Common, path.get()); } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::BeginWaitCursor(void) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::EndWaitCursor(void) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::SupportsURLProtocol(const char* protocol, PRBool *result) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::NotifyStatusChange(nsIPlugin* plugin, nsresult errorStatus) { return NS_ERROR_NOT_IMPLEMENTED; } -/** + +/*//////////////////////////////////////////////////////////////////////// * This method queries the prefs for proxy information. * It has been tested and is known to work in the following three cases * when no proxy host or port is specified @@ -2718,36 +2929,50 @@ NS_IMETHODIMP nsPluginHostImpl::FindProxyForURL(const char* url, char* *result) return res; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::RegisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::UnregisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::AllocateMenuID(nsIEventHandler* handler, PRBool isSubmenu, PRInt16 *result) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::DeallocateMenuID(nsIEventHandler* handler, PRInt16 menuID) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::HasAllocatedMenuID(nsIEventHandler* handler, PRInt16 menuID, PRBool *result) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::ProcessNextEvent(PRBool *bEventHandled) { return NS_ERROR_NOT_IMPLEMENTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult) @@ -2756,19 +2981,27 @@ NS_IMETHODIMP nsPluginHostImpl::CreateInstance(nsISupports *aOuter, return NS_ERROR_UNEXPECTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::LockFactory(PRBool aLock) { NS_NOTREACHED("how'd I get here?"); return NS_ERROR_UNEXPECTED; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::Init(void) { return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::Destroy(void) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("nsPluginHostImpl::Destroy Called\n")); + if (mIsDestroyed) return NS_OK; @@ -2817,11 +3050,25 @@ NS_IMETHODIMP nsPluginHostImpl::Destroy(void) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// /* Called by nsPluginInstanceOwner (nsObjectFrame.cpp - embeded case) */ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, nsIURI* aURL, nsIPluginInstanceOwner *aOwner) { +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::InstatiateEmbededPlugin Begin mime=%s, owner=%p, url=%s\n", + aMimeType, aOwner, urlSpec)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); +#endif + nsresult rv; nsIPluginInstance *instance = nsnull; nsCOMPtr pti2; @@ -2864,20 +3111,14 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, } } -#ifdef NS_DEBUG - if(aMimeType) - printf("InstantiateEmbededPlugin for %s\n",aMimeType); -#endif + if(FindStoppedPluginForURL(aURL, aOwner) == NS_OK) { - if(FindStoppedPluginForURL(aURL, aOwner) == NS_OK) - { -#ifdef NS_DEBUG - printf("InstantiateEmbededPlugin find stopped\n"); -#endif + PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("nsPluginHostImpl::InstatiateEmbededPlugin FoundStopped mime=%s\n", aMimeType)); - aOwner->GetInstance(instance); + aOwner->GetInstance(instance); if(!aMimeType || PL_strcasecmp(aMimeType, "application/x-java-vm")) - rv = NewEmbededPluginStream(aURL, nsnull, instance); + rv = NewEmbededPluginStream(aURL, nsnull, instance); // notify Java DOM component nsresult res; @@ -2903,7 +3144,7 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, rv = SetUpPluginInstance(aMimeType, aURL, aOwner); if(rv == NS_OK) - rv = aOwner->GetInstance(instance); + rv = aOwner->GetInstance(instance); else { // We have the mime type either supplied in source or from the header. @@ -2928,7 +3169,7 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, result = SetUpDefaultPluginInstance(aMimeType, aURL, aOwner); if(result == NS_OK) - result = aOwner->GetInstance(instance); + result = aOwner->GetInstance(instance); if(result != NS_OK) { DisplayNoDefaultPluginDialog(aMimeType); @@ -2941,7 +3182,7 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, // if we have a failure error, it means we found a plugin for the mimetype, // but we had a problem with the entry point if(rv == NS_ERROR_FAILURE) - return rv; + return rv; // if we are here then we have loaded a plugin for this mimetype // and it could be the Default plugin @@ -2990,26 +3231,36 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, NS_RELEASE(instance); } -#ifdef NS_DEBUG - printf("InstantiateEmbededPlugin.. returning\n"); +#ifdef PLUGIN_LOGGING + char* urlSpec2 = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec2); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::InstatiateEmbededPlugin Finished mime=%s, rv=%d, owner=%p, url=%s\n", + aMimeType, rv, aOwner, urlSpec2)); + + PR_LogFlush(); + if (urlSpec2) nsCRT::free(urlSpec2); #endif + return rv; } -/* Called by nsPluginViewer.cpp (full-page case) */ +//////////////////////////////////////////////////////////////////////// +/* Called by nsPluginViewer.cpp (full-page case) */ NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType, nsString& aURLSpec, nsIStreamListener *&aStreamListener, nsIPluginInstanceOwner *aOwner) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::InstatiateFullPagePlugin Begin mime=%s, owner=%p, url=%s\n", + aMimeType, aOwner, aURLSpec.GetBuffer())); + nsresult rv; nsIURI *url; -#ifdef NS_DEBUG - printf("InstantiateFullPagePlugin for %s\n",aMimeType); -#endif - //create a URL so that the instantiator can do file ext. //based plugin lookups... rv = NS_NewURI(&url, aURLSpec); @@ -3017,16 +3268,14 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType, if (rv != NS_OK) url = nsnull; - if(FindStoppedPluginForURL(url, aOwner) == NS_OK) - { -#ifdef NS_DEBUG - printf("InstantiateFullPagePlugin, got a stopped plugin\n"); -#endif + if(FindStoppedPluginForURL(url, aOwner) == NS_OK) { + PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("nsPluginHostImpl::InstatiateFullPagePlugin FoundStopped mime=%s\n",aMimeType)); nsIPluginInstance* instance; - aOwner->GetInstance(instance); + aOwner->GetInstance(instance); if(!aMimeType || PL_strcasecmp(aMimeType, "application/x-java-vm")) - rv = NewFullPagePluginStream(aStreamListener, instance); + rv = NewFullPagePluginStream(aStreamListener, instance); NS_IF_RELEASE(instance); return NS_OK; } @@ -3040,11 +3289,6 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType, nsIPluginInstance *instance = nsnull; nsPluginWindow *window = nsnull; -#ifdef NS_DEBUG - printf("InstantiateFullPagePlugin, got it... now stream\n"); -#endif - //we got a plugin built, now stream - aOwner->GetInstance(instance); aOwner->GetWindow(window); @@ -3067,22 +3311,21 @@ NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType, } } -#ifdef NS_DEBUG - printf("Falling out of InstantiateFullPagePlugin...\n"); -#endif + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::InstatiateFullPagePlugin End mime=%s, rv=%d, owner=%p, url=%s\n", + aMimeType, rv, aOwner, aURLSpec.GetBuffer())); + return rv; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::FindStoppedPluginForURL(nsIURI* aURL, nsIPluginInstanceOwner *aOwner) { char* url; if(!aURL) - return NS_ERROR_FAILURE; - -#ifdef NS_DEBUG - printf("Inside nsPluginHostImpl::FindStoppedPluginForURL...\n"); -#endif + return NS_ERROR_FAILURE; (void)aURL->GetSpec(&url); @@ -3115,6 +3358,8 @@ nsresult nsPluginHostImpl::FindStoppedPluginForURL(nsIURI* aURL, return NS_ERROR_FAILURE; } + +//////////////////////////////////////////////////////////////////////// void nsPluginHostImpl::AddInstanceToActiveList(nsCOMPtr aPlugin, nsIPluginInstance* aInstance, nsIURI* aURL, @@ -3124,8 +3369,8 @@ void nsPluginHostImpl::AddInstanceToActiveList(nsCOMPtr aPlugin, char* url; if(!aURL) - return; - + return; + (void)aURL->GetSpec(&url); // find corresponding plugin tag @@ -3161,6 +3406,8 @@ void nsPluginHostImpl::AddInstanceToActiveList(nsCOMPtr aPlugin, nsCRT::free(url); } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::RegisterPluginMimeTypesWithLayout(nsPluginTag * pluginTag, nsIComponentManager * compManager, nsIFile * path) @@ -3169,6 +3416,10 @@ nsresult nsPluginHostImpl::RegisterPluginMimeTypesWithLayout(nsPluginTag * plugi NS_ENSURE_ARG_POINTER(pluginTag->mMimeTypeArray); NS_ENSURE_ARG_POINTER(compManager); + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::RegisterPluginMimeTypesWithLayout plugin=%s\n", + pluginTag->mFileName)); + nsresult rv = NS_OK; for(int i = 0; i < pluginTag->mVariants; i++) @@ -3184,26 +3435,45 @@ nsresult nsPluginHostImpl::RegisterPluginMimeTypesWithLayout(nsPluginTag * plugi path, PR_TRUE, PR_FALSE); + + PLUGIN_LOG(PLUGIN_LOG_NOISY, + ("nsPluginHostImpl::RegisterPluginMimeTypesWithLayout mime=%s, plugin=%s\n", + pluginTag->mMimeTypeArray[i], pluginTag->mFileName)); } return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType, nsIURI *aURL, nsIPluginInstanceOwner *aOwner) { +#ifdef PLUGIN_LOGGING + char* urlSpec = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::SetupPluginInstance Begin mime=%s, owner=%p, url=%s\n", + aMimeType, aOwner, urlSpec)); + + PR_LogFlush(); + if (urlSpec) nsCRT::free(urlSpec); +#endif + + nsresult result = NS_ERROR_FAILURE; nsIPluginInstance* instance = NULL; nsCOMPtr plugin; const char* mimetype; nsString strContractID; strContractID.AssignWithConversion (NS_INLINE_PLUGIN_CONTRACTID_PREFIX); char buf[255]; // todo: need to use a const - + if(!aURL) return NS_ERROR_FAILURE; - // if don't have a mimetype, check by file extension + // if don't have a mimetype, check by file extension if(!aMimeType) { char* extension; @@ -3222,7 +3492,7 @@ NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType, return NS_ERROR_FAILURE; } nsCRT::free(filename); - } + } else mimetype = aMimeType; @@ -3329,9 +3599,23 @@ NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType, //release what was addreffed in Create(Plugin)Instance NS_RELEASE(instance); +#ifdef PLUGIN_LOGGING + char* urlSpec2 = nsnull; + if(aURL != nsnull) (void)aURL->GetSpec(&urlSpec2); + + PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_BASIC, + ("nsPluginHostImpl::SetupPluginInstance Finished mime=%s, rv=%d, owner=%p, url=%s\n", + aMimeType, result, aOwner, urlSpec2)); + + PR_LogFlush(); + if (urlSpec2) nsCRT::free(urlSpec2); +#endif + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::SetUpDefaultPluginInstance(const char *aMimeType, nsIURI *aURL, nsIPluginInstanceOwner *aOwner) { @@ -3341,7 +3625,7 @@ nsresult nsPluginHostImpl::SetUpDefaultPluginInstance(const char *aMimeType, nsI const char* mimetype; nsString strContractID; strContractID.AssignWithConversion (NS_INLINE_PLUGIN_CONTRACTID_PREFIX); char buf[255]; // todo: need to use a const - + if(!aURL) return NS_ERROR_FAILURE; @@ -3372,7 +3656,7 @@ nsresult nsPluginHostImpl::SetUpDefaultPluginInstance(const char *aMimeType, nsI if(peer == nsnull) return NS_ERROR_OUT_OF_MEMORY; - // if we don't have a mimetype, check by file extension + // if we don't have a mimetype, check by file extension nsXPIDLCString mt; if(mimetype == nsnull) { @@ -3420,6 +3704,8 @@ nsresult nsPluginHostImpl::SetUpDefaultPluginInstance(const char *aMimeType, nsI return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::IsPluginEnabledForType(const char* aMimeType) { @@ -3452,6 +3738,8 @@ nsPluginHostImpl::IsPluginEnabledForType(const char* aMimeType) return NS_ERROR_FAILURE; } + +//////////////////////////////////////////////////////////////////////// // check comma delimetered extensions static int CompareExtensions(const char *aExtensionList, const char *aExtension) { @@ -3479,6 +3767,8 @@ static int CompareExtensions(const char *aExtensionList, const char *aExtension) return PL_strcasecmp(pExt, aExtension); } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::IsPluginEnabledForExtension(const char* aExtension, const char* &aMimeType) @@ -3504,11 +3794,11 @@ nsPluginHostImpl::IsPluginEnabledForExtension(const char* aExtension, // mExtensionsArray[cnt] could be not a single extension but // rather a list separated by commas if (0 == CompareExtensions(plugins->mExtensionsArray[cnt], aExtension)) - { - aMimeType = plugins->mMimeTypeArray[cnt]; - return NS_OK; - } - } + { + aMimeType = plugins->mMimeTypeArray[cnt]; + return NS_OK; + } + } if (cnt < variants) break; @@ -3520,112 +3810,119 @@ nsPluginHostImpl::IsPluginEnabledForExtension(const char* aExtension, return NS_ERROR_FAILURE; } + +//////////////////////////////////////////////////////////////////////// class DOMMimeTypeImpl : public nsIDOMMimeType { public: - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS - DOMMimeTypeImpl(nsPluginTag* aPluginTag, PRUint32 aMimeTypeIndex) - { - NS_INIT_ISUPPORTS(); - mDescription.AssignWithConversion(aPluginTag->mMimeDescriptionArray[aMimeTypeIndex]); - mSuffixes.AssignWithConversion(aPluginTag->mExtensionsArray[aMimeTypeIndex]); - mType.AssignWithConversion(aPluginTag->mMimeTypeArray[aMimeTypeIndex]); - } - - virtual ~DOMMimeTypeImpl() { - } + DOMMimeTypeImpl(nsPluginTag* aPluginTag, PRUint32 aMimeTypeIndex) + { + NS_INIT_ISUPPORTS(); + mDescription.AssignWithConversion(aPluginTag->mMimeDescriptionArray[aMimeTypeIndex]); + mSuffixes.AssignWithConversion(aPluginTag->mExtensionsArray[aMimeTypeIndex]); + mType.AssignWithConversion(aPluginTag->mMimeTypeArray[aMimeTypeIndex]); + } + + virtual ~DOMMimeTypeImpl() { + } - NS_METHOD GetDescription(nsAWritableString& aDescription) - { - aDescription.Assign(mDescription); - return NS_OK; - } + NS_METHOD GetDescription(nsAWritableString& aDescription) + { + aDescription.Assign(mDescription); + return NS_OK; + } - NS_METHOD GetEnabledPlugin(nsIDOMPlugin** aEnabledPlugin) - { - // this has to be implemented by the DOM version. - *aEnabledPlugin = nsnull; - return NS_OK; - } + NS_METHOD GetEnabledPlugin(nsIDOMPlugin** aEnabledPlugin) + { + // this has to be implemented by the DOM version. + *aEnabledPlugin = nsnull; + return NS_OK; + } - NS_METHOD GetSuffixes(nsAWritableString& aSuffixes) - { - aSuffixes.Assign(mSuffixes); - return NS_OK; - } + NS_METHOD GetSuffixes(nsAWritableString& aSuffixes) + { + aSuffixes.Assign(mSuffixes); + return NS_OK; + } - NS_METHOD GetType(nsAWritableString& aType) - { - aType.Assign(mType); - return NS_OK; - } + NS_METHOD GetType(nsAWritableString& aType) + { + aType.Assign(mType); + return NS_OK; + } private: - nsString mDescription; - nsString mSuffixes; - nsString mType; + nsString mDescription; + nsString mSuffixes; + nsString mType; }; -NS_IMPL_ISUPPORTS(DOMMimeTypeImpl, nsIDOMMimeType::GetIID()); +//////////////////////////////////////////////////////////////////////// +NS_IMPL_ISUPPORTS(DOMMimeTypeImpl, nsIDOMMimeType::GetIID()); +//////////////////////////////////////////////////////////////////////// class DOMPluginImpl : public nsIDOMPlugin { public: - NS_DECL_ISUPPORTS - - DOMPluginImpl(nsPluginTag* aPluginTag) : mPluginTag(aPluginTag) - { - NS_INIT_ISUPPORTS(); - } - - virtual ~DOMPluginImpl() { - } + NS_DECL_ISUPPORTS + + DOMPluginImpl(nsPluginTag* aPluginTag) : mPluginTag(aPluginTag) + { + NS_INIT_ISUPPORTS(); + } + + virtual ~DOMPluginImpl() { + } - NS_METHOD GetDescription(nsAWritableString& aDescription) - { - aDescription.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mDescription)); - return NS_OK; - } + NS_METHOD GetDescription(nsAWritableString& aDescription) + { + aDescription.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mDescription)); + return NS_OK; + } - NS_METHOD GetFilename(nsAWritableString& aFilename) - { - aFilename.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mFileName)); - return NS_OK; - } + NS_METHOD GetFilename(nsAWritableString& aFilename) + { + aFilename.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mFileName)); + return NS_OK; + } - NS_METHOD GetName(nsAWritableString& aName) - { - aName.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mName)); - return NS_OK; - } + NS_METHOD GetName(nsAWritableString& aName) + { + aName.Assign(NS_ConvertASCIItoUCS2(mPluginTag.mName)); + return NS_OK; + } - NS_METHOD GetLength(PRUint32* aLength) - { - *aLength = mPluginTag.mVariants; - return NS_OK; - } + NS_METHOD GetLength(PRUint32* aLength) + { + *aLength = mPluginTag.mVariants; + return NS_OK; + } - NS_METHOD Item(PRUint32 aIndex, nsIDOMMimeType** aReturn) - { - nsIDOMMimeType* mimeType = new DOMMimeTypeImpl(&mPluginTag, aIndex); - NS_IF_ADDREF(mimeType); - *aReturn = mimeType; - return NS_OK; - } + NS_METHOD Item(PRUint32 aIndex, nsIDOMMimeType** aReturn) + { + nsIDOMMimeType* mimeType = new DOMMimeTypeImpl(&mPluginTag, aIndex); + NS_IF_ADDREF(mimeType); + *aReturn = mimeType; + return NS_OK; + } - NS_METHOD NamedItem(const nsAReadableString& aName, nsIDOMMimeType** aReturn) - { - for (int index = mPluginTag.mVariants - 1; index >= 0; --index) { - if (aName.Equals(NS_ConvertASCIItoUCS2(mPluginTag.mMimeTypeArray[index]))) - return Item(index, aReturn); - } - return NS_OK; - } + NS_METHOD NamedItem(const nsAReadableString& aName, nsIDOMMimeType** aReturn) + { + for (int index = mPluginTag.mVariants - 1; index >= 0; --index) { + if (aName.Equals(NS_ConvertASCIItoUCS2(mPluginTag.mMimeTypeArray[index]))) + return Item(index, aReturn); + } + return NS_OK; + } private: - nsPluginTag mPluginTag; + nsPluginTag mPluginTag; }; +//////////////////////////////////////////////////////////////////////// NS_IMPL_ISUPPORTS(DOMPluginImpl, nsIDOMPlugin::GetIID()); +//////////////////////////////////////////////////////////////////////// + NS_IMETHODIMP nsPluginHostImpl::GetPluginCount(PRUint32* aPluginCount) @@ -3645,6 +3942,8 @@ nsPluginHostImpl::GetPluginCount(PRUint32* aPluginCount) return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetPlugins(PRUint32 aPluginCount, nsIDOMPlugin* aPluginArray[]) @@ -3662,6 +3961,8 @@ nsPluginHostImpl::GetPlugins(PRUint32 aPluginCount, return NS_OK; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::FindPluginEnabledForType(const char* aMimeType, nsPluginTag* &aPlugin) @@ -3698,6 +3999,8 @@ nsPluginHostImpl::FindPluginEnabledForType(const char* aMimeType, return NS_ERROR_FAILURE; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugin** aPlugin) { nsresult rv = NS_ERROR_FAILURE; @@ -3715,12 +4018,16 @@ NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugi nsPluginTag* pluginTag; if((rv = FindPluginEnabledForType(aMimeType, pluginTag)) == NS_OK) { + PLUGIN_LOG(PLUGIN_LOG_BASIC, + ("nsPluginHostImpl::GetPluginFactory Begin mime=%s, plugin=%s\n", + aMimeType, pluginTag->mFileName)); + #ifdef NS_DEBUG if(aMimeType && pluginTag->mFileName) printf("For %s found plugin %s\n", aMimeType, pluginTag->mFileName); #endif - if (nsnull == pluginTag->mLibrary) // if we haven't done this yet + if (nsnull == pluginTag->mLibrary) // if we haven't done this yet { #ifndef XP_MAC nsFileSpec file(pluginTag->mFileName); @@ -3733,7 +4040,7 @@ NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugi PRLibrary* pluginLibrary = NULL; if (pluginFile.LoadPlugin(pluginLibrary) != NS_OK || pluginLibrary == NULL) - return NS_ERROR_FAILURE; + return NS_ERROR_FAILURE; pluginTag->mLibrary = pluginLibrary; } @@ -3815,9 +4122,15 @@ NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugi } } + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::GetPluginFactory End mime=%s, rv=%d, plugin=%p name=%s\n", + aMimeType, rv, *aPlugin, (pluginTag ? pluginTag->mFileName : "(not found)"))); + return rv; } + +//////////////////////////////////////////////////////////////////////// static PRBool areTheSameFileNames(char * aPath1, char * aPath2) { if((aPath1 == nsnull) || (aPath2 == nsnull)) @@ -3850,6 +4163,8 @@ static PRBool areTheSameFileNames(char * aPath1, char * aPath2) return (nsnull == PL_strncasecmp(filename1.get(), filename2.get(), PL_strlen(filename1.get()))); } + +//////////////////////////////////////////////////////////////////////// static PRBool isJavaPlugin(nsPluginTag * tag) { if(tag->mFileName == nsnull) @@ -3858,13 +4173,15 @@ static PRBool isJavaPlugin(nsPluginTag * tag) char * filename = PL_strrchr(tag->mFileName, '\\'); if(filename != nsnull) - filename++; - else - filename = tag->mFileName; + filename++; + else + filename = tag->mFileName; return (nsnull == PL_strncasecmp(filename, "npjava", 6)); } + +//////////////////////////////////////////////////////////////////////// // currently 'unwanted' plugins are Java, and all other plugins except // RealPlayer, Acrobat, Flash static PRBool isUnwantedPlugin(nsPluginTag * tag) @@ -3894,18 +4211,23 @@ static PRBool isUnwantedPlugin(nsPluginTag * tag) return PR_TRUE; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::ScanPluginsDirectory(nsPluginsDir& pluginsDir, nsIComponentManager * compManager, nsIFile * layoutPath, PRBool checkForUnwantedPlugins) { + PLUGIN_LOG(PLUGIN_LOG_BASIC, + ("nsPluginHostImpl::ScanPluginsDirectory dir=%s\n", pluginsDir.GetCString())); + for (nsDirectoryIterator iter(pluginsDir, PR_TRUE); iter.Exists(); iter++) { - const nsFileSpec& file = iter; - if (pluginsDir.IsPluginFile(file)) + const nsFileSpec& file = iter; + if (pluginsDir.IsPluginFile(file)) { - nsPluginFile pluginFile(file); - PRLibrary* pluginLibrary = nsnull; + nsPluginFile pluginFile(file); + PRLibrary* pluginLibrary = nsnull; // load the plugin's library so we can ask it some questions, but not for Windows #ifndef XP_WIN @@ -3954,18 +4276,20 @@ nsresult nsPluginHostImpl::ScanPluginsDirectory(nsPluginsDir& pluginsDir, if(bAddIt) { pluginTag->mNext = mPlugins; - mPlugins = pluginTag; + mPlugins = pluginTag; if(layoutPath) RegisterPluginMimeTypesWithLayout(pluginTag, compManager, layoutPath); } else delete pluginTag; - } - } + } + } return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::LoadPlugins() { // do not do anything if it is already done @@ -3986,7 +4310,7 @@ NS_IMETHODIMP nsPluginHostImpl::LoadPlugins() nsCOMPtr theprefs = do_GetService(NS_PREF_CONTRACTID); - // scan the 4x plugins directory for eligible legacy plugin libraries + // scan the 4x plugins directory for eligible legacy plugin libraries #if !defined(XP_WIN) && !defined (XP_MAC) // old plugin finding logic @@ -4010,7 +4334,7 @@ NS_IMETHODIMP nsPluginHostImpl::LoadPlugins() // on Mac there is a common folder for storing plugins. Go and look there next nsPluginsDir pluginsDirMacSystem(PLUGINS_DIR_LOCATION_MAC_SYSTEM_PLUGINS_FOLDER); - + if (pluginsDirMacSystem.Valid()) { PRBool skipSystem = PR_FALSE; @@ -4023,7 +4347,7 @@ NS_IMETHODIMP nsPluginHostImpl::LoadPlugins() nsCOMPtr lpath = nsnull; if(isLayoutPath) lpath = path; - + ScanPluginsDirectory(pluginsDirMacSystem, compManager, lpath, @@ -4070,8 +4394,8 @@ NS_IMETHODIMP nsPluginHostImpl::LoadPlugins() // add if not found (check for dups) // 2. we ignore 4.x Java plugins no matter what and other // unwanted plugins as per temporary decision described in bug #23856 - nsPluginsDir pluginsDir4x(PLUGINS_DIR_LOCATION_4DOTX); - if (pluginsDir4x.Valid()) + nsPluginsDir pluginsDir4x(PLUGINS_DIR_LOCATION_4DOTX); + if (pluginsDir4x.Valid()) { nsCOMPtr lpath = nsnull; if(isLayoutPath) @@ -4170,6 +4494,8 @@ printf("found some more plugins at: %s\n", pluginPath); return NS_OK; } + +//////////////////////////////////////////////////////////////////////// static nsresult LoadXPCOMPlugin(nsIComponentManager* aComponentManager, nsIRegistry* aRegistry, @@ -4313,6 +4639,8 @@ LoadXPCOMPlugin(nsIComponentManager* aComponentManager, return rv; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::LoadXPCOMPlugins(nsIComponentManager* aComponentManager, nsIFile* aPath) { @@ -4400,8 +4728,9 @@ nsPluginHostImpl::LoadXPCOMPlugins(nsIComponentManager* aComponentManager, nsIFi return NS_OK; } -/* Called by GetURL and PostURL */ +//////////////////////////////////////////////////////////////////////// +/* Called by GetURL and PostURL */ NS_IMETHODIMP nsPluginHostImpl::NewPluginURLStream(const nsString& aURL, nsIPluginInstance *aInstance, nsIPluginStreamListener* aListener, @@ -4576,6 +4905,8 @@ NS_IMETHODIMP nsPluginHostImpl::NewPluginURLStream(const nsString& aURL, return rv; } + +//////////////////////////////////////////////////////////////////////// nsresult nsPluginHostImpl::FixPostData(const char *inPostData, PRUint32 inPostDataLen, char **outPostData, PRUint32 *outPostDataLen) @@ -4628,6 +4959,8 @@ nsPluginHostImpl::FixPostData(const char *inPostData, PRUint32 inPostDataLen, return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::AddHeadersToChannel(const char *aHeadersData, PRUint32 aHeadersDataLen, @@ -4689,9 +5022,14 @@ nsPluginHostImpl::AddHeadersToChannel(const char *aHeadersData, return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::StopPluginInstance(nsIPluginInstance* aInstance) { + PLUGIN_LOG(PLUGIN_LOG_NORMAL, + ("nsPluginHostImpl::StopPluginInstance called instance=%p\n",aInstance)); + nsActivePlugin * plugin = mActivePluginList.find(aInstance); if(plugin != nsnull) @@ -4751,8 +5089,9 @@ nsPluginHostImpl::StopPluginInstance(nsIPluginInstance* aInstance) return NS_OK; } -/* Called by InstantiateEmbededPlugin() */ +//////////////////////////////////////////////////////////////////////// +/* Called by InstantiateEmbededPlugin() */ nsresult nsPluginHostImpl::NewEmbededPluginStream(nsIURI* aURL, nsIPluginInstanceOwner *aOwner, nsIPluginInstance* aInstance) @@ -4787,8 +5126,9 @@ nsresult nsPluginHostImpl::NewEmbededPluginStream(nsIURI* aURL, return rv; } -/* Called by InstantiateFullPagePlugin() */ +//////////////////////////////////////////////////////////////////////// +/* Called by InstantiateFullPagePlugin() */ nsresult nsPluginHostImpl::NewFullPagePluginStream(nsIStreamListener *&aStreamListener, nsIPluginInstance *aInstance) { @@ -4811,34 +5151,39 @@ nsresult nsPluginHostImpl::NewFullPagePluginStream(nsIStreamListener *&aStreamLi NS_ADDREF(listener); } - - return rv; } -// nsIFileUtilities interface +// nsIFileUtilities interface +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetProgramPath(const char* *result) { - static nsSpecialSystemDirectory programDir(nsSpecialSystemDirectory::OS_CurrentProcessDirectory); - *result = programDir; - return NS_OK; + static nsSpecialSystemDirectory programDir(nsSpecialSystemDirectory::OS_CurrentProcessDirectory); + *result = programDir; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetTempDirPath(const char* *result) { - static nsSpecialSystemDirectory tempDir(nsSpecialSystemDirectory::OS_TemporaryDirectory); - *result = tempDir; - return NS_OK; + static nsSpecialSystemDirectory tempDir(nsSpecialSystemDirectory::OS_TemporaryDirectory); + *result = tempDir; + return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::NewTempFileName(const char* prefix, PRUint32 bufLen, char* resultBuf) { - return NS_ERROR_NOT_IMPLEMENTED; + return NS_ERROR_NOT_IMPLEMENTED; } + // nsICookieStorage interface +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::GetCookie(const char* inCookieURL, void* inOutCookieBuffer, PRUint32& inOutCookieSize) { nsresult rv = NS_ERROR_NOT_IMPLEMENTED; @@ -4883,6 +5228,8 @@ NS_IMETHODIMP nsPluginHostImpl::GetCookie(const char* inCookieURL, void* inOutCo return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::SetCookie(const char* inCookieURL, const void* inCookieBuffer, PRUint32 inCookieSize) { nsresult rv = NS_ERROR_NOT_IMPLEMENTED; @@ -4921,6 +5268,8 @@ NS_IMETHODIMP nsPluginHostImpl::SetCookie(const char* inCookieURL, const void* i return rv; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::Observe(nsISupports *aSubject, const PRUnichar *aTopic, const PRUnichar *someData) @@ -4940,6 +5289,8 @@ NS_IMETHODIMP nsPluginHostImpl::Observe(nsISupports *aSubject, return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::SetIsScriptableInstance(nsCOMPtr aPluginInstance, PRBool aScriptable) @@ -4955,6 +5306,8 @@ nsPluginHostImpl::SetIsScriptableInstance(nsCOMPtr aPluginIns return NS_OK; } + +//////////////////////////////////////////////////////////////////////// NS_IMETHODIMP nsPluginHostImpl::HandleBadPlugin(PRLibrary* aLibrary) { nsresult rv = NS_OK;