1999-06-28 10:35:57 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
1998-07-28 02:07:25 +00:00
|
|
|
*
|
1999-11-06 03:43:54 +00:00
|
|
|
* 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/
|
1998-07-28 02:07:25 +00:00
|
|
|
*
|
1999-11-06 03:43:54 +00:00
|
|
|
* 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.
|
1998-07-28 02:07:25 +00:00
|
|
|
*
|
1999-11-06 03:43:54 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1998-07-28 02:07:25 +00:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 03:43:54 +00:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
1998-07-28 02:07:25 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "nsPluginHostImpl.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "prio.h"
|
|
|
|
#include "prmem.h"
|
|
|
|
#include "ns4xPlugin.h"
|
1998-08-01 05:46:47 +00:00
|
|
|
#include "nsPluginInstancePeer.h"
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
#include "nsIPluginStreamListener.h"
|
1998-08-05 04:21:36 +00:00
|
|
|
#include "nsIStreamListener.h"
|
|
|
|
#include "nsIInputStream.h"
|
1999-03-11 22:48:58 +00:00
|
|
|
#include "nsIOutputStream.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
#include "nsIURL.h"
|
1999-10-09 01:18:02 +00:00
|
|
|
#include "nsXPIDLString.h"
|
|
|
|
#include "nsIPref.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
|
1999-06-25 01:41:26 +00:00
|
|
|
#include "nsIBufferInputStream.h"
|
1999-06-18 17:34:08 +00:00
|
|
|
#include "nsIIOService.h"
|
1999-06-23 03:29:44 +00:00
|
|
|
#include "nsIURL.h"
|
1999-06-25 01:41:26 +00:00
|
|
|
#include "nsIChannel.h"
|
1999-06-25 00:03:22 +00:00
|
|
|
#include "nsCOMPtr.h"
|
1999-11-30 04:50:42 +00:00
|
|
|
#include "nsNetUtil.h"
|
1999-07-07 08:08:40 +00:00
|
|
|
#include "nsIProgressEventSink.h"
|
1999-07-09 21:18:47 +00:00
|
|
|
#include "nsIDocument.h"
|
1999-10-09 01:18:02 +00:00
|
|
|
|
2000-06-20 21:04:52 +00:00
|
|
|
// for the dialog
|
|
|
|
#include "nsIStringBundle.h"
|
|
|
|
#include "nsINetSupportDialogService.h"
|
|
|
|
#include "nsIPrompt.h"
|
|
|
|
#include "nsILocale.h"
|
2000-07-13 02:44:14 +00:00
|
|
|
#include "nsIScriptGlobalObject.h"
|
|
|
|
#include "nsIScriptGlobalObjectOwner.h"
|
|
|
|
#include "nsIPrincipal.h"
|
2000-06-20 21:04:52 +00:00
|
|
|
|
1998-10-28 21:16:00 +00:00
|
|
|
#include "nsIServiceManager.h"
|
1999-03-20 23:11:25 +00:00
|
|
|
#include "nsICookieStorage.h"
|
1999-10-21 21:09:21 +00:00
|
|
|
#include "nsICookieService.h"
|
1999-04-20 19:29:28 +00:00
|
|
|
#include "nsIDOMPlugin.h"
|
|
|
|
#include "nsIDOMMimeType.h"
|
1998-09-15 03:48:58 +00:00
|
|
|
#include "prprf.h"
|
2000-07-10 07:13:31 +00:00
|
|
|
#if 0
|
1998-09-15 03:48:58 +00:00
|
|
|
#include "gui.h"
|
2000-07-10 07:13:31 +00:00
|
|
|
#endif
|
1998-12-11 05:17:50 +00:00
|
|
|
|
2000-02-28 15:00:30 +00:00
|
|
|
#if defined(XP_PC) && !defined(XP_OS2)
|
1998-07-28 02:07:25 +00:00
|
|
|
#include "windows.h"
|
1998-09-15 03:48:58 +00:00
|
|
|
#include "winbase.h"
|
1998-07-28 02:07:25 +00:00
|
|
|
#endif
|
|
|
|
|
1999-03-20 23:11:25 +00:00
|
|
|
#include "nsSpecialSystemDirectory.h"
|
1999-02-20 02:24:15 +00:00
|
|
|
#include "nsFileSpec.h"
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
#include "nsIDocumentLoaderFactory.h"
|
|
|
|
#include "nsLayoutCID.h"
|
|
|
|
|
2000-07-09 22:26:44 +00:00
|
|
|
#if defined(XP_PC)
|
|
|
|
#define LAYOUT_DLL "gkhtml.dll"
|
|
|
|
#elif defined(XP_UNIX) || defined(XP_BEOS)
|
|
|
|
#define LAYOUT_DLL "libgklayout"MOZ_DLL_SUFFIX
|
|
|
|
#elif defined(XP_MAC)
|
|
|
|
#define LAYOUT_DLL "LAYOUT_DLL"
|
|
|
|
#endif
|
|
|
|
|
2000-07-10 23:54:31 +00:00
|
|
|
#ifdef XP_MAC
|
|
|
|
#define REL_LAYOUT_DLL LAYOUT_DLL
|
|
|
|
#else
|
2000-07-09 22:26:44 +00:00
|
|
|
#define REL_LAYOUT_DLL "rel:"LAYOUT_DLL
|
2000-07-10 23:54:31 +00:00
|
|
|
#endif
|
2000-07-09 22:26:44 +00:00
|
|
|
|
1998-11-22 00:22:35 +00:00
|
|
|
//uncomment this to use netlib to determine what the
|
|
|
|
//user agent string is. we really *want* to do this,
|
|
|
|
//can't today since netlib returns 4.05, but this
|
|
|
|
//version of plugin functionality really supports
|
|
|
|
//5.0 level features. once netlib is returning
|
|
|
|
//5.0x, then we can turn this on again. MMP
|
|
|
|
//#define USE_NETLIB_FOR_USER_AGENT
|
|
|
|
|
1998-08-01 05:46:47 +00:00
|
|
|
static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID);
|
1998-08-05 04:21:36 +00:00
|
|
|
static NS_DEFINE_IID(kIPluginInstancePeerIID, NS_IPLUGININSTANCEPEER_IID);
|
1999-01-25 08:05:00 +00:00
|
|
|
static NS_DEFINE_IID(kIPluginStreamInfoIID, NS_IPLUGINSTREAMINFO_IID);
|
1999-03-03 04:10:54 +00:00
|
|
|
static NS_DEFINE_CID(kPluginCID, NS_PLUGIN_CID);
|
2000-05-26 22:14:39 +00:00
|
|
|
static NS_DEFINE_IID(kIPluginTagInfo2IID, NS_IPLUGINTAGINFO2_IID);
|
1999-10-09 01:18:02 +00:00
|
|
|
static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID);
|
1999-10-21 21:09:21 +00:00
|
|
|
static NS_DEFINE_CID(kCookieServiceCID, NS_COOKIESERVICE_CID);
|
1998-08-05 04:21:36 +00:00
|
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
|
|
static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID);
|
|
|
|
static NS_DEFINE_IID(kIStreamObserverIID, NS_ISTREAMOBSERVER_IID);
|
1999-06-18 17:34:08 +00:00
|
|
|
|
|
|
|
static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
static NS_DEFINE_IID(kIFileUtilitiesIID, NS_IFILEUTILITIES_IID);
|
1999-03-11 22:48:58 +00:00
|
|
|
static NS_DEFINE_IID(kIOutputStreamIID, NS_IOUTPUTSTREAM_IID);
|
1998-08-01 05:46:47 +00:00
|
|
|
|
2000-06-20 21:04:52 +00:00
|
|
|
// for the dialog
|
|
|
|
static NS_DEFINE_CID(kNetSupportDialogCID, NS_NETSUPPORTDIALOG_CID);
|
|
|
|
static NS_DEFINE_IID(kStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID);
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
|
|
|
|
static NS_DEFINE_IID(kDocumentFactoryImplCID, NS_LAYOUT_DOCUMENT_LOADER_FACTORY_CID);
|
|
|
|
|
2000-06-20 21:04:52 +00:00
|
|
|
#define PLUGIN_PROPERTIES_URL "chrome://global/locale/downloadProgress.properties"
|
|
|
|
void DisplayNoDefaultPluginDialog(void);
|
|
|
|
|
|
|
|
void DisplayNoDefaultPluginDialog(void)
|
|
|
|
{
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIPrompt> prompt(do_GetService(kNetSupportDialogCID));
|
|
|
|
nsCOMPtr<nsIIOService> io(do_GetService(kIOServiceCID));
|
|
|
|
nsCOMPtr<nsIStringBundleService> strings(do_GetService(kStringBundleServiceCID));
|
|
|
|
nsCOMPtr<nsIStringBundle> bundle;
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
char *spec = nsnull;
|
|
|
|
nsILocale* locale = nsnull;
|
|
|
|
nsCAutoString titleKey("noDefaultPluginTitle");
|
|
|
|
nsCAutoString messageKey("noDefaultPluginMessage");
|
|
|
|
PRInt32 buttonPressed;
|
|
|
|
|
|
|
|
if (!prompt || !io || !strings) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Taken from mozilla\extensions\wallet\src\wallet.cpp
|
|
|
|
// WalletLocalize().
|
|
|
|
|
|
|
|
rv = io->NewURI(PLUGIN_PROPERTIES_URL, nsnull, getter_AddRefs(uri));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = uri->GetSpec(&spec);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
nsCRT::free(spec);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = strings->CreateBundle(spec, locale, getter_AddRefs(bundle));
|
|
|
|
nsCRT::free(spec);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUnichar *titleUni = nsnull;
|
|
|
|
PRUnichar *messageUni = nsnull;
|
|
|
|
PRUnichar *titleKeyUni = titleKey.ToNewUnicode();
|
|
|
|
PRUnichar *messageKeyUni = messageKey.ToNewUnicode();
|
|
|
|
if (!titleKeyUni || !messageKeyUni) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
rv = bundle->GetStringFromName(NS_LITERAL_STRING("noDefaultPluginTitle"),
|
|
|
|
&titleUni);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
goto EXIT_DNDPD;
|
|
|
|
}
|
|
|
|
rv = bundle->GetStringFromName(NS_LITERAL_STRING("noDefaultPluginMessage"),
|
|
|
|
&messageUni);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
goto EXIT_DNDPD;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = prompt->UniversalDialog(
|
|
|
|
nsnull, /* title message */
|
|
|
|
titleUni, /* title text in top line of window */
|
|
|
|
messageUni, /* this is the main message */
|
|
|
|
nsnull, /* This is the checkbox message */
|
|
|
|
nsnull, /* first button text, becomes OK by default */
|
|
|
|
nsnull, /* second button text, becomes CANCEL by default */
|
|
|
|
nsnull, /* third button text */
|
|
|
|
nsnull, /* fourth button text */
|
|
|
|
nsnull, /* first edit field label */
|
|
|
|
nsnull, /* second edit field label */
|
|
|
|
nsnull, /* first edit field initial and final value */
|
|
|
|
nsnull, /* second edit field initial and final value */
|
|
|
|
nsnull, /* icon: question mark by default */
|
|
|
|
PR_FALSE, /* initial and final value of checkbox */
|
|
|
|
1, /* number of buttons */
|
|
|
|
0, /* number of edit fields */
|
|
|
|
0, /* is first edit field a password field */
|
|
|
|
|
|
|
|
&buttonPressed);
|
|
|
|
EXIT_DNDPD:
|
|
|
|
nsMemory::Free((void *)titleKeyUni);
|
|
|
|
nsMemory::Free((void *)messageKeyUni);
|
|
|
|
nsMemory::Free((void *)titleUni);
|
|
|
|
nsMemory::Free((void *)messageUni);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
nsActivePlugin::nsActivePlugin(nsIPluginInstance* aInstance, char * url)
|
|
|
|
{
|
|
|
|
mNext = nsnull;
|
|
|
|
mPeer = nsnull;
|
|
|
|
|
|
|
|
mURL = PL_strdup(url);
|
|
|
|
mInstance = aInstance;
|
|
|
|
if(aInstance != nsnull)
|
|
|
|
{
|
|
|
|
aInstance->GetPeer(&mPeer);
|
|
|
|
NS_ADDREF(aInstance);
|
|
|
|
}
|
|
|
|
mStopped = PR_FALSE;
|
2000-06-15 01:07:27 +00:00
|
|
|
mllStopTime = LL_ZERO;
|
2000-06-13 23:23:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsActivePlugin::~nsActivePlugin()
|
|
|
|
{
|
|
|
|
if(mInstance != nsnull)
|
|
|
|
{
|
|
|
|
mInstance->Destroy();
|
|
|
|
NS_RELEASE(mInstance);
|
|
|
|
NS_RELEASE(mPeer);
|
|
|
|
}
|
|
|
|
PL_strfree(mURL);
|
|
|
|
}
|
|
|
|
|
2000-06-15 01:07:27 +00:00
|
|
|
void nsActivePlugin::setStopped(PRBool stopped)
|
|
|
|
{
|
|
|
|
mStopped = stopped;
|
|
|
|
if(mStopped)
|
|
|
|
mllStopTime = PR_Now();
|
|
|
|
else
|
|
|
|
mllStopTime = LL_ZERO;
|
|
|
|
}
|
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
nsActivePluginList::nsActivePluginList()
|
|
|
|
{
|
|
|
|
first = nsnull;
|
|
|
|
last = nsnull;
|
|
|
|
count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsActivePluginList::~nsActivePluginList()
|
|
|
|
{
|
|
|
|
if(first == nsnull)
|
|
|
|
return;
|
|
|
|
shut();
|
|
|
|
}
|
|
|
|
|
|
|
|
void nsActivePluginList::shut()
|
|
|
|
{
|
|
|
|
if(first == nsnull)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for(nsActivePlugin * plugin = first; plugin != nsnull;)
|
|
|
|
{
|
|
|
|
nsActivePlugin * next = plugin->mNext;
|
|
|
|
remove(plugin);
|
|
|
|
plugin = next;
|
|
|
|
}
|
|
|
|
first = nsnull;
|
|
|
|
last = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 nsActivePluginList::add(nsActivePlugin * plugin)
|
|
|
|
{
|
|
|
|
if (first == nsnull)
|
|
|
|
{
|
|
|
|
first = plugin;
|
|
|
|
last = plugin;
|
|
|
|
first->mNext = nsnull;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
last->mNext = plugin;
|
|
|
|
last = plugin;
|
|
|
|
}
|
|
|
|
last->mNext = nsnull;
|
|
|
|
count++;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRBool nsActivePluginList::remove(nsActivePlugin * plugin)
|
|
|
|
{
|
|
|
|
if(first == nsnull)
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
nsActivePlugin * prev = nsnull;
|
|
|
|
for(nsActivePlugin * p = first; p != nsnull; p = p->mNext)
|
|
|
|
{
|
|
|
|
if(p == plugin)
|
|
|
|
{
|
|
|
|
if(p == first)
|
|
|
|
first = p->mNext;
|
|
|
|
else
|
|
|
|
prev->mNext = p->mNext;
|
|
|
|
|
|
|
|
if((prev != nsnull) && (prev->mNext == nsnull))
|
|
|
|
last = prev;
|
|
|
|
|
|
|
|
delete p;
|
|
|
|
count--;
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
prev = p;
|
|
|
|
}
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsActivePlugin * nsActivePluginList::find(nsIPluginInstance* instance)
|
|
|
|
{
|
|
|
|
for(nsActivePlugin * p = first; p != nsnull; p = p->mNext)
|
|
|
|
{
|
|
|
|
if(p->mInstance == instance)
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsActivePlugin * nsActivePluginList::findStopped(char * url)
|
|
|
|
{
|
|
|
|
for(nsActivePlugin * p = first; p != nsnull; p = p->mNext)
|
|
|
|
{
|
|
|
|
if(!PL_strcmp(url, p->mURL) && p->mStopped)
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 nsActivePluginList::getStoppedCount()
|
|
|
|
{
|
|
|
|
PRUint32 stoppedCount = 0;
|
|
|
|
for(nsActivePlugin * p = first; p != nsnull; p = p->mNext)
|
|
|
|
{
|
|
|
|
if(p->mStopped)
|
|
|
|
stoppedCount++;
|
|
|
|
}
|
|
|
|
return stoppedCount;
|
|
|
|
}
|
|
|
|
|
2000-06-15 01:07:27 +00:00
|
|
|
nsActivePlugin * nsActivePluginList::findOldestStopped()
|
|
|
|
{
|
|
|
|
nsActivePlugin * res = nsnull;
|
|
|
|
PRInt64 llTime = LL_MAXINT;
|
|
|
|
for(nsActivePlugin * p = first; p != nsnull; p = p->mNext)
|
|
|
|
{
|
|
|
|
if(!p->mStopped)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if(LL_CMP(p->mllStopTime, <, llTime))
|
|
|
|
{
|
|
|
|
llTime = p->mllStopTime;
|
|
|
|
res = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginTag::nsPluginTag()
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1999-04-20 19:29:28 +00:00
|
|
|
mNext = nsnull;
|
|
|
|
mName = nsnull;
|
|
|
|
mDescription = nsnull;
|
|
|
|
mMimeType = nsnull;
|
|
|
|
mMimeDescription = nsnull;
|
|
|
|
mExtensions = nsnull;
|
|
|
|
mVariants = 0;
|
|
|
|
mMimeTypeArray = nsnull;
|
|
|
|
mMimeDescriptionArray = nsnull;
|
|
|
|
mExtensionsArray = nsnull;
|
|
|
|
mLibrary = nsnull;
|
|
|
|
mEntryPoint = nsnull;
|
|
|
|
mFlags = NS_PLUGIN_FLAG_ENABLED;
|
2000-06-13 23:23:13 +00:00
|
|
|
mFileName = nsnull;
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
inline char* new_str(char* str)
|
|
|
|
{
|
1999-10-02 00:41:03 +00:00
|
|
|
if(str == nsnull)
|
|
|
|
return nsnull;
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
char* result = new char[strlen(str) + 1];
|
|
|
|
if (result != nsnull)
|
|
|
|
return strcpy(result, str);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginTag::nsPluginTag(nsPluginTag* aPluginTag)
|
|
|
|
{
|
|
|
|
mNext = nsnull;
|
|
|
|
mName = new_str(aPluginTag->mName);
|
|
|
|
mDescription = new_str(aPluginTag->mDescription);
|
|
|
|
mMimeType = new_str(aPluginTag->mMimeType);
|
|
|
|
mMimeDescription = new_str(aPluginTag->mMimeDescription);
|
|
|
|
mExtensions = new_str(aPluginTag->mExtensions);
|
|
|
|
mVariants = aPluginTag->mVariants;
|
2000-04-13 22:34:49 +00:00
|
|
|
|
|
|
|
mMimeTypeArray = nsnull;
|
|
|
|
mMimeDescriptionArray = nsnull;
|
|
|
|
mExtensionsArray = nsnull;
|
|
|
|
|
|
|
|
if(aPluginTag->mMimeTypeArray != nsnull)
|
|
|
|
{
|
|
|
|
mMimeTypeArray = new char*[mVariants];
|
|
|
|
for (int i = 0; i < mVariants; i++)
|
1999-04-20 19:29:28 +00:00
|
|
|
mMimeTypeArray[i] = new_str(aPluginTag->mMimeTypeArray[i]);
|
2000-04-13 22:34:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(aPluginTag->mMimeDescriptionArray != nsnull)
|
|
|
|
{
|
|
|
|
mMimeDescriptionArray = new char*[mVariants];
|
|
|
|
for (int i = 0; i < mVariants; i++)
|
1999-04-20 19:29:28 +00:00
|
|
|
mMimeDescriptionArray[i] = new_str(aPluginTag->mMimeDescriptionArray[i]);
|
2000-04-13 22:34:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(aPluginTag->mExtensionsArray != nsnull)
|
|
|
|
{
|
|
|
|
mExtensionsArray = new char*[mVariants];
|
|
|
|
for (int i = 0; i < mVariants; i++)
|
1999-04-20 19:29:28 +00:00
|
|
|
mExtensionsArray[i] = new_str(aPluginTag->mExtensionsArray[i]);
|
|
|
|
}
|
2000-04-13 22:34:49 +00:00
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
mLibrary = nsnull;
|
|
|
|
mEntryPoint = nsnull;
|
|
|
|
mFlags = NS_PLUGIN_FLAG_ENABLED;
|
2000-03-23 00:45:49 +00:00
|
|
|
mFileName = new_str(aPluginTag->mFileName);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginTag::nsPluginTag(nsPluginInfo* aPluginInfo)
|
|
|
|
{
|
|
|
|
mNext = nsnull;
|
|
|
|
mName = new_str(aPluginInfo->fName);
|
|
|
|
mDescription = new_str(aPluginInfo->fDescription);
|
|
|
|
mMimeType = new_str(aPluginInfo->fMimeType);
|
|
|
|
mMimeDescription = new_str(aPluginInfo->fMimeDescription);
|
|
|
|
mExtensions = new_str(aPluginInfo->fExtensions);
|
|
|
|
mVariants = aPluginInfo->fVariantCount;
|
|
|
|
|
2000-04-13 22:34:49 +00:00
|
|
|
mMimeTypeArray = nsnull;
|
|
|
|
mMimeDescriptionArray = nsnull;
|
|
|
|
mExtensionsArray = nsnull;
|
|
|
|
|
2000-03-29 23:58:42 +00:00
|
|
|
if(aPluginInfo->fMimeTypeArray != nsnull)
|
2000-03-23 00:45:49 +00:00
|
|
|
{
|
2000-04-13 22:34:49 +00:00
|
|
|
mMimeTypeArray = new char*[mVariants];
|
2000-03-29 23:58:42 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
2000-03-23 00:45:49 +00:00
|
|
|
mMimeTypeArray[i] = new_str(aPluginInfo->fMimeTypeArray[i]);
|
2000-03-29 23:58:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(aPluginInfo->fMimeDescriptionArray != nsnull)
|
|
|
|
{
|
2000-04-13 22:34:49 +00:00
|
|
|
mMimeDescriptionArray = new char*[mVariants];
|
2000-03-29 23:58:42 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
2000-03-23 00:45:49 +00:00
|
|
|
mMimeDescriptionArray[i] = new_str(aPluginInfo->fMimeDescriptionArray[i]);
|
2000-03-29 23:58:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(aPluginInfo->fExtensionArray != nsnull)
|
|
|
|
{
|
2000-04-13 22:34:49 +00:00
|
|
|
mExtensionsArray = new char*[mVariants];
|
2000-03-29 23:58:42 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
2000-03-23 00:45:49 +00:00
|
|
|
mExtensionsArray[i] = new_str(aPluginInfo->fExtensionArray[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
mFileName = new_str(aPluginInfo->fFileName);
|
|
|
|
|
|
|
|
mLibrary = nsnull;
|
|
|
|
mEntryPoint = nsnull;
|
|
|
|
mFlags = NS_PLUGIN_FLAG_ENABLED;
|
1999-04-20 19:29:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginTag::~nsPluginTag()
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
NS_IF_RELEASE(mEntryPoint);
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mName) {
|
|
|
|
delete[] (mName);
|
1998-07-28 02:07:25 +00:00
|
|
|
mName = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mDescription) {
|
|
|
|
delete[] (mDescription);
|
1998-07-28 02:07:25 +00:00
|
|
|
mDescription = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mMimeType) {
|
|
|
|
delete[] (mMimeType);
|
1998-07-28 02:07:25 +00:00
|
|
|
mMimeType = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mMimeDescription) {
|
|
|
|
delete[] (mMimeDescription);
|
1998-07-28 02:07:25 +00:00
|
|
|
mMimeDescription = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mExtensions) {
|
|
|
|
delete[] (mExtensions);
|
1998-07-28 02:07:25 +00:00
|
|
|
mExtensions = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mMimeTypeArray) {
|
2000-05-14 09:18:43 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
|
|
|
delete[] mMimeTypeArray[i];
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
delete[] (mMimeTypeArray);
|
1998-07-28 02:07:25 +00:00
|
|
|
mMimeTypeArray = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mMimeDescriptionArray) {
|
2000-05-14 09:18:43 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
|
|
|
delete[] mMimeDescriptionArray[i];
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
delete[] (mMimeDescriptionArray);
|
1998-07-28 02:07:25 +00:00
|
|
|
mMimeDescriptionArray = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mExtensionsArray) {
|
2000-05-14 09:18:43 +00:00
|
|
|
for (int i = 0; i < mVariants; i++)
|
|
|
|
delete[] mExtensionsArray[i];
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
delete[] (mExtensionsArray);
|
1998-07-28 02:07:25 +00:00
|
|
|
mExtensionsArray = nsnull;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
if (nsnull != mLibrary) {
|
1998-07-28 02:07:25 +00:00
|
|
|
PR_UnloadLibrary(mLibrary);
|
|
|
|
mLibrary = nsnull;
|
|
|
|
}
|
1999-06-04 22:32:27 +00:00
|
|
|
|
|
|
|
if(nsnull != mFileName)
|
|
|
|
{
|
|
|
|
delete [] mFileName;
|
|
|
|
mFileName = nsnull;
|
|
|
|
}
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
class nsPluginStreamInfo : public nsIPluginStreamInfo
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
nsPluginStreamInfo();
|
1999-03-23 03:18:12 +00:00
|
|
|
virtual ~nsPluginStreamInfo();
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
// nsIPluginStreamInfo interface
|
|
|
|
|
|
|
|
NS_IMETHOD
|
|
|
|
GetContentType(nsMIMEType* result);
|
|
|
|
|
|
|
|
NS_IMETHOD
|
|
|
|
IsSeekable(PRBool* result);
|
|
|
|
|
|
|
|
NS_IMETHOD
|
|
|
|
GetLength(PRUint32* result);
|
|
|
|
|
|
|
|
NS_IMETHOD
|
|
|
|
GetLastModified(PRUint32* result);
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
NS_IMETHOD
|
|
|
|
GetURL(const char** result);
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
NS_IMETHOD
|
|
|
|
RequestRead(nsByteRange* rangeList);
|
|
|
|
|
|
|
|
// local methods
|
|
|
|
|
|
|
|
void
|
1999-03-11 22:48:58 +00:00
|
|
|
SetContentType(const nsMIMEType contentType);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
void
|
1999-03-11 22:48:58 +00:00
|
|
|
SetSeekable(const PRBool seekable);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
void
|
1999-03-11 22:48:58 +00:00
|
|
|
SetLength(const PRUint32 length);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
void
|
1999-03-11 22:48:58 +00:00
|
|
|
SetLastModified(const PRUint32 modified);
|
|
|
|
|
|
|
|
void
|
|
|
|
SetURL(const char* url);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
char* mContentType;
|
1999-03-11 22:48:58 +00:00
|
|
|
char* mURL;
|
1999-01-25 08:05:00 +00:00
|
|
|
PRBool mSeekable;
|
|
|
|
PRUint32 mLength;
|
|
|
|
PRUint32 mModified;
|
|
|
|
};
|
|
|
|
|
|
|
|
nsPluginStreamInfo::nsPluginStreamInfo()
|
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
|
|
|
|
mContentType = nsnull;
|
1999-03-11 22:48:58 +00:00
|
|
|
mURL = nsnull;
|
1999-01-25 08:05:00 +00:00
|
|
|
mSeekable = PR_FALSE;
|
|
|
|
mLength = 0;
|
|
|
|
mModified = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPluginStreamInfo::~nsPluginStreamInfo()
|
|
|
|
{
|
|
|
|
if(mContentType != nsnull)
|
|
|
|
PL_strfree(mContentType);
|
1999-03-11 22:48:58 +00:00
|
|
|
if(mURL != nsnull)
|
|
|
|
PL_strfree(mURL);
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsPluginStreamInfo)
|
|
|
|
NS_IMPL_RELEASE(nsPluginStreamInfo)
|
|
|
|
|
|
|
|
nsresult nsPluginStreamInfo::QueryInterface(const nsIID& aIID,
|
|
|
|
void** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
if (aIID.Equals(kIPluginStreamInfoIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIPluginStreamInfo *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIStreamListener *)this));
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::GetContentType(nsMIMEType* result)
|
|
|
|
{
|
|
|
|
*result = mContentType;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::IsSeekable(PRBool* result)
|
|
|
|
{
|
|
|
|
*result = mSeekable;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::GetLength(PRUint32* result)
|
|
|
|
{
|
|
|
|
*result = mLength;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::GetLastModified(PRUint32* result)
|
|
|
|
{
|
|
|
|
*result = mModified;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::GetURL(const char** result)
|
|
|
|
{
|
|
|
|
*result = mURL;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamInfo::RequestRead(nsByteRange* rangeList)
|
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// local methods
|
|
|
|
|
|
|
|
void
|
|
|
|
nsPluginStreamInfo::SetContentType(const nsMIMEType contentType)
|
|
|
|
{
|
|
|
|
if(mContentType != nsnull)
|
|
|
|
PL_strfree(mContentType);
|
|
|
|
|
|
|
|
mContentType = PL_strdup(contentType);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsPluginStreamInfo::SetSeekable(const PRBool seekable)
|
|
|
|
{
|
|
|
|
mSeekable = seekable;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsPluginStreamInfo::SetLength(const PRUint32 length)
|
|
|
|
{
|
|
|
|
mLength = length;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nsPluginStreamInfo::SetLastModified(const PRUint32 modified)
|
|
|
|
{
|
|
|
|
mModified = modified;
|
|
|
|
}
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
void
|
|
|
|
nsPluginStreamInfo::SetURL(const char* url)
|
|
|
|
{
|
|
|
|
if(mURL != nsnull)
|
|
|
|
PL_strfree(mURL);
|
|
|
|
|
|
|
|
mURL = PL_strdup(url);
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
class nsPluginStreamListenerPeer : public nsIStreamListener
|
1999-07-07 08:08:40 +00:00
|
|
|
, public nsIProgressEventSink
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
|
|
|
public:
|
1999-01-25 08:05:00 +00:00
|
|
|
nsPluginStreamListenerPeer();
|
1999-03-23 03:18:12 +00:00
|
|
|
virtual ~nsPluginStreamListenerPeer();
|
1998-08-05 04:21:36 +00:00
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
1999-07-09 21:18:47 +00:00
|
|
|
// nsIProgressEventSink methods:
|
1999-08-22 23:52:07 +00:00
|
|
|
NS_DECL_NSIPROGRESSEVENTSINK
|
|
|
|
|
1999-07-09 21:18:47 +00:00
|
|
|
// nsIStreamObserver methods:
|
1999-08-22 23:52:07 +00:00
|
|
|
NS_DECL_NSISTREAMOBSERVER
|
|
|
|
|
1999-07-09 21:18:47 +00:00
|
|
|
// nsIStreamListener methods:
|
1999-08-22 23:52:07 +00:00
|
|
|
NS_DECL_NSISTREAMLISTENER
|
1999-06-25 00:03:22 +00:00
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
//locals
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
// Called by GetURL and PostURL (via NewStream)
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult Initialize(nsIURI *aURL, nsIPluginInstance *aInstance,
|
|
|
|
nsIPluginStreamListener *aListener);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult InitializeEmbeded(nsIURI *aURL, nsIPluginInstance* aInstance,
|
|
|
|
nsIPluginInstanceOwner *aOwner = nsnull,
|
|
|
|
nsIPluginHost *aHost = nsnull);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
nsresult InitializeFullPage(nsIPluginInstance *aInstance);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
nsresult OnFileAvailable(const char* aFilename);
|
|
|
|
|
1999-07-09 21:18:47 +00:00
|
|
|
nsILoadGroup* GetLoadGroup();
|
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
private:
|
1998-12-11 04:50:57 +00:00
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
nsresult SetUpCache(nsIURI* aURL);
|
|
|
|
nsresult SetUpStreamListener(nsIURI* aURL);
|
1998-12-11 04:50:57 +00:00
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI *mURL;
|
1998-09-15 03:48:58 +00:00
|
|
|
nsIPluginInstanceOwner *mOwner;
|
|
|
|
nsIPluginInstance *mInstance;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
nsIPluginStreamListener *mPStreamListener;
|
|
|
|
nsPluginStreamInfo *mPluginStreamInfo;
|
1999-02-04 23:37:20 +00:00
|
|
|
PRBool mSetUpListener;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
// these get passed to the plugin stream listener
|
1998-09-15 03:48:58 +00:00
|
|
|
char *mMIMEType;
|
1999-01-25 08:05:00 +00:00
|
|
|
PRUint32 mLength;
|
|
|
|
nsPluginStreamType mStreamType;
|
1998-09-15 03:48:58 +00:00
|
|
|
nsIPluginHost *mHost;
|
1999-03-11 22:48:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class nsPluginCacheListener : public nsIStreamListener
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsPluginCacheListener(nsPluginStreamListenerPeer* aListener);
|
1999-03-23 03:18:12 +00:00
|
|
|
virtual ~nsPluginCacheListener();
|
1999-03-11 22:48:58 +00:00
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
1999-09-16 01:16:22 +00:00
|
|
|
NS_DECL_NSISTREAMOBSERVER
|
|
|
|
NS_DECL_NSISTREAMLISTENER
|
1999-06-25 00:03:22 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
private:
|
2000-06-21 22:57:17 +00:00
|
|
|
nsPluginStreamListenerPeer* mListener;
|
1998-08-05 04:21:36 +00:00
|
|
|
};
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginCacheListener::nsPluginCacheListener(nsPluginStreamListenerPeer* aListener)
|
1999-03-11 22:48:58 +00:00
|
|
|
{
|
|
|
|
NS_INIT_REFCNT();
|
|
|
|
|
|
|
|
mListener = aListener;
|
|
|
|
NS_ADDREF(mListener);
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginCacheListener::~nsPluginCacheListener()
|
1999-03-11 22:48:58 +00:00
|
|
|
{
|
|
|
|
NS_IF_RELEASE(mListener);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS(nsPluginCacheListener, kIStreamListenerIID);
|
|
|
|
|
1999-06-25 00:03:22 +00:00
|
|
|
NS_IMETHODIMP
|
1999-07-07 08:08:40 +00:00
|
|
|
nsPluginCacheListener::OnStartRequest(nsIChannel* channel, nsISupports* ctxt)
|
1999-06-25 00:03:22 +00:00
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
return NS_OK;
|
1999-06-25 00:03:22 +00:00
|
|
|
}
|
1999-03-11 22:48:58 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
1999-07-07 08:08:40 +00:00
|
|
|
nsPluginCacheListener::OnDataAvailable(nsIChannel* channel, nsISupports* ctxt,
|
|
|
|
nsIInputStream* aIStream,
|
|
|
|
PRUint32 sourceOffset,
|
|
|
|
PRUint32 aLength)
|
1999-03-11 22:48:58 +00:00
|
|
|
{
|
1999-06-25 00:03:22 +00:00
|
|
|
|
2000-06-21 22:57:17 +00:00
|
|
|
PRUint32 readlen;
|
|
|
|
char* buffer = (char*) PR_Malloc(aLength);
|
1999-03-11 22:48:58 +00:00
|
|
|
|
2000-06-21 22:57:17 +00:00
|
|
|
// if we don't read from the stream, OnStopRequest will never be called
|
|
|
|
if(!buffer)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
nsresult rv = aIStream->Read(buffer, aLength, &readlen);
|
|
|
|
|
|
|
|
NS_ASSERTION(aLength == readlen, "nsCacheListener->OnDataAvailable: "
|
|
|
|
"readlen != aLength");
|
|
|
|
|
|
|
|
PR_Free(buffer);
|
|
|
|
return rv;
|
1999-03-11 22:48:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-04-22 20:50:22 +00:00
|
|
|
nsPluginCacheListener::OnStopRequest(nsIChannel* channel,
|
|
|
|
nsISupports* aContext,
|
|
|
|
nsresult aStatus,
|
|
|
|
const PRUnichar* aMsg)
|
1999-03-11 22:48:58 +00:00
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
return NS_OK;
|
1999-03-11 22:48:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginStreamListenerPeer::nsPluginStreamListenerPeer()
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
NS_INIT_REFCNT();
|
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
mURL = nsnull;
|
1998-09-15 03:48:58 +00:00
|
|
|
mOwner = nsnull;
|
1998-08-05 04:21:36 +00:00
|
|
|
mInstance = nsnull;
|
1999-01-25 08:05:00 +00:00
|
|
|
mPStreamListener = nsnull;
|
|
|
|
mPluginStreamInfo = nsnull;
|
1999-02-04 23:37:20 +00:00
|
|
|
mSetUpListener = PR_FALSE;
|
1998-08-05 04:21:36 +00:00
|
|
|
mHost = nsnull;
|
1998-09-27 22:21:39 +00:00
|
|
|
mStreamType = nsPluginStreamType_Normal;
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginStreamListenerPeer::~nsPluginStreamListenerPeer()
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
#ifdef NS_DEBUG
|
1999-01-04 23:43:41 +00:00
|
|
|
if(mURL != nsnull)
|
|
|
|
{
|
1999-06-28 10:35:57 +00:00
|
|
|
char* spec;
|
1999-01-04 23:43:41 +00:00
|
|
|
(void)mURL->GetSpec(&spec);
|
|
|
|
printf("killing stream for %s\n", mURL ? spec : "(unknown URL)");
|
1999-06-25 01:41:26 +00:00
|
|
|
nsCRT::free(spec);
|
1999-01-04 23:43:41 +00:00
|
|
|
}
|
1998-09-15 03:48:58 +00:00
|
|
|
#endif
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
NS_IF_RELEASE(mURL);
|
1998-09-15 03:48:58 +00:00
|
|
|
NS_IF_RELEASE(mOwner);
|
1998-08-05 04:21:36 +00:00
|
|
|
NS_IF_RELEASE(mInstance);
|
1999-01-25 08:05:00 +00:00
|
|
|
NS_IF_RELEASE(mPStreamListener);
|
1998-08-05 04:21:36 +00:00
|
|
|
NS_IF_RELEASE(mHost);
|
|
|
|
}
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
NS_IMPL_ADDREF(nsPluginStreamListenerPeer);
|
|
|
|
NS_IMPL_RELEASE(nsPluginStreamListenerPeer);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::QueryInterface(const nsIID& aIID,
|
2000-04-22 20:50:22 +00:00
|
|
|
void** aInstancePtrResult)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
if (aIID.Equals(kIStreamListenerIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIStreamListener *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aIID.Equals(kIStreamObserverIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIStreamObserver *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIStreamListener *)this));
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called as a result of GetURL and PostURL */
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::Initialize(nsIURI *aURL,
|
|
|
|
nsIPluginInstance *aInstance,
|
|
|
|
nsIPluginStreamListener* aListener)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
#ifdef NS_DEBUG
|
1999-06-28 10:35:57 +00:00
|
|
|
char* spec;
|
1999-01-25 08:05:00 +00:00
|
|
|
(void)aURL->GetSpec(&spec);
|
|
|
|
printf("created stream for %s\n", spec);
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(spec);
|
1999-01-25 08:05:00 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
mURL = aURL;
|
|
|
|
NS_ADDREF(mURL);
|
|
|
|
|
|
|
|
mInstance = aInstance;
|
|
|
|
NS_ADDREF(mInstance);
|
|
|
|
|
|
|
|
mPStreamListener = aListener;
|
|
|
|
NS_ADDREF(mPStreamListener);
|
|
|
|
|
|
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
1998-08-05 04:21:36 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/*
|
2000-04-22 20:50:22 +00:00
|
|
|
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.
|
1999-01-25 08:05:00 +00:00
|
|
|
*/
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::InitializeEmbeded(nsIURI *aURL,
|
|
|
|
nsIPluginInstance* aInstance,
|
|
|
|
nsIPluginInstanceOwner *aOwner,
|
|
|
|
nsIPluginHost *aHost)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
#ifdef NS_DEBUG
|
1999-06-28 10:35:57 +00:00
|
|
|
char* spec;
|
1998-12-16 05:40:20 +00:00
|
|
|
(void)aURL->GetSpec(&spec);
|
|
|
|
printf("created stream for %s\n", spec);
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(spec);
|
1998-09-15 03:48:58 +00:00
|
|
|
#endif
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
mURL = aURL;
|
|
|
|
NS_ADDREF(mURL);
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
if(aInstance != nsnull)
|
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
NS_ASSERTION(mInstance == nsnull, "nsPluginStreamListenerPeer::InitializeEmbeded mInstance != nsnull");
|
1999-01-25 08:05:00 +00:00
|
|
|
mInstance = aInstance;
|
|
|
|
NS_ADDREF(mInstance);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mOwner = aOwner;
|
|
|
|
NS_IF_ADDREF(mOwner);
|
|
|
|
|
|
|
|
mHost = aHost;
|
|
|
|
NS_IF_ADDREF(mHost);
|
|
|
|
}
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
1998-08-05 04:21:36 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by NewFullPagePluginStream() */
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIPluginInstance *aInstance)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
|
|
|
#ifdef NS_DEBUG
|
1999-01-25 08:05:00 +00:00
|
|
|
printf("created stream for (unknown URL)\n");
|
2000-04-22 20:50:22 +00:00
|
|
|
printf("Inside nsPluginStreamListenerPeer::InitializeFullPage...\n");
|
2000-06-16 22:27:16 +00:00
|
|
|
#endif
|
2000-04-22 20:50:22 +00:00
|
|
|
|
2000-06-21 22:57:17 +00:00
|
|
|
NS_ASSERTION(mInstance == nsnull, "nsPluginStreamListenerPeer::InitializeFullPage mInstance != nsnull");
|
1998-09-15 03:48:58 +00:00
|
|
|
mInstance = aInstance;
|
|
|
|
NS_ADDREF(mInstance);
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
1998-09-15 03:48:58 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1999-07-07 08:08:40 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginStreamListenerPeer::OnStartRequest(nsIChannel* channel, nsISupports* aContext)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
char* aContentType = nsnull;
|
|
|
|
rv = channel->GetContentType(&aContentType);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
nsCOMPtr<nsIURI> aURL;
|
|
|
|
rv = channel->GetURI(getter_AddRefs(aURL));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1999-06-25 00:03:22 +00:00
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
if (nsnull != aContentType)
|
1999-03-11 22:48:58 +00:00
|
|
|
mPluginStreamInfo->SetContentType(aContentType);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1998-09-15 03:48:58 +00:00
|
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
// if we don't have an nsIPluginInstance (mInstance), it means
|
|
|
|
// we weren't able to load a plugin previously because we
|
|
|
|
// didn't have the mimetype. Now that we do (aContentType),
|
|
|
|
// we'll try again with SetUpPluginInstance()
|
|
|
|
|
1998-09-15 03:48:58 +00:00
|
|
|
if ((nsnull == mInstance) && (nsnull != mOwner))
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1999-01-25 08:05:00 +00:00
|
|
|
mOwner->GetInstance(mInstance);
|
1998-09-15 03:48:58 +00:00
|
|
|
mOwner->GetWindow(window);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
if ((nsnull == mInstance) && (nsnull != mHost) && (nsnull != window))
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1999-01-25 08:05:00 +00:00
|
|
|
rv = mHost->SetUpPluginInstance(aContentType, aURL, mOwner);
|
1998-09-15 03:48:58 +00:00
|
|
|
|
|
|
|
if (NS_OK == rv)
|
|
|
|
{
|
1999-01-25 08:05:00 +00:00
|
|
|
// GetInstance() adds a ref
|
|
|
|
mOwner->GetInstance(mInstance);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
if (nsnull != mInstance)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
1999-01-25 08:05:00 +00:00
|
|
|
mInstance->Start();
|
1998-09-15 03:48:58 +00:00
|
|
|
mOwner->CreateWidget();
|
1999-01-25 08:05:00 +00:00
|
|
|
mInstance->SetWindow(window);
|
1998-09-15 03:48:58 +00:00
|
|
|
}
|
|
|
|
}
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
}
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(aContentType);
|
1999-09-09 05:13:31 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// Set up the stream listener...
|
|
|
|
//
|
|
|
|
PRInt32 length;
|
|
|
|
|
|
|
|
rv = channel->GetContentLength(&length);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
mPluginStreamInfo->SetLength(length);
|
|
|
|
|
|
|
|
rv = SetUpStreamListener(aURL);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
1998-08-05 04:21:36 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1999-07-07 08:08:40 +00:00
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer::OnProgress(nsIChannel* channel,
|
|
|
|
nsISupports* aContext,
|
|
|
|
PRUint32 aProgress,
|
|
|
|
PRUint32 aProgressMax)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1998-12-11 04:50:57 +00:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
return rv;
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
1999-07-07 08:08:40 +00:00
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStatus(nsIChannel* channel,
|
2000-04-22 20:50:22 +00:00
|
|
|
nsISupports* aContext,
|
|
|
|
const PRUnichar* aMsg)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
1999-06-25 00:03:22 +00:00
|
|
|
|
1999-07-07 08:08:40 +00:00
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIChannel* channel,
|
|
|
|
nsISupports* aContext,
|
|
|
|
nsIInputStream *aIStream,
|
|
|
|
PRUint32 sourceOffset,
|
|
|
|
PRUint32 aLength)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1999-03-11 22:48:58 +00:00
|
|
|
nsresult rv = NS_OK;
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCOMPtr<nsIURI> aURL;
|
|
|
|
rv = channel->GetURI(getter_AddRefs(aURL));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if(!mPStreamListener)
|
|
|
|
return NS_ERROR_FAILURE;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
char* urlString;
|
1999-03-11 22:48:58 +00:00
|
|
|
aURL->GetSpec(&urlString);
|
|
|
|
mPluginStreamInfo->SetURL(urlString);
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(urlString);
|
1999-03-11 22:48:58 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// if the plugin has requested an AsFileOnly stream, then don't
|
|
|
|
// call OnDataAvailable
|
1999-03-11 22:48:58 +00:00
|
|
|
if(mStreamType != nsPluginStreamType_AsFileOnly)
|
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
// It's up to the plugin to read from the stream
|
|
|
|
// If it doesn't, OnStopRequest will never be called
|
1999-04-06 01:53:37 +00:00
|
|
|
rv = mPStreamListener->OnDataAvailable((nsIPluginStreamInfo*)mPluginStreamInfo, aIStream, aLength);
|
2000-06-21 22:57:17 +00:00
|
|
|
// if a plugin returns an error, the peer must kill the stream
|
|
|
|
// else the stream and PluginStreamListener leak
|
|
|
|
if (NS_FAILED(rv))
|
|
|
|
channel->Cancel(rv);
|
1999-04-06 01:53:37 +00:00
|
|
|
}
|
|
|
|
else
|
2000-06-21 22:57:17 +00:00
|
|
|
{
|
1999-07-01 19:30:20 +00:00
|
|
|
// if we don't read from the stream, OnStopRequest will never be called
|
1999-04-06 01:53:37 +00:00
|
|
|
char* buffer = new char[aLength];
|
|
|
|
PRUint32 amountRead;
|
|
|
|
rv = aIStream->Read(buffer, aLength, &amountRead);
|
|
|
|
delete [] buffer;
|
|
|
|
}
|
1999-03-11 22:48:58 +00:00
|
|
|
return rv;
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
1999-07-07 08:08:40 +00:00
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStopRequest(nsIChannel* channel,
|
|
|
|
nsISupports* aContext,
|
|
|
|
nsresult aStatus,
|
|
|
|
const PRUnichar* aMsg)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1999-02-23 08:10:24 +00:00
|
|
|
nsresult rv = NS_OK;
|
1999-07-07 08:08:40 +00:00
|
|
|
nsCOMPtr<nsIURI> aURL;
|
|
|
|
rv = channel->GetURI(getter_AddRefs(aURL));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if(nsnull != mPStreamListener)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
1999-06-28 10:35:57 +00:00
|
|
|
char* urlString;
|
2000-06-21 22:57:17 +00:00
|
|
|
nsCOMPtr<nsIFile> localFile;
|
2000-06-22 22:51:36 +00:00
|
|
|
rv = channel->GetLocalFile(getter_AddRefs(localFile));
|
2000-06-22 22:36:37 +00:00
|
|
|
if (NS_SUCCEEDED(rv) && localFile)
|
2000-06-21 22:57:17 +00:00
|
|
|
{
|
|
|
|
char* pathAndFilename;
|
|
|
|
rv = localFile->GetPath(&pathAndFilename);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
OnFileAvailable(pathAndFilename);
|
|
|
|
nsMemory::Free(pathAndFilename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = aURL->GetSpec(&urlString);
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
mPluginStreamInfo->SetURL(urlString);
|
|
|
|
nsCRT::free(urlString);
|
|
|
|
}
|
1998-09-15 03:48:58 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
mPStreamListener->OnStopBinding((nsIPluginStreamInfo*)mPluginStreamInfo, aStatus);
|
1998-09-27 22:21:39 +00:00
|
|
|
}
|
|
|
|
|
1998-09-15 03:48:58 +00:00
|
|
|
return rv;
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
1999-06-25 00:03:22 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
// private methods for nsPluginStreamListenerPeer
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURI* aURL)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
1999-03-11 22:48:58 +00:00
|
|
|
nsPluginCacheListener* cacheListener = new nsPluginCacheListener(this);
|
1999-08-26 22:45:55 +00:00
|
|
|
// XXX: Null LoadGroup?
|
|
|
|
return NS_OpenURI(cacheListener, nsnull, aURL, nsnull);
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIURI* aURL)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
1999-02-04 23:37:20 +00:00
|
|
|
nsresult rv = NS_OK;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// If we don't yet have a stream listener, we need to get
|
|
|
|
// one from the plugin.
|
|
|
|
// NOTE: this should only happen when a stream was NOT created
|
|
|
|
// with GetURL or PostURL (i.e. it's the initial stream we
|
|
|
|
// send to the plugin as determined by the SRC or DATA attribute)
|
1999-01-25 08:05:00 +00:00
|
|
|
if(mPStreamListener == nsnull && mInstance != nsnull)
|
|
|
|
rv = mInstance->NewStream(&mPStreamListener);
|
|
|
|
|
|
|
|
if(rv != NS_OK)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
if(mPStreamListener == nsnull)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
1999-02-04 23:37:20 +00:00
|
|
|
|
|
|
|
mSetUpListener = PR_TRUE;
|
2000-04-22 20:50:22 +00:00
|
|
|
mPluginStreamInfo->SetSeekable(PR_FALSE);
|
1999-01-25 08:05:00 +00:00
|
|
|
//mPluginStreamInfo->SetModified(??);
|
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
char* urlString;
|
|
|
|
aURL->GetSpec(&urlString);
|
|
|
|
mPluginStreamInfo->SetURL(urlString);
|
|
|
|
nsCRT::free(urlString);
|
1998-07-28 02:07:25 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
rv = mPStreamListener->OnStartBinding((nsIPluginStreamInfo*)mPluginStreamInfo);
|
1998-12-11 04:50:57 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if(rv == NS_OK)
|
2000-06-21 22:57:17 +00:00
|
|
|
{
|
|
|
|
mPStreamListener->GetStreamType(&mStreamType);
|
|
|
|
// check to see if we need to cache the file as well
|
|
|
|
if ((mStreamType == nsPluginStreamType_AsFile) ||
|
2000-04-22 20:50:22 +00:00
|
|
|
(mStreamType == nsPluginStreamType_AsFileOnly))
|
2000-06-21 22:57:17 +00:00
|
|
|
rv = SetUpCache(aURL);
|
|
|
|
}
|
1998-12-11 04:50:57 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
return rv;
|
|
|
|
}
|
1998-12-11 04:50:57 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
nsresult
|
|
|
|
nsPluginStreamListenerPeer::OnFileAvailable(const char* aFilename)
|
|
|
|
{
|
2000-06-21 22:57:17 +00:00
|
|
|
nsresult rv;
|
|
|
|
if (!mPStreamListener)
|
|
|
|
return NS_ERROR_FAILURE;
|
1998-12-11 04:50:57 +00:00
|
|
|
|
2000-06-21 22:57:17 +00:00
|
|
|
rv = mPStreamListener->OnFileAvailable((nsIPluginStreamInfo*)mPluginStreamInfo, aFilename);
|
|
|
|
return rv;
|
1998-12-11 04:50:57 +00:00
|
|
|
}
|
|
|
|
|
1999-07-09 21:18:47 +00:00
|
|
|
nsILoadGroup*
|
|
|
|
nsPluginStreamListenerPeer::GetLoadGroup()
|
|
|
|
{
|
|
|
|
nsILoadGroup* loadGroup = nsnull;
|
|
|
|
nsIDocument* doc;
|
|
|
|
nsresult rv = mOwner->GetDocument(&doc);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
1999-09-18 06:55:13 +00:00
|
|
|
doc->GetDocumentLoadGroup(&loadGroup);
|
1999-07-09 21:18:47 +00:00
|
|
|
NS_RELEASE(doc);
|
|
|
|
}
|
|
|
|
return loadGroup;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
1999-01-25 08:05:00 +00:00
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginHostImpl::nsPluginHostImpl(nsIServiceManager *serviceMgr)
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
NS_INIT_REFCNT();
|
1999-01-25 08:05:00 +00:00
|
|
|
mPluginsLoaded = PR_FALSE;
|
1999-02-25 04:15:39 +00:00
|
|
|
mServiceMgr = serviceMgr;
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsPluginHostImpl::~nsPluginHostImpl()
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1998-09-15 03:48:58 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("killing plugin host\n");
|
|
|
|
#endif
|
2000-04-13 02:52:34 +00:00
|
|
|
Destroy();
|
1998-07-28 02:07:25 +00:00
|
|
|
if (nsnull != mPluginPath)
|
|
|
|
{
|
|
|
|
PR_Free(mPluginPath);
|
|
|
|
mPluginPath = nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (nsnull != mPlugins)
|
|
|
|
{
|
|
|
|
nsPluginTag *temp = mPlugins->mNext;
|
|
|
|
delete mPlugins;
|
|
|
|
mPlugins = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF(nsPluginHostImpl)
|
|
|
|
NS_IMPL_RELEASE(nsPluginHostImpl)
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginHostImpl::QueryInterface(const nsIID& aIID,
|
1998-07-28 02:07:25 +00:00
|
|
|
void** aInstancePtrResult)
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsIPluginManager::GetIID()))
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIPluginManager *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsIPluginManager2::GetIID()))
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIPluginManager2 *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsIPluginHost::GetIID()))
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIPluginHost *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsIFactory::GetIID()))
|
1998-08-02 03:20:22 +00:00
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsIFactory *)this);
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsIFileUtilities::GetIID()))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void*)(nsIFileUtilities*)this;
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
if (aIID.Equals(nsICookieStorage::GetIID())) {
|
1999-03-20 23:11:25 +00:00
|
|
|
*aInstancePtrResult = (void*)(nsICookieStorage*)this;
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-07-28 02:07:25 +00:00
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
|
|
{
|
|
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIPluginHost *)this));
|
|
|
|
AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetValue(nsPluginManagerVariable variable, void *value)
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginHostImpl::ReloadPlugins(PRBool reloadPages)
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1998-09-30 18:57:27 +00:00
|
|
|
mPluginsLoaded = PR_FALSE;
|
1998-09-15 03:48:58 +00:00
|
|
|
return LoadPlugins();
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginHostImpl::UserAgent(const char **retstring)
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1998-11-22 00:22:35 +00:00
|
|
|
nsresult res;
|
|
|
|
|
|
|
|
#ifdef USE_NETLIB_FOR_USER_AGENT
|
1998-10-28 21:16:00 +00:00
|
|
|
nsString ua;
|
|
|
|
nsINetService *service = nsnull;
|
|
|
|
|
1999-06-18 17:34:08 +00:00
|
|
|
NS_WITH_SERVICE(nsIIOService, service, kIOServiceCID, &res);
|
|
|
|
|
1998-11-22 00:22:35 +00:00
|
|
|
if ((NS_OK == res) && (nsnull != service))
|
|
|
|
{
|
|
|
|
res = service->GetUserAgent(ua);
|
|
|
|
|
|
|
|
if (NS_OK == res)
|
|
|
|
*retstring = ua.ToNewCString();
|
|
|
|
else
|
|
|
|
*retstring = nsnull;
|
|
|
|
|
|
|
|
NS_RELEASE(service);
|
1998-10-28 21:16:00 +00:00
|
|
|
}
|
1999-06-25 00:03:22 +00:00
|
|
|
#else //TODO fix this -Gagan
|
1998-11-22 00:22:35 +00:00
|
|
|
*retstring = (const char *)"Mozilla/5.0 [en] (Windows;I)";
|
|
|
|
res = NS_OK;
|
|
|
|
#endif
|
|
|
|
|
1998-10-28 21:16:00 +00:00
|
|
|
return res;
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetURL(nsISupports* pluginInst,
|
|
|
|
const char* url,
|
|
|
|
const char* target,
|
|
|
|
nsIPluginStreamListener* streamListener,
|
|
|
|
const char* altHost,
|
|
|
|
const char* referrer,
|
|
|
|
PRBool forceJSEnabled)
|
|
|
|
{
|
2000-04-03 09:20:26 +00:00
|
|
|
nsAutoString string; string.AssignWithConversion(url);
|
1999-01-25 08:05:00 +00:00
|
|
|
nsIPluginInstance *instance;
|
|
|
|
nsresult rv;
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// 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
|
1999-01-25 08:05:00 +00:00
|
|
|
if(target == nsnull && streamListener == nsnull)
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
|
|
|
|
rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
if (nsnull != target)
|
|
|
|
{
|
|
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
rv = instance->GetPeer(NS_REINTERPRET_CAST(nsIPluginInstancePeer **, &peer));
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
2000-06-16 22:27:16 +00:00
|
|
|
nsCOMPtr<nsIPluginInstanceOwner> owner;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
rv = peer->GetOwner(*getter_AddRefs(owner));
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
|
|
(0 == PL_strcmp(target, "_new")))
|
|
|
|
target = "_blank";
|
|
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
|
|
target = "_self";
|
|
|
|
|
|
|
|
rv = owner->GetURL(url, target, nsnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_RELEASE(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsnull != streamListener)
|
|
|
|
rv = NewPluginURLStream(string, instance, streamListener);
|
|
|
|
|
|
|
|
NS_RELEASE(instance);
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2000-04-03 09:20:26 +00:00
|
|
|
nsAutoString string; string.AssignWithConversion(url);
|
1999-01-25 08:05:00 +00:00
|
|
|
nsIPluginInstance *instance;
|
|
|
|
nsresult rv;
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// 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
|
1999-01-25 08:05:00 +00:00
|
|
|
if(target == nsnull && streamListener == nsnull)
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
|
|
|
|
rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
if (nsnull != target)
|
|
|
|
{
|
|
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
rv = instance->GetPeer(NS_REINTERPRET_CAST(nsIPluginInstancePeer **, &peer));
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
2000-06-16 22:27:16 +00:00
|
|
|
nsCOMPtr<nsIPluginInstanceOwner> owner;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
rv = peer->GetOwner(*getter_AddRefs(owner));
|
1999-01-25 08:05:00 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv))
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
|
|
(0 == PL_strcmp(target, "_new")))
|
|
|
|
target = "_blank";
|
|
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
|
|
target = "_self";
|
|
|
|
|
|
|
|
rv = owner->GetURL(url, target, (void*)postData);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_RELEASE(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (streamListener != nsnull)
|
|
|
|
rv = NewPluginURLStream(string, instance, streamListener);
|
|
|
|
|
|
|
|
NS_RELEASE(instance);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::BeginWaitCursor(void)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::EndWaitCursor(void)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::SupportsURLProtocol(const char* protocol, PRBool *result)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::NotifyStatusChange(nsIPlugin* plugin, nsresult errorStatus)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
1998-09-01 00:17:25 +00:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-10-09 01:18:02 +00:00
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
* when only the proxy host is specified
|
|
|
|
* when only the proxy port is specified
|
|
|
|
* This method conforms to the return code specified in
|
|
|
|
* http://developer.netscape.com/docs/manuals/proxy/adminnt/autoconf.htm#1020923
|
|
|
|
* with the exception that multiple values are not implemented.
|
|
|
|
*/
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::FindProxyForURL(const char* url, char* *result)
|
1998-09-01 00:17:25 +00:00
|
|
|
{
|
1999-10-09 01:18:02 +00:00
|
|
|
nsresult res = NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
const PRInt32 bufLen = 80;
|
|
|
|
|
|
|
|
nsIURI *uriIn = nsnull;
|
|
|
|
char *protocol = nsnull;
|
|
|
|
char buf[bufLen];
|
|
|
|
nsXPIDLCString proxyHost;
|
|
|
|
PRInt32 proxyPort = -1;
|
|
|
|
PRBool useDirect = PR_FALSE;
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsIPref, prefs, kPrefServiceCID, &res);
|
|
|
|
|
|
|
|
if (NS_FAILED(res) || (nsnull == prefs) || (nsnull == url)) {
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsIIOService, theService, kIOServiceCID, &res);
|
|
|
|
|
|
|
|
if (NS_FAILED(res) || (nsnull == theService) || (nsnull == url)) {
|
|
|
|
goto FPFU_CLEANUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
// make an nsURI from the argument url
|
|
|
|
res = theService->NewURI(url, nsnull, &uriIn);
|
|
|
|
if (NS_FAILED(res)) {
|
|
|
|
goto FPFU_CLEANUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the scheme from this nsURI
|
|
|
|
res = uriIn->GetScheme(&protocol);
|
|
|
|
if (NS_FAILED(res)) {
|
|
|
|
goto FPFU_CLEANUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_snprintf(buf, bufLen, "network.proxy.%s", protocol);
|
|
|
|
res = prefs->CopyCharPref(buf, getter_Copies(proxyHost));
|
|
|
|
if (NS_SUCCEEDED(res) && PL_strlen((const char *) proxyHost) > 0) {
|
|
|
|
PR_snprintf(buf, bufLen, "network.proxy.%s_port", protocol);
|
|
|
|
res = prefs->GetIntPref(buf, &proxyPort);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(res) && (proxyPort>0)) { // currently a bug in IntPref
|
|
|
|
// construct the return value
|
|
|
|
*result = PR_smprintf("PROXY %s:%d", (const char *) proxyHost,
|
|
|
|
proxyPort);
|
|
|
|
if (nsnull == *result) {
|
|
|
|
res = NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
goto FPFU_CLEANUP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
useDirect = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
useDirect = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (useDirect) {
|
|
|
|
// construct the return value
|
|
|
|
*result = PR_smprintf("DIRECT");
|
|
|
|
if (nsnull == *result) {
|
|
|
|
res = NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
goto FPFU_CLEANUP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
FPFU_CLEANUP:
|
|
|
|
nsCRT::free(protocol);
|
|
|
|
NS_RELEASE(uriIn);
|
|
|
|
|
|
|
|
|
|
|
|
return res;
|
1998-09-27 22:21:39 +00:00
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::RegisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::UnregisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::AllocateMenuID(nsIEventHandler* handler, PRBool isSubmenu, PRInt16 *result)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::DeallocateMenuID(nsIEventHandler* handler, PRInt16 menuID)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::HasAllocatedMenuID(nsIEventHandler* handler, PRInt16 menuID, PRBool *result)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::ProcessNextEvent(PRBool *bEventHandled)
|
1998-09-27 22:21:39 +00:00
|
|
|
{
|
1998-09-01 00:17:25 +00:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
1998-08-01 05:46:47 +00:00
|
|
|
}
|
1998-07-28 02:07:25 +00:00
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::Init(void)
|
1998-07-28 02:07:25 +00:00
|
|
|
{
|
1999-03-02 22:33:32 +00:00
|
|
|
return NS_OK;
|
1998-07-28 02:07:25 +00:00
|
|
|
}
|
|
|
|
|
1999-03-03 04:10:54 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::Destroy(void)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
|
|
|
nsPluginTag *plug = mPlugins;
|
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
mActivePluginList.shut();
|
1999-05-17 21:26:48 +00:00
|
|
|
|
1998-09-15 03:48:58 +00:00
|
|
|
while (nsnull != plug)
|
|
|
|
{
|
|
|
|
if (nsnull != plug->mEntryPoint)
|
|
|
|
plug->mEntryPoint->Shutdown();
|
|
|
|
|
|
|
|
plug = plug->mNext;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by nsPluginInstanceOwner (nsObjectFrame.cpp - embeded case) */
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType,
|
|
|
|
nsIURI* aURL,
|
|
|
|
nsIPluginInstanceOwner *aOwner)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
nsresult rv;
|
1999-03-11 22:48:58 +00:00
|
|
|
nsIPluginInstance *instance = nsnull;
|
2000-06-20 21:04:52 +00:00
|
|
|
nsCOMPtr<nsIPluginTagInfo2> pti2 = nsnull;
|
|
|
|
nsPluginTagType tagType;
|
|
|
|
PRBool isJavaEnabled = PR_TRUE;
|
|
|
|
|
|
|
|
rv = aOwner->QueryInterface(kIPluginTagInfo2IID, getter_AddRefs(pti2));
|
|
|
|
|
|
|
|
if(rv != NS_OK) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = pti2->GetTagType(&tagType);
|
|
|
|
|
2000-06-21 22:57:17 +00:00
|
|
|
if((rv != NS_OK) || !((tagType == nsPluginTagType_Embed)
|
2000-06-22 23:17:50 +00:00
|
|
|
|| (tagType == nsPluginTagType_Applet)
|
|
|
|
|| (tagType == nsPluginTagType_Object)))
|
|
|
|
{
|
2000-06-20 21:04:52 +00:00
|
|
|
return rv;
|
|
|
|
}
|
1998-08-21 01:12:53 +00:00
|
|
|
|
2000-06-30 17:31:02 +00:00
|
|
|
if (tagType == nsPluginTagType_Applet) {
|
|
|
|
nsCOMPtr<nsIPref> prefs(do_GetService(kPrefServiceCID));
|
|
|
|
// see if java is enabled
|
|
|
|
if (prefs) {
|
|
|
|
rv = prefs->GetBoolPref("security.enable_java", &isJavaEnabled);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
// if not, don't show this plugin
|
|
|
|
if (!isJavaEnabled) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// if we were unable to get the pref, assume java is enabled
|
|
|
|
// and rely on the "find the plugin or not" logic.
|
|
|
|
|
|
|
|
// make sure the value wasn't modified in GetBoolPref
|
|
|
|
isJavaEnabled = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
2000-05-12 00:46:07 +00:00
|
|
|
if(!aMimeType)
|
|
|
|
printf("InstantiateEmbededPlugin for %s\n",aMimeType);
|
1999-07-07 00:28:34 +00:00
|
|
|
#endif
|
|
|
|
|
1999-05-07 22:06:47 +00:00
|
|
|
if(FindStoppedPluginForURL(aURL, aOwner) == NS_OK)
|
|
|
|
{
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("InstantiateEmbededPlugin find stopped\n");
|
|
|
|
#endif
|
|
|
|
|
1999-05-07 22:06:47 +00:00
|
|
|
aOwner->GetInstance(instance);
|
|
|
|
if(!aMimeType || PL_strcasecmp(aMimeType, "application/x-java-vm"))
|
|
|
|
rv = NewEmbededPluginStream(aURL, nsnull, instance);
|
2000-05-16 00:22:30 +00:00
|
|
|
|
|
|
|
// notify Java DOM component
|
|
|
|
nsresult res;
|
|
|
|
NS_WITH_SERVICE(nsIPluginInstanceOwner, javaDOM, "component://netscape/blackwood/java-dom", &res);
|
|
|
|
if (NS_SUCCEEDED(res) && javaDOM)
|
|
|
|
javaDOM->SetInstance(instance);
|
|
|
|
|
2000-05-02 22:27:58 +00:00
|
|
|
NS_IF_RELEASE(instance);
|
1999-05-07 22:06:47 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
rv = SetUpPluginInstance(aMimeType, aURL, aOwner);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if(rv == NS_OK)
|
1999-05-07 22:06:47 +00:00
|
|
|
rv = aOwner->GetInstance(instance);
|
2000-06-20 21:04:52 +00:00
|
|
|
else
|
2000-05-26 22:14:39 +00:00
|
|
|
{
|
2000-06-20 21:04:52 +00:00
|
|
|
// We may not have a mime type, but that's ok. Let's try to render
|
|
|
|
// the default plugin. See bug 41197
|
|
|
|
|
2000-05-06 06:00:48 +00:00
|
|
|
// We were unable to find a plug-in yet we
|
|
|
|
// really do have mime type. Return the error
|
|
|
|
// so that the nsObjectFrame can render any
|
|
|
|
// alternate content.
|
2000-05-26 22:14:39 +00:00
|
|
|
|
|
|
|
// but try to load the default plugin first. We need to do this
|
|
|
|
// for <embed> tag leaving <object> to play with its alt content.
|
|
|
|
// but before we return an error let's see if this is an <embed>
|
|
|
|
// tag and try to launch the default plugin
|
2000-06-21 22:57:17 +00:00
|
|
|
|
2000-06-22 23:17:50 +00:00
|
|
|
// but to comply with the spec don't do it for <object> tag
|
|
|
|
if(tagType == nsPluginTagType_Object)
|
|
|
|
return rv;
|
|
|
|
|
2000-06-20 21:04:52 +00:00
|
|
|
nsresult result;
|
2000-05-26 22:14:39 +00:00
|
|
|
|
|
|
|
result = SetUpDefaultPluginInstance(aMimeType, aURL, aOwner);
|
|
|
|
|
|
|
|
if(result == NS_OK)
|
|
|
|
result = aOwner->GetInstance(instance);
|
|
|
|
|
2000-06-20 21:04:52 +00:00
|
|
|
if(result != NS_OK) {
|
|
|
|
DisplayNoDefaultPluginDialog();
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2000-05-26 22:14:39 +00:00
|
|
|
|
|
|
|
rv = NS_OK;
|
|
|
|
}
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-03-23 03:18:12 +00:00
|
|
|
// 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;
|
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if(rv != NS_OK)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
2000-04-22 20:50:22 +00:00
|
|
|
// we have not been able to load a plugin because we have not
|
|
|
|
// determined the mimetype
|
1999-03-11 22:48:58 +00:00
|
|
|
if (aURL)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
//we need to stream in enough to get the mime type...
|
1999-03-11 22:48:58 +00:00
|
|
|
rv = NewEmbededPluginStream(aURL, aOwner, nsnull);
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
rv = NS_ERROR_FAILURE;
|
|
|
|
}
|
1999-03-11 22:48:58 +00:00
|
|
|
else // we have loaded a plugin for this mimetype
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
nsPluginWindow *window = nsnull;
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
//we got a plugin built, now stream
|
|
|
|
aOwner->GetWindow(window);
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
if (nsnull != instance)
|
|
|
|
{
|
|
|
|
instance->Start();
|
|
|
|
aOwner->CreateWidget();
|
|
|
|
instance->SetWindow(window);
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-04-06 01:53:37 +00:00
|
|
|
// don't make an initial steam if it's a java applet
|
2000-04-22 20:50:22 +00:00
|
|
|
if(!aMimeType ||
|
|
|
|
(PL_strcasecmp(aMimeType, "application/x-java-vm") != 0 &&
|
|
|
|
PL_strcasecmp(aMimeType, "application/x-java-applet") != 0))
|
1999-05-08 15:19:06 +00:00
|
|
|
rv = NewEmbededPluginStream(aURL, nsnull, instance);
|
1998-08-21 01:12:53 +00:00
|
|
|
|
2000-05-16 00:22:30 +00:00
|
|
|
// notify Java DOM component
|
|
|
|
nsresult res;
|
|
|
|
NS_WITH_SERVICE(nsIPluginInstanceOwner, javaDOM, "component://netscape/blackwood/java-dom", &res);
|
|
|
|
if (NS_SUCCEEDED(res) && javaDOM)
|
|
|
|
javaDOM->SetInstance(instance);
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
NS_RELEASE(instance);
|
|
|
|
}
|
|
|
|
}
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
2000-05-03 22:34:28 +00:00
|
|
|
printf("InstantiateEmbededPlugin.. returning\n");
|
1999-07-07 00:28:34 +00:00
|
|
|
#endif
|
1999-01-25 08:05:00 +00:00
|
|
|
return rv;
|
|
|
|
}
|
1998-08-21 01:12:53 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by nsPluginViewer.cpp (full-page case) */
|
1998-07-28 02:07:25 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType,
|
|
|
|
nsString& aURLSpec,
|
|
|
|
nsIStreamListener *&aStreamListener,
|
|
|
|
nsIPluginInstanceOwner *aOwner)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
nsresult rv;
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI *url;
|
2000-06-20 21:04:52 +00:00
|
|
|
PRBool isJavaEnabled = PR_TRUE;
|
1998-07-28 02:07:25 +00:00
|
|
|
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("InstantiateFullPagePlugin for %s\n",aMimeType);
|
|
|
|
#endif
|
2000-06-30 17:31:02 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
//create a URL so that the instantiator can do file ext.
|
|
|
|
//based plugin lookups...
|
1999-06-28 10:35:57 +00:00
|
|
|
rv = NS_NewURI(&url, aURLSpec);
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
if (rv != NS_OK)
|
|
|
|
url = nsnull;
|
1999-05-07 22:06:47 +00:00
|
|
|
|
|
|
|
if(FindStoppedPluginForURL(url, aOwner) == NS_OK)
|
|
|
|
{
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("InstantiateFullPagePlugin, got a stopped plugin\n");
|
|
|
|
#endif
|
|
|
|
|
1999-05-07 22:06:47 +00:00
|
|
|
nsIPluginInstance* instance;
|
|
|
|
aOwner->GetInstance(instance);
|
|
|
|
if(!aMimeType || PL_strcasecmp(aMimeType, "application/x-java-vm"))
|
|
|
|
rv = NewFullPagePluginStream(aStreamListener, instance);
|
2000-05-02 22:27:58 +00:00
|
|
|
NS_IF_RELEASE(instance);
|
1999-05-07 22:06:47 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
rv = SetUpPluginInstance(aMimeType, url, aOwner);
|
|
|
|
|
|
|
|
NS_IF_RELEASE(url);
|
|
|
|
|
|
|
|
if (NS_OK == rv)
|
|
|
|
{
|
|
|
|
nsIPluginInstance *instance = nsnull;
|
|
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
|
1999-07-07 00:28:34 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("InstantiateFullPagePlugin, got it... now stream\n");
|
|
|
|
#endif
|
1999-01-25 08:05:00 +00:00
|
|
|
//we got a plugin built, now stream
|
|
|
|
|
|
|
|
aOwner->GetInstance(instance);
|
|
|
|
aOwner->GetWindow(window);
|
|
|
|
|
|
|
|
if (nsnull != instance)
|
|
|
|
{
|
|
|
|
instance->Start();
|
|
|
|
aOwner->CreateWidget();
|
|
|
|
instance->SetWindow(window);
|
|
|
|
|
|
|
|
rv = NewFullPagePluginStream(aStreamListener, instance);
|
|
|
|
|
|
|
|
NS_RELEASE(instance);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("Falling out of InstantiateFullPagePlugin...\n");
|
|
|
|
#endif
|
1999-01-25 08:05:00 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult nsPluginHostImpl::FindStoppedPluginForURL(nsIURI* aURL,
|
|
|
|
nsIPluginInstanceOwner *aOwner)
|
1999-05-07 22:06:47 +00:00
|
|
|
{
|
1999-06-28 10:35:57 +00:00
|
|
|
char* url;
|
1999-05-17 21:26:48 +00:00
|
|
|
if(!aURL)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("Inside nsPluginHostImpl::FindStoppedPluginForURL...\n");
|
|
|
|
#endif
|
|
|
|
|
1999-05-07 22:06:47 +00:00
|
|
|
(void)aURL->GetSpec(&url);
|
2000-06-13 23:23:13 +00:00
|
|
|
|
|
|
|
nsActivePlugin * plugin = mActivePluginList.findStopped(url);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
if((plugin != nsnull) && (plugin->mStopped))
|
1999-05-07 22:06:47 +00:00
|
|
|
{
|
2000-06-13 23:23:13 +00:00
|
|
|
nsIPluginInstance* instance = plugin->mInstance;
|
|
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
aOwner->GetWindow(window);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
aOwner->SetInstance(instance);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
// we have to reset the owner and instance in the plugin instance peer
|
|
|
|
//instance->GetPeer(&peer);
|
|
|
|
((nsPluginInstancePeerImpl*)plugin->mPeer)->SetOwner(aOwner);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
instance->Start();
|
|
|
|
aOwner->CreateWidget();
|
|
|
|
instance->SetWindow(window);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-15 01:07:27 +00:00
|
|
|
plugin->setStopped(PR_FALSE);
|
2000-06-13 23:23:13 +00:00
|
|
|
nsCRT::free(url);
|
|
|
|
return NS_OK;
|
1999-05-07 22:06:47 +00:00
|
|
|
}
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(url);
|
1999-05-07 22:06:47 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
void nsPluginHostImpl::AddInstanceToActiveList(nsIPluginInstance* aInstance,
|
|
|
|
nsIURI* aURL)
|
1999-05-07 22:06:47 +00:00
|
|
|
{
|
1999-06-28 10:35:57 +00:00
|
|
|
char* url;
|
1999-11-02 23:34:03 +00:00
|
|
|
|
1999-05-17 21:26:48 +00:00
|
|
|
if(!aURL)
|
|
|
|
return;
|
|
|
|
|
1999-05-07 22:06:47 +00:00
|
|
|
(void)aURL->GetSpec(&url);
|
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
nsActivePlugin * plugin = new nsActivePlugin(aInstance, url);
|
1999-05-07 22:06:47 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
if(plugin == nsnull)
|
|
|
|
return;
|
2000-04-26 06:19:26 +00:00
|
|
|
|
2000-06-13 23:23:13 +00:00
|
|
|
mActivePluginList.add(plugin);
|
2000-04-26 06:19:26 +00:00
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(url);
|
1999-05-07 22:06:47 +00:00
|
|
|
}
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
nsresult nsPluginHostImpl::RegisterPluginMimeTypesWithLayout(nsPluginTag * pluginTag,
|
|
|
|
nsIComponentManager * compManager,
|
|
|
|
nsIFile * layoutPath)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(pluginTag);
|
|
|
|
NS_ENSURE_ARG_POINTER(pluginTag->mMimeTypeArray);
|
|
|
|
NS_ENSURE_ARG_POINTER(compManager);
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
|
|
|
for(int i = 0; i < pluginTag->mVariants; i++)
|
|
|
|
{
|
|
|
|
char progid[512];
|
|
|
|
char * contentType = pluginTag->mMimeTypeArray[i];
|
|
|
|
PR_snprintf(progid, sizeof(progid), NS_DOCUMENT_LOADER_FACTORY_PROGID_PREFIX "%s/%s", "view", contentType);
|
|
|
|
rv = compManager->RegisterComponentSpec(kDocumentFactoryImplCID, "Layout", progid, layoutPath, PR_TRUE, PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-03-03 04:10:54 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType,
|
1999-06-23 03:29:44 +00:00
|
|
|
nsIURI *aURL,
|
1999-03-03 04:10:54 +00:00
|
|
|
nsIPluginInstanceOwner *aOwner)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_FAILURE;
|
1999-07-25 23:20:03 +00:00
|
|
|
nsIPluginInstance* instance = NULL;
|
1999-03-03 04:10:54 +00:00
|
|
|
nsIPlugin* plugin = NULL;
|
1999-03-29 22:18:05 +00:00
|
|
|
const char* mimetype;
|
2000-04-03 09:20:26 +00:00
|
|
|
nsString strProgID; strProgID.AssignWithConversion (NS_INLINE_PLUGIN_PROGID_PREFIX);
|
1999-07-25 23:20:03 +00:00
|
|
|
char buf[255]; // todo: need to use a const
|
1999-05-17 21:26:48 +00:00
|
|
|
|
|
|
|
if(!aURL)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
// if don't have a mimetype, check by file extension
|
|
|
|
if(!aMimeType)
|
|
|
|
{
|
|
|
|
char* extension;
|
1999-05-17 21:26:48 +00:00
|
|
|
|
1999-06-28 10:35:57 +00:00
|
|
|
char* filename;
|
1999-06-25 01:41:26 +00:00
|
|
|
aURL->GetPath(&filename);
|
1999-03-29 22:18:05 +00:00
|
|
|
extension = PL_strrchr(filename, '.');
|
|
|
|
if(extension)
|
|
|
|
++extension;
|
|
|
|
else
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
if(IsPluginEnabledForExtension(extension, mimetype) != NS_OK)
|
|
|
|
return NS_ERROR_FAILURE;
|
1999-06-28 10:35:57 +00:00
|
|
|
nsCRT::free(filename);
|
1999-03-29 22:18:05 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
mimetype = aMimeType;
|
|
|
|
|
2000-04-03 09:20:26 +00:00
|
|
|
strProgID.AppendWithConversion(mimetype);
|
1999-07-25 23:20:03 +00:00
|
|
|
strProgID.ToCString(buf, 255); // todo: need to use a const
|
|
|
|
|
|
|
|
result = nsComponentManager::CreateInstance(buf,
|
|
|
|
nsnull,
|
2000-04-22 20:50:22 +00:00
|
|
|
nsIPluginInstance::GetIID(),
|
1999-07-25 23:20:03 +00:00
|
|
|
(void**)&instance);
|
|
|
|
|
1999-08-03 00:17:55 +00:00
|
|
|
|
1999-07-25 23:20:03 +00:00
|
|
|
// couldn't create an XPCOM plugin, try to create wrapper for a legacy plugin
|
|
|
|
if (NS_FAILED(result)) {
|
1999-08-03 00:17:55 +00:00
|
|
|
result = GetPluginFactory(mimetype, &plugin);
|
2000-04-22 20:50:22 +00:00
|
|
|
if(!NS_FAILED(result)){
|
|
|
|
result = plugin->CreateInstance(NULL, kIPluginInstanceIID, (void **)&instance);
|
1999-07-25 23:20:03 +00:00
|
|
|
NS_RELEASE(plugin);
|
|
|
|
}
|
1999-11-16 04:18:59 +00:00
|
|
|
if (NS_FAILED(result)) {
|
|
|
|
NS_WITH_SERVICE(nsIPlugin, plugin, "component://netscape/blackwood/pluglet-engine",&result);
|
|
|
|
if (NS_SUCCEEDED(result)) {
|
|
|
|
result = plugin->CreatePluginInstance(NULL, kIPluginInstanceIID, aMimeType,(void **)&instance);
|
|
|
|
}
|
|
|
|
}
|
1999-07-25 23:20:03 +00:00
|
|
|
}
|
1999-03-29 22:18:05 +00:00
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// neither an XPCOM or legacy plugin could be instantiated,
|
|
|
|
// so return the failure
|
1999-08-03 00:17:55 +00:00
|
|
|
if (NS_FAILED(result)){
|
1999-07-25 23:20:03 +00:00
|
|
|
return result;
|
|
|
|
}
|
1999-03-03 04:10:54 +00:00
|
|
|
|
2000-04-26 06:19:26 +00:00
|
|
|
// it is adreffed here
|
1999-07-25 23:20:03 +00:00
|
|
|
aOwner->SetInstance(instance);
|
1999-03-03 04:10:54 +00:00
|
|
|
|
1999-07-25 23:20:03 +00:00
|
|
|
nsPluginInstancePeerImpl *peer = new nsPluginInstancePeerImpl();
|
1999-07-30 23:51:53 +00:00
|
|
|
if(peer == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
1999-03-03 04:10:54 +00:00
|
|
|
|
1999-07-25 23:20:03 +00:00
|
|
|
// set up the peer for the instance
|
2000-04-22 00:04:24 +00:00
|
|
|
peer->Initialize(aOwner, mimetype);
|
|
|
|
|
|
|
|
nsIPluginInstancePeer *pi;
|
|
|
|
|
|
|
|
result = peer->QueryInterface(kIPluginInstancePeerIID, (void **)&pi);
|
|
|
|
|
|
|
|
if(result != NS_OK)
|
|
|
|
return result;
|
1999-05-07 22:06:47 +00:00
|
|
|
|
1999-07-25 23:20:03 +00:00
|
|
|
// tell the plugin instance to initialize itself and pass in the peer.
|
2000-04-22 00:04:24 +00:00
|
|
|
instance->Initialize(pi); // this will not add a ref to the instance (or owner). MMP
|
|
|
|
|
|
|
|
NS_RELEASE(pi);
|
1999-07-25 23:20:03 +00:00
|
|
|
|
2000-04-26 06:19:26 +00:00
|
|
|
// we should addref here
|
1999-07-25 23:20:03 +00:00
|
|
|
AddInstanceToActiveList(instance, aURL);
|
|
|
|
|
2000-04-26 06:19:26 +00:00
|
|
|
//release what was addreffed in Create(Plugin)Instance
|
|
|
|
NS_RELEASE(instance);
|
1999-07-25 23:20:03 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
1999-03-03 04:10:54 +00:00
|
|
|
}
|
|
|
|
|
2000-05-26 22:14:39 +00:00
|
|
|
nsresult nsPluginHostImpl::SetUpDefaultPluginInstance(const char *aMimeType, nsIURI *aURL,
|
|
|
|
nsIPluginInstanceOwner *aOwner)
|
|
|
|
{
|
|
|
|
nsresult result = NS_ERROR_FAILURE;
|
|
|
|
nsIPluginInstance* instance = NULL;
|
|
|
|
nsIPlugin* plugin = NULL;
|
|
|
|
const char* mimetype;
|
|
|
|
nsString strProgID; strProgID.AssignWithConversion (NS_INLINE_PLUGIN_PROGID_PREFIX);
|
|
|
|
char buf[255]; // todo: need to use a const
|
|
|
|
|
|
|
|
if(!aURL)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
mimetype = aMimeType;
|
|
|
|
|
|
|
|
strProgID.AppendWithConversion("*");
|
|
|
|
strProgID.ToCString(buf, 255); // todo: need to use a const
|
|
|
|
|
|
|
|
result = nsComponentManager::CreateInstance(buf, nsnull, nsIPluginInstance::GetIID(), (void**)&instance);
|
|
|
|
|
|
|
|
// couldn't create an XPCOM plugin, try to create wrapper for a legacy plugin
|
|
|
|
if (NS_FAILED(result))
|
|
|
|
{
|
|
|
|
result = GetPluginFactory("*", &plugin);
|
|
|
|
if(!NS_FAILED(result))
|
|
|
|
{
|
|
|
|
result = plugin->CreateInstance(NULL, kIPluginInstanceIID, (void **)&instance);
|
|
|
|
NS_RELEASE(plugin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// neither an XPCOM or legacy plugin could be instantiated, so return the failure
|
|
|
|
if(NS_FAILED(result))
|
|
|
|
return result;
|
|
|
|
|
|
|
|
// it is adreffed here
|
|
|
|
aOwner->SetInstance(instance);
|
|
|
|
|
|
|
|
nsPluginInstancePeerImpl *peer = new nsPluginInstancePeerImpl();
|
|
|
|
if(peer == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
// set up the peer for the instance
|
|
|
|
peer->Initialize(aOwner, mimetype);
|
|
|
|
|
|
|
|
nsIPluginInstancePeer *pi;
|
|
|
|
|
|
|
|
result = peer->QueryInterface(kIPluginInstancePeerIID, (void **)&pi);
|
|
|
|
|
|
|
|
if(result != NS_OK)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
// tell the plugin instance to initialize itself and pass in the peer.
|
|
|
|
instance->Initialize(pi); // this will not add a ref to the instance (or owner). MMP
|
|
|
|
|
|
|
|
NS_RELEASE(pi);
|
|
|
|
|
|
|
|
// we should addref here
|
|
|
|
AddInstanceToActiveList(instance, aURL);
|
|
|
|
|
|
|
|
//release what was addreffed in Create(Plugin)Instance
|
|
|
|
NS_RELEASE(instance);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginHostImpl::IsPluginEnabledForType(const char* aMimeType)
|
1999-01-25 08:05:00 +00:00
|
|
|
{
|
|
|
|
nsPluginTag *plugins = nsnull;
|
|
|
|
PRInt32 variants, cnt;
|
|
|
|
|
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
|
|
LoadPlugins();
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// if we have a mimetype passed in, search the mPlugins linked
|
|
|
|
// list for a match
|
1999-01-25 08:05:00 +00:00
|
|
|
if (nsnull != aMimeType)
|
|
|
|
{
|
|
|
|
plugins = mPlugins;
|
|
|
|
|
|
|
|
while (nsnull != plugins)
|
|
|
|
{
|
|
|
|
variants = plugins->mVariants;
|
|
|
|
|
|
|
|
for (cnt = 0; cnt < variants; cnt++)
|
2000-07-11 21:44:39 +00:00
|
|
|
if (plugins->mMimeTypeArray[cnt] && (0 == strcmp(plugins->mMimeTypeArray[cnt], aMimeType)))
|
1999-03-29 22:18:05 +00:00
|
|
|
return NS_OK;
|
1999-01-25 08:05:00 +00:00
|
|
|
|
|
|
|
if (cnt < variants)
|
|
|
|
break;
|
|
|
|
|
|
|
|
plugins = plugins->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
|
1999-09-01 19:58:22 +00:00
|
|
|
// check comma delimetered extensions
|
|
|
|
static int CompareExtensions(const char *aExtensionList, const char *aExtension)
|
|
|
|
{
|
|
|
|
if((aExtensionList == nsnull) || (aExtension == nsnull))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
const char *pExt = aExtensionList;
|
1999-11-12 23:55:01 +00:00
|
|
|
const char *pComma = strchr(pExt, ',');
|
1999-09-01 19:58:22 +00:00
|
|
|
|
|
|
|
if(pComma == nsnull)
|
|
|
|
return strcmp(pExt, aExtension);
|
|
|
|
|
|
|
|
while(pComma != nsnull)
|
|
|
|
{
|
|
|
|
int length = pComma - pExt;
|
|
|
|
if(0 == strncmp(pExt, aExtension, length))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pComma++;
|
|
|
|
pExt = pComma;
|
|
|
|
pComma = strchr(pExt, ',');
|
|
|
|
}
|
|
|
|
|
|
|
|
// the last one
|
|
|
|
return strcmp(pExt, aExtension);
|
|
|
|
}
|
|
|
|
|
1999-03-23 03:18:12 +00:00
|
|
|
NS_IMETHODIMP
|
2000-04-22 20:50:22 +00:00
|
|
|
nsPluginHostImpl::IsPluginEnabledForExtension(const char* aExtension,
|
|
|
|
const char* &aMimeType)
|
1999-03-23 03:18:12 +00:00
|
|
|
{
|
|
|
|
nsPluginTag *plugins = nsnull;
|
|
|
|
PRInt32 variants, cnt;
|
|
|
|
|
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
|
|
LoadPlugins();
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
// if we have a mimetype passed in, search the mPlugins linked
|
|
|
|
// list for a match
|
1999-03-29 22:18:05 +00:00
|
|
|
if (nsnull != aExtension)
|
1999-03-23 03:18:12 +00:00
|
|
|
{
|
|
|
|
plugins = mPlugins;
|
|
|
|
|
|
|
|
while (nsnull != plugins)
|
|
|
|
{
|
|
|
|
variants = plugins->mVariants;
|
|
|
|
|
|
|
|
for (cnt = 0; cnt < variants; cnt++)
|
|
|
|
{
|
1999-09-01 19:58:22 +00:00
|
|
|
//if (0 == strcmp(plugins->mExtensionsArray[cnt], aExtension))
|
2000-04-22 20:50:22 +00:00
|
|
|
// mExtensionsArray[cnt] could be not a single extension but
|
|
|
|
// rather a list separated by commas
|
1999-09-01 19:58:22 +00:00
|
|
|
if (0 == CompareExtensions(plugins->mExtensionsArray[cnt], aExtension))
|
|
|
|
{
|
|
|
|
aMimeType = plugins->mMimeTypeArray[cnt];
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
1999-03-23 03:18:12 +00:00
|
|
|
|
|
|
|
if (cnt < variants)
|
|
|
|
break;
|
|
|
|
|
|
|
|
plugins = plugins->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
class DOMMimeTypeImpl : public nsIDOMMimeType {
|
|
|
|
public:
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
DOMMimeTypeImpl(nsPluginTag* aPluginTag, PRUint32 aMimeTypeIndex)
|
|
|
|
{
|
|
|
|
NS_INIT_ISUPPORTS();
|
2000-04-03 09:20:26 +00:00
|
|
|
mDescription.AssignWithConversion(aPluginTag->mMimeDescriptionArray[aMimeTypeIndex]);
|
|
|
|
mSuffixes.AssignWithConversion(aPluginTag->mExtensionsArray[aMimeTypeIndex]);
|
|
|
|
mType.AssignWithConversion(aPluginTag->mMimeTypeArray[aMimeTypeIndex]);
|
1999-04-20 19:29:28 +00:00
|
|
|
}
|
|
|
|
|
1999-05-13 02:17:09 +00:00
|
|
|
virtual ~DOMMimeTypeImpl() {
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_METHOD GetDescription(nsString& aDescription)
|
|
|
|
{
|
|
|
|
aDescription = 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 GetSuffixes(nsString& aSuffixes)
|
|
|
|
{
|
|
|
|
aSuffixes = mSuffixes;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_METHOD GetType(nsString& aType)
|
|
|
|
{
|
|
|
|
aType = mType;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsString mDescription;
|
|
|
|
nsString mSuffixes;
|
|
|
|
nsString mType;
|
|
|
|
};
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
NS_IMPL_ISUPPORTS(DOMMimeTypeImpl, nsIDOMMimeType::GetIID());
|
1999-04-20 19:29:28 +00:00
|
|
|
|
|
|
|
class DOMPluginImpl : public nsIDOMPlugin {
|
|
|
|
public:
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
DOMPluginImpl(nsPluginTag* aPluginTag) : mPluginTag(aPluginTag)
|
|
|
|
{
|
|
|
|
NS_INIT_ISUPPORTS();
|
|
|
|
}
|
|
|
|
|
1999-05-13 02:17:09 +00:00
|
|
|
virtual ~DOMPluginImpl() {
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_METHOD GetDescription(nsString& aDescription)
|
|
|
|
{
|
2000-04-03 09:20:26 +00:00
|
|
|
aDescription.AssignWithConversion(mPluginTag.mDescription);
|
1999-04-20 19:29:28 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_METHOD GetFilename(nsString& aFilename)
|
|
|
|
{
|
2000-04-03 09:20:26 +00:00
|
|
|
aFilename.AssignWithConversion(mPluginTag.mFileName);
|
1999-04-20 19:29:28 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_METHOD GetName(nsString& aName)
|
|
|
|
{
|
2000-04-03 09:20:26 +00:00
|
|
|
aName.AssignWithConversion(mPluginTag.mName);
|
1999-04-20 19:29:28 +00:00
|
|
|
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 NamedItem(const nsString& aName, nsIDOMMimeType** aReturn)
|
|
|
|
{
|
|
|
|
for (int index = mPluginTag.mVariants - 1; index >= 0; --index) {
|
2000-04-03 09:20:26 +00:00
|
|
|
if (aName.EqualsWithConversion(mPluginTag.mMimeTypeArray[index]))
|
1999-04-20 19:29:28 +00:00
|
|
|
return Item(index, aReturn);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
nsPluginTag mPluginTag;
|
|
|
|
};
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
NS_IMPL_ISUPPORTS(DOMPluginImpl, nsIDOMPlugin::GetIID());
|
1999-04-20 19:29:28 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginHostImpl::GetPluginCount(PRUint32* aPluginCount)
|
|
|
|
{
|
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
|
|
LoadPlugins();
|
|
|
|
|
|
|
|
PRUint32 count = 0;
|
|
|
|
|
|
|
|
nsPluginTag* plugin = mPlugins;
|
|
|
|
while (plugin != nsnull) {
|
|
|
|
++count;
|
|
|
|
plugin = plugin->mNext;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aPluginCount = count;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-04-22 20:50:22 +00:00
|
|
|
nsPluginHostImpl::GetPlugins(PRUint32 aPluginCount,
|
|
|
|
nsIDOMPlugin* aPluginArray[])
|
1999-04-20 19:29:28 +00:00
|
|
|
{
|
2000-04-22 20:50:22 +00:00
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
|
|
LoadPlugins();
|
|
|
|
|
|
|
|
nsPluginTag* plugin = mPlugins;
|
|
|
|
for (PRUint32 i = 0; i < aPluginCount && plugin != nsnull;
|
|
|
|
i++, plugin = plugin->mNext) {
|
|
|
|
nsIDOMPlugin* domPlugin = new DOMPluginImpl(plugin);
|
|
|
|
NS_IF_ADDREF(domPlugin);
|
|
|
|
aPluginArray[i] = domPlugin;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
1999-04-20 19:29:28 +00:00
|
|
|
}
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
nsresult
|
2000-04-22 20:50:22 +00:00
|
|
|
nsPluginHostImpl::FindPluginEnabledForType(const char* aMimeType,
|
|
|
|
nsPluginTag* &aPlugin)
|
1999-03-23 03:18:12 +00:00
|
|
|
{
|
|
|
|
nsPluginTag *plugins = nsnull;
|
|
|
|
PRInt32 variants, cnt;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
aPlugin = nsnull;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-03-23 03:18:12 +00:00
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
|
|
LoadPlugins();
|
2000-04-22 20:50:22 +00:00
|
|
|
|
|
|
|
// if we have a mimetype passed in, search the mPlugins
|
|
|
|
// linked list for a match
|
|
|
|
if (nsnull != aMimeType) {
|
1999-03-23 03:18:12 +00:00
|
|
|
plugins = mPlugins;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
|
|
|
while (nsnull != plugins) {
|
1999-03-23 03:18:12 +00:00
|
|
|
variants = plugins->mVariants;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
|
|
|
for (cnt = 0; cnt < variants; cnt++) {
|
2000-07-11 21:44:39 +00:00
|
|
|
if (plugins->mMimeTypeArray[cnt] && (0 == strcmp(plugins->mMimeTypeArray[cnt], aMimeType))) {
|
1999-07-06 04:14:54 +00:00
|
|
|
aPlugin = plugins;
|
2000-04-22 20:50:22 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
1999-03-23 03:18:12 +00:00
|
|
|
|
|
|
|
if (cnt < variants)
|
|
|
|
break;
|
2000-04-22 20:50:22 +00:00
|
|
|
|
1999-03-23 03:18:12 +00:00
|
|
|
plugins = plugins->mNext;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
1999-02-25 04:15:39 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugin** aPlugin)
|
1999-02-20 02:24:15 +00:00
|
|
|
{
|
1999-03-29 22:18:05 +00:00
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
1999-02-20 02:24:15 +00:00
|
|
|
*aPlugin = NULL;
|
1999-02-25 04:15:39 +00:00
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
if(!aMimeType)
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
|
|
|
|
// If plugins haven't been scanned yet, do so now
|
|
|
|
if (mPlugins == nsnull)
|
1999-02-25 04:15:39 +00:00
|
|
|
LoadPlugins();
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
nsPluginTag* pluginTag;
|
|
|
|
if((rv = FindPluginEnabledForType(aMimeType, pluginTag)) == NS_OK)
|
|
|
|
{
|
1999-07-06 04:14:54 +00:00
|
|
|
|
|
|
|
#ifdef XP_WIN // actually load a dll on Windows
|
1999-07-07 13:37:36 +00:00
|
|
|
|
2000-03-03 00:53:45 +00:00
|
|
|
#ifdef NS_DEBUG
|
|
|
|
printf("For %s found plugin %s\n", aMimeType, pluginTag->mFileName);
|
|
|
|
#endif
|
|
|
|
|
1999-07-07 00:37:41 +00:00
|
|
|
nsFileSpec file(pluginTag->mFileName);
|
|
|
|
|
1999-07-06 04:14:54 +00:00
|
|
|
nsPluginFile pluginFile(file);
|
|
|
|
PRLibrary* pluginLibrary = NULL;
|
|
|
|
|
|
|
|
if (pluginFile.LoadPlugin(pluginLibrary) != NS_OK || pluginLibrary == NULL)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
pluginTag->mLibrary = pluginLibrary;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
nsIPlugin* plugin = pluginTag->mEntryPoint;
|
|
|
|
if(plugin == NULL)
|
|
|
|
{
|
|
|
|
// need to get the plugin factory from this plugin.
|
|
|
|
nsFactoryProc nsGetFactory = nsnull;
|
|
|
|
nsGetFactory = (nsFactoryProc) PR_FindSymbol(pluginTag->mLibrary, "NSGetFactory");
|
1999-05-07 22:06:47 +00:00
|
|
|
if(nsGetFactory != nsnull)
|
1999-03-29 22:18:05 +00:00
|
|
|
{
|
1999-05-07 22:06:47 +00:00
|
|
|
rv = nsGetFactory(mServiceMgr, kPluginCID, nsnull, nsnull, // XXX fix ClassName/ProgID
|
|
|
|
(nsIFactory**)&pluginTag->mEntryPoint);
|
|
|
|
plugin = pluginTag->mEntryPoint;
|
|
|
|
if (plugin != NULL)
|
|
|
|
plugin->Initialize();
|
1999-03-29 22:18:05 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-07-19 21:43:46 +00:00
|
|
|
rv = ns4xPlugin::CreatePlugin(mServiceMgr,
|
|
|
|
pluginTag->mFileName,
|
|
|
|
pluginTag->mLibrary,
|
|
|
|
&pluginTag->mEntryPoint);
|
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
plugin = pluginTag->mEntryPoint;
|
1999-05-17 21:26:48 +00:00
|
|
|
pluginTag->mFlags |= NS_PLUGIN_FLAG_OLDSCHOOL;
|
1999-05-07 22:06:47 +00:00
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
// no need to initialize, already done by CreatePlugin()
|
1999-02-25 04:15:39 +00:00
|
|
|
}
|
|
|
|
}
|
1999-02-20 02:24:15 +00:00
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
if(plugin != nsnull)
|
|
|
|
{
|
|
|
|
*aPlugin = plugin;
|
|
|
|
plugin->AddRef();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
1999-02-20 02:24:15 +00:00
|
|
|
|
1999-03-29 22:18:05 +00:00
|
|
|
return rv;
|
|
|
|
}
|
1999-02-20 02:24:15 +00:00
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
#ifndef XP_WIN // for now keep the old plugin finding logic for non-Windows platforms
|
|
|
|
|
1999-02-20 02:24:15 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::LoadPlugins()
|
|
|
|
{
|
2000-07-07 00:10:54 +00:00
|
|
|
do {
|
1999-02-20 02:24:15 +00:00
|
|
|
// 1. scan the plugins directory (where is it?) for eligible plugin libraries.
|
|
|
|
nsPluginsDir pluginsDir;
|
|
|
|
if (! pluginsDir.Valid())
|
|
|
|
break;
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
// retrieve a path for layout module. Needed for plugin mime types registration
|
|
|
|
nsCOMPtr<nsIComponentManager> compManager = do_GetService(kComponentManagerCID);
|
|
|
|
nsCOMPtr<nsIFile> path;
|
2000-07-09 22:26:44 +00:00
|
|
|
nsresult rvIsLayoutPath = compManager->SpecForRegistryLocation(REL_LAYOUT_DLL, getter_AddRefs(path));
|
2000-07-07 00:10:54 +00:00
|
|
|
|
|
|
|
for (nsDirectoryIterator iter(pluginsDir, PR_TRUE); iter.Exists(); iter++) {
|
1999-02-25 20:58:10 +00:00
|
|
|
const nsFileSpec& file = iter;
|
1999-02-24 02:13:42 +00:00
|
|
|
if (pluginsDir.IsPluginFile(file)) {
|
|
|
|
nsPluginFile pluginFile(file);
|
|
|
|
PRLibrary* pluginLibrary = NULL;
|
1999-07-06 04:14:54 +00:00
|
|
|
|
|
|
|
#ifndef XP_WIN
|
|
|
|
// load the plugin's library so we can ask it some questions but not for Windows for now
|
|
|
|
if (pluginFile.LoadPlugin(pluginLibrary) == NS_OK && pluginLibrary != NULL) {
|
|
|
|
#endif
|
1999-02-24 02:13:42 +00:00
|
|
|
// create a tag describing this plugin.
|
2000-04-22 00:04:24 +00:00
|
|
|
nsPluginInfo info = { sizeof(info) };
|
|
|
|
if (pluginFile.GetPluginInfo(info) != NS_OK)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsPluginTag* pluginTag = new nsPluginTag(&info);
|
|
|
|
|
|
|
|
pluginFile.FreePluginInfo(info);
|
|
|
|
|
|
|
|
if(pluginTag == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
pluginTag->mNext = mPlugins;
|
|
|
|
mPlugins = pluginTag;
|
2000-07-07 00:10:54 +00:00
|
|
|
|
|
|
|
if(NS_SUCCEEDED(rvIsLayoutPath))
|
|
|
|
RegisterPluginMimeTypesWithLayout(pluginTag, compManager, path);
|
|
|
|
|
2000-04-22 00:04:24 +00:00
|
|
|
pluginTag->mLibrary = pluginLibrary;
|
|
|
|
|
1999-07-06 04:14:54 +00:00
|
|
|
#ifndef XP_WIN
|
1999-02-24 02:13:42 +00:00
|
|
|
}
|
1999-07-06 04:14:54 +00:00
|
|
|
#endif
|
1999-02-20 02:24:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mPluginsLoaded = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
#else // go for new plugin finding logic on Windows
|
|
|
|
|
|
|
|
static PRBool areTheSameFileNames(char * name1, char * name2)
|
|
|
|
{
|
|
|
|
if((name1 == nsnull) || (name2 == nsnull))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
char * filename1 = PL_strrchr(name1, '\\');
|
|
|
|
if(filename1 != nsnull)
|
|
|
|
filename1++;
|
|
|
|
else
|
|
|
|
filename1 = name1;
|
|
|
|
|
|
|
|
char * filename2 = PL_strrchr(name2, '\\');
|
|
|
|
if(filename2 != nsnull)
|
|
|
|
filename2++;
|
|
|
|
else
|
|
|
|
filename2 = name2;
|
|
|
|
|
|
|
|
if(PL_strlen(filename1) != PL_strlen(filename2))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
2000-03-15 01:27:30 +00:00
|
|
|
// this one MUST be case insensitive for Windows and MUST be case sensitive
|
|
|
|
// for Unix. How about Win2000?
|
2000-03-03 00:53:45 +00:00
|
|
|
return (nsnull == PL_strncasecmp(filename1, filename2, PL_strlen(filename1)));
|
2000-02-01 00:42:52 +00:00
|
|
|
}
|
|
|
|
|
2000-03-15 01:27:30 +00:00
|
|
|
static PRBool isJavaPlugin(nsPluginTag * tag)
|
|
|
|
{
|
|
|
|
if(tag->mFileName == nsnull)
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
char * filename = PL_strrchr(tag->mFileName, '\\');
|
|
|
|
|
|
|
|
if(filename != nsnull)
|
|
|
|
filename++;
|
|
|
|
else
|
|
|
|
filename = tag->mFileName;
|
|
|
|
|
|
|
|
return (nsnull == PL_strncasecmp(filename, "npjava", 6));
|
|
|
|
}
|
|
|
|
|
2000-06-21 01:44:55 +00:00
|
|
|
// currently 'unwanted' plugins are Java, and all other plugins except
|
|
|
|
// RealPlayer, Acrobat, Flash
|
|
|
|
static PRBool isUnwantedPlugin(nsPluginTag * tag)
|
|
|
|
{
|
|
|
|
if(tag->mFileName == nsnull)
|
|
|
|
return PR_TRUE;
|
|
|
|
|
|
|
|
if(nsnull == PL_strncasecmp(tag->mMimeType, "audio/x-pn-realaudio-plugin", PL_strlen(tag->mMimeType)))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
if(nsnull == PL_strncasecmp(tag->mMimeType, "application/pdf", PL_strlen(tag->mMimeType)))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
if(nsnull == PL_strncasecmp(tag->mMimeType, "application/x-shockwave-flash", PL_strlen(tag->mMimeType)))
|
|
|
|
return PR_FALSE;
|
|
|
|
|
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::LoadPlugins()
|
|
|
|
{
|
|
|
|
// currently we decided to look in both local plugins dir and
|
|
|
|
// that of the previous 4.x installation combining plugins from both places.
|
|
|
|
// See bug #21938
|
|
|
|
// As of 1.27.00 this selective mechanism is natively supported in Windows
|
|
|
|
// native implementation of nsPluginsDir.
|
|
|
|
|
|
|
|
nsPluginsDir pluginsDir4x(PLUGINS_DIR_LOCATION_4DOTX);
|
|
|
|
nsPluginsDir pluginsDirMoz(PLUGINS_DIR_LOCATION_MOZ_LOCAL);
|
|
|
|
|
2000-02-12 01:43:02 +00:00
|
|
|
if(!pluginsDir4x.Valid() && !pluginsDirMoz.Valid())
|
2000-02-01 00:42:52 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
// retrieve a path for layout module. Needed for plugin mime types registration
|
|
|
|
nsCOMPtr<nsIComponentManager> compManager = do_GetService(kComponentManagerCID);
|
|
|
|
nsCOMPtr<nsIFile> path;
|
2000-07-09 22:26:44 +00:00
|
|
|
nsresult rvIsLayoutPath = compManager->SpecForRegistryLocation(REL_LAYOUT_DLL, getter_AddRefs(path));
|
2000-07-07 00:10:54 +00:00
|
|
|
|
|
|
|
// first, make a list from MOZ_LOCAL installation
|
2000-02-01 00:42:52 +00:00
|
|
|
for (nsDirectoryIterator iter(pluginsDirMoz, PR_TRUE); iter.Exists(); iter++)
|
|
|
|
{
|
|
|
|
const nsFileSpec& file = iter;
|
|
|
|
if (pluginsDirMoz.IsPluginFile(file)) {
|
|
|
|
nsPluginFile pluginFile(file);
|
|
|
|
PRLibrary* pluginLibrary = NULL;
|
|
|
|
|
|
|
|
#ifndef XP_WIN
|
|
|
|
// load the plugin's library so we can ask it some questions but not for Windows for now
|
|
|
|
if (pluginFile.LoadPlugin(pluginLibrary) == NS_OK && pluginLibrary != NULL)
|
|
|
|
{
|
|
|
|
#endif
|
|
|
|
// create a tag describing this plugin.
|
2000-03-23 00:45:49 +00:00
|
|
|
nsPluginInfo info = { sizeof(info) };
|
|
|
|
if (pluginFile.GetPluginInfo(info) != NS_OK)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsPluginTag* pluginTag = new nsPluginTag(&info);
|
2000-04-22 00:04:24 +00:00
|
|
|
|
|
|
|
pluginFile.FreePluginInfo(info);
|
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
if(pluginTag == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
pluginTag->mNext = mPlugins;
|
|
|
|
mPlugins = pluginTag;
|
|
|
|
|
2000-07-07 00:10:54 +00:00
|
|
|
if(NS_SUCCEEDED(rvIsLayoutPath))
|
|
|
|
RegisterPluginMimeTypesWithLayout(pluginTag, compManager, path);
|
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
pluginTag->mLibrary = pluginLibrary;
|
|
|
|
|
|
|
|
#ifndef XP_WIN
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now check the 4.x plugins dir and add new files
|
|
|
|
for (nsDirectoryIterator iter2(pluginsDir4x, PR_TRUE); iter2.Exists(); iter2++)
|
|
|
|
{
|
|
|
|
const nsFileSpec& file = iter2;
|
|
|
|
if (pluginsDir4x.IsPluginFile(file))
|
|
|
|
{
|
|
|
|
nsPluginFile pluginFile(file);
|
|
|
|
PRLibrary* pluginLibrary = NULL;
|
|
|
|
|
|
|
|
#ifndef XP_WIN
|
|
|
|
// load the plugin's library so we can ask it some questions but not for Windows for now
|
|
|
|
if (pluginFile.LoadPlugin(pluginLibrary) == NS_OK && pluginLibrary != NULL)
|
|
|
|
{
|
|
|
|
#endif
|
|
|
|
// create a tag describing this plugin.
|
2000-03-23 00:45:49 +00:00
|
|
|
nsPluginInfo info = { sizeof(info) };
|
|
|
|
if (pluginFile.GetPluginInfo(info) != NS_OK)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsPluginTag* pluginTag = new nsPluginTag(&info);
|
2000-04-22 00:04:24 +00:00
|
|
|
|
|
|
|
pluginFile.FreePluginInfo(info);
|
|
|
|
|
2000-02-01 00:42:52 +00:00
|
|
|
if(pluginTag == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
pluginTag->mLibrary = pluginLibrary;
|
|
|
|
|
|
|
|
// search for a match in the list of MOZ_LOCAL plugins, ignore if found, add if not
|
2000-03-15 01:27:30 +00:00
|
|
|
PRBool bAddIt = PR_TRUE;
|
|
|
|
|
|
|
|
// make sure we ignore 4.x Java plugins no matter what
|
2000-06-21 01:44:55 +00:00
|
|
|
// and other unwanted plugins as per temporary decision described in #23856
|
|
|
|
if(isUnwantedPlugin(pluginTag))
|
2000-03-15 01:27:30 +00:00
|
|
|
bAddIt = PR_FALSE;
|
|
|
|
else
|
2000-02-01 00:42:52 +00:00
|
|
|
{
|
2000-03-15 01:27:30 +00:00
|
|
|
for(nsPluginTag* tag = mPlugins; tag != nsnull; tag = tag->mNext)
|
2000-02-01 00:42:52 +00:00
|
|
|
{
|
2000-03-15 01:27:30 +00:00
|
|
|
if(areTheSameFileNames(tag->mFileName, pluginTag->mFileName))
|
|
|
|
{
|
|
|
|
bAddIt = PR_FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2000-02-01 00:42:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-15 01:27:30 +00:00
|
|
|
if(bAddIt)
|
2000-02-01 00:42:52 +00:00
|
|
|
{
|
|
|
|
pluginTag->mNext = mPlugins;
|
|
|
|
mPlugins = pluginTag;
|
2000-07-07 00:10:54 +00:00
|
|
|
|
|
|
|
if(NS_SUCCEEDED(rvIsLayoutPath))
|
|
|
|
RegisterPluginMimeTypesWithLayout(pluginTag, compManager, path);
|
2000-02-01 00:42:52 +00:00
|
|
|
}
|
2000-03-15 01:27:30 +00:00
|
|
|
else
|
|
|
|
delete pluginTag;
|
2000-02-01 00:42:52 +00:00
|
|
|
|
|
|
|
#ifndef XP_WIN
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mPluginsLoaded = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
#endif // XP_WIN -- end new plugin finding logic
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by GetURL and PostURL */
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
NS_IMETHODIMP nsPluginHostImpl::NewPluginURLStream(const nsString& aURL,
|
1999-01-25 08:05:00 +00:00
|
|
|
nsIPluginInstance *aInstance,
|
|
|
|
nsIPluginStreamListener* aListener)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
2000-06-16 22:27:16 +00:00
|
|
|
nsCOMPtr<nsIURI> url;
|
|
|
|
nsAutoString absUrl;
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult rv;
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
if (aURL.Length() <= 0)
|
|
|
|
return NS_OK;
|
1998-09-15 03:48:58 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
// get the full URL of the document that the plugin is embedded
|
|
|
|
// in to create an absolute url in case aURL is relative
|
2000-07-13 02:44:14 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc;
|
2000-06-16 22:27:16 +00:00
|
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
rv = aInstance->GetPeer(NS_REINTERPRET_CAST(nsIPluginInstancePeer **, &peer));
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIPluginInstanceOwner> owner;
|
|
|
|
rv = peer->GetOwner(*getter_AddRefs(owner));
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
rv = owner->GetDocument(getter_AddRefs(doc));
|
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIURI> docURL( getter_AddRefs(doc->GetDocumentURL()) );
|
|
|
|
|
|
|
|
// Create an absolute URL
|
|
|
|
rv = NS_MakeAbsoluteURI(absUrl, aURL, docURL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
NS_RELEASE(peer);
|
|
|
|
}
|
1998-09-15 03:48:58 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (absUrl.IsEmpty())
|
|
|
|
absUrl.Assign(aURL);
|
|
|
|
|
|
|
|
rv = NS_NewURI(getter_AddRefs(url), absUrl);
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv))
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
2000-06-16 22:27:16 +00:00
|
|
|
nsPluginStreamListenerPeer *listenerPeer = new nsPluginStreamListenerPeer;
|
|
|
|
if (listenerPeer == NULL)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
NS_ADDREF(listenerPeer);
|
1999-01-25 08:05:00 +00:00
|
|
|
rv = listenerPeer->Initialize(url, aInstance, aListener);
|
1998-09-15 03:48:58 +00:00
|
|
|
|
2000-06-16 22:27:16 +00:00
|
|
|
if (NS_SUCCEEDED(rv)) {
|
2000-07-13 02:44:14 +00:00
|
|
|
nsCOMPtr<nsIInterfaceRequestor> callbacks;
|
|
|
|
|
|
|
|
if (doc) {
|
|
|
|
// Get the script global object owner and use that as the notification callback
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> global;
|
|
|
|
doc->GetScriptGlobalObject(getter_AddRefs(global));
|
|
|
|
|
|
|
|
if (global) {
|
|
|
|
nsCOMPtr<nsIScriptGlobalObjectOwner> owner;
|
|
|
|
global->GetGlobalObjectOwner(getter_AddRefs(owner));
|
|
|
|
|
|
|
|
callbacks = do_QueryInterface(owner);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
|
|
|
1999-08-26 22:45:55 +00:00
|
|
|
// XXX: Null LoadGroup?
|
2000-07-13 02:44:14 +00:00
|
|
|
rv = NS_OpenURI(getter_AddRefs(channel), url, nsnull,
|
|
|
|
nsnull, callbacks);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
if (doc) {
|
|
|
|
// Set the owner of channel to the document principal...
|
|
|
|
nsCOMPtr<nsIPrincipal> principal;
|
|
|
|
doc->GetPrincipal(getter_AddRefs(principal));
|
|
|
|
|
|
|
|
channel->SetOwner(principal);
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = channel->AsyncRead(listenerPeer, nsnull);
|
1998-09-15 03:48:58 +00:00
|
|
|
}
|
2000-06-16 22:27:16 +00:00
|
|
|
NS_RELEASE(listenerPeer);
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-06-04 22:32:27 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsPluginHostImpl::StopPluginInstance(nsIPluginInstance* aInstance)
|
|
|
|
{
|
2000-06-13 23:23:13 +00:00
|
|
|
nsActivePlugin * plugin = mActivePluginList.find(aInstance);
|
|
|
|
|
|
|
|
if(plugin != nsnull)
|
2000-06-15 01:07:27 +00:00
|
|
|
{
|
|
|
|
if(mActivePluginList.getStoppedCount() >= MAX_NUMBER_OF_STOPPED_PLUGINS)
|
|
|
|
{
|
|
|
|
nsActivePlugin * oldest = mActivePluginList.findOldestStopped();
|
|
|
|
if(oldest != nsnull)
|
|
|
|
mActivePluginList.remove(oldest);
|
|
|
|
}
|
|
|
|
plugin->setStopped(PR_TRUE);
|
|
|
|
}
|
1999-06-04 22:32:27 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by InstantiateEmbededPlugin() */
|
|
|
|
|
1999-06-23 03:29:44 +00:00
|
|
|
nsresult nsPluginHostImpl::NewEmbededPluginStream(nsIURI* aURL,
|
1998-09-15 03:48:58 +00:00
|
|
|
nsIPluginInstanceOwner *aOwner,
|
1999-01-25 08:05:00 +00:00
|
|
|
nsIPluginInstance* aInstance)
|
1998-08-05 04:21:36 +00:00
|
|
|
{
|
1999-03-11 22:48:58 +00:00
|
|
|
nsPluginStreamListenerPeer *listener = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
1999-07-30 23:51:53 +00:00
|
|
|
if (listener == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
nsresult rv;
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if (!aURL)
|
|
|
|
return NS_OK;
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
// if we have an instance, everything has been set up
|
|
|
|
// if we only have an owner, then we need to pass it in
|
|
|
|
// so the listener can set up the instance later after
|
|
|
|
// we've determined the mimetype of the stream
|
|
|
|
if(aInstance != nsnull)
|
1999-03-11 22:48:58 +00:00
|
|
|
rv = listener->InitializeEmbeded(aURL, aInstance);
|
1999-01-25 08:05:00 +00:00
|
|
|
else if(aOwner != nsnull)
|
1999-03-11 22:48:58 +00:00
|
|
|
rv = listener->InitializeEmbeded(aURL, nsnull, aOwner, (nsIPluginHost *)this);
|
1999-01-25 08:05:00 +00:00
|
|
|
else
|
|
|
|
rv = NS_ERROR_ILLEGAL_VALUE;
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
if (NS_OK == rv) {
|
1999-08-26 22:45:55 +00:00
|
|
|
// XXX: Null LoadGroup?
|
|
|
|
rv = NS_OpenURI(listener, nsnull, aURL, nsnull);
|
1999-03-11 22:48:58 +00:00
|
|
|
}
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
//NS_RELEASE(aURL);
|
1998-08-05 04:21:36 +00:00
|
|
|
|
1999-03-11 22:48:58 +00:00
|
|
|
return rv;
|
1998-09-15 03:48:58 +00:00
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
/* Called by InstantiateFullPagePlugin() */
|
|
|
|
|
2000-04-22 20:50:22 +00:00
|
|
|
nsresult nsPluginHostImpl::NewFullPagePluginStream(nsIStreamListener *&aStreamListener,
|
|
|
|
nsIPluginInstance *aInstance)
|
1998-09-15 03:48:58 +00:00
|
|
|
{
|
1999-01-25 08:05:00 +00:00
|
|
|
nsPluginStreamListenerPeer *listener = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
1999-07-30 23:51:53 +00:00
|
|
|
if (listener == nsnull)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
nsresult rv;
|
1998-09-15 03:48:58 +00:00
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
rv = listener->InitializeFullPage(aInstance);
|
1998-09-15 03:48:58 +00:00
|
|
|
|
|
|
|
aStreamListener = (nsIStreamListener *)listener;
|
|
|
|
NS_IF_ADDREF(listener);
|
|
|
|
|
|
|
|
return rv;
|
1998-08-05 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
1999-01-25 08:05:00 +00:00
|
|
|
// nsIFactory interface
|
|
|
|
|
|
|
|
nsresult nsPluginHostImpl::CreateInstance(nsISupports *aOuter,
|
1998-08-02 03:20:22 +00:00
|
|
|
const nsIID &aIID,
|
|
|
|
void **aResult)
|
|
|
|
{
|
|
|
|
if (aResult == NULL)
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
|
|
|
|
nsISupports *inst = nsnull;
|
|
|
|
|
|
|
|
if (inst == NULL)
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
|
1999-10-24 04:41:17 +00:00
|
|
|
// XXX Doh, we never get here... what is going on???
|
|
|
|
|
|
|
|
NS_ADDREF(inst); // Stabilize
|
|
|
|
|
1998-08-02 03:20:22 +00:00
|
|
|
nsresult res = inst->QueryInterface(aIID, aResult);
|
|
|
|
|
1999-10-24 04:41:17 +00:00
|
|
|
NS_RELEASE(inst); // Destabilize and avoid leaks. Avoid calling delete <interface pointer>
|
1998-08-02 03:20:22 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
1999-04-20 19:29:28 +00:00
|
|
|
nsresult nsPluginHostImpl::LockFactory(PRBool aLock)
|
1998-08-02 03:20:22 +00:00
|
|
|
{
|
|
|
|
// Not implemented in simplest case.
|
|
|
|
return NS_OK;
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// nsIFileUtilities interface
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetProgramPath(const char* *result)
|
|
|
|
{
|
1999-03-20 23:11:25 +00:00
|
|
|
static nsSpecialSystemDirectory programDir(nsSpecialSystemDirectory::OS_CurrentProcessDirectory);
|
|
|
|
*result = programDir;
|
1999-01-25 08:05:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetTempDirPath(const char* *result)
|
|
|
|
{
|
1999-03-20 23:11:25 +00:00
|
|
|
static nsSpecialSystemDirectory tempDir(nsSpecialSystemDirectory::OS_TemporaryDirectory);
|
|
|
|
*result = tempDir;
|
1999-01-25 08:05:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::NewTempFileName(const char* prefix, PRUint32 bufLen, char* resultBuf)
|
|
|
|
{
|
1999-03-20 23:11:25 +00:00
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// nsICookieStorage interface
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetCookie(const char* inCookieURL, void* inOutCookieBuffer, PRUint32& inOutCookieSize)
|
|
|
|
{
|
1999-10-21 21:09:21 +00:00
|
|
|
nsresult rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
nsString cookieString;
|
|
|
|
nsCOMPtr<nsIURI> uriIn;
|
|
|
|
char *bufPtr;
|
|
|
|
|
|
|
|
if ((nsnull == inCookieURL) || (0 >= inOutCookieSize)) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsIIOService, ioService, kIOServiceCID, &rv);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv) || (nsnull == ioService)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsICookieService, cookieService, kCookieServiceCID, &rv);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv) || (nsnull == cookieService)) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
// make an nsURI from the argument url
|
|
|
|
rv = ioService->NewURI(inCookieURL, nsnull, getter_AddRefs(uriIn));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = cookieService->GetCookieString(uriIn, cookieString);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv) ||
|
|
|
|
(((PRInt32) inOutCookieSize) < cookieString.Length())) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
bufPtr = cookieString.ToCString((char *) inOutCookieBuffer,
|
|
|
|
inOutCookieSize);
|
|
|
|
if (nsnull == bufPtr) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
inOutCookieSize = cookieString.Length();
|
|
|
|
rv = NS_OK;
|
|
|
|
|
|
|
|
return rv;
|
1999-03-20 23:11:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::SetCookie(const char* inCookieURL, const void* inCookieBuffer, PRUint32 inCookieSize)
|
|
|
|
{
|
1999-10-21 21:09:21 +00:00
|
|
|
nsresult rv = NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
nsString cookieString;
|
|
|
|
nsCOMPtr<nsIURI> uriIn;
|
|
|
|
|
|
|
|
if ((nsnull == inCookieURL) || (nsnull == inCookieBuffer) ||
|
|
|
|
(0 >= inCookieSize)) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsIIOService, ioService, kIOServiceCID, &rv);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv) || (nsnull == ioService)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_WITH_SERVICE(nsICookieService, cookieService, kCookieServiceCID, &rv);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv) || (nsnull == cookieService)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// make an nsURI from the argument url
|
|
|
|
rv = ioService->NewURI(inCookieURL, nsnull, getter_AddRefs(uriIn));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2000-04-03 09:20:26 +00:00
|
|
|
cookieString.AssignWithConversion((const char *) inCookieBuffer,(PRInt32) inCookieSize);
|
1999-10-21 21:09:21 +00:00
|
|
|
|
|
|
|
rv = cookieService->SetCookieString(uriIn, cookieString);
|
|
|
|
|
|
|
|
return rv;
|
1999-01-25 08:05:00 +00:00
|
|
|
}
|