613 lines
19 KiB
C++
613 lines
19 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Sun Microsystems,
|
|
* Inc. Portions created by Sun are
|
|
* Copyright (C) 1999 Sun Microsystems, Inc. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
#include "nsIGenericFactory.h"
|
|
#include "nsXPCOMCID.h"
|
|
#include "nsAppDirectoryServiceDefs.h"
|
|
#include "nsIFile.h"
|
|
#include "nsFileSpec.h"
|
|
#include "nsICategoryManager.h"
|
|
#include "nsObserverService.h"
|
|
#include "nsMemory.h"
|
|
|
|
#include "PlugletEngine.h"
|
|
#include "Pluglet.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "prenv.h"
|
|
#include "plstr.h"
|
|
#include "prlink.h"
|
|
#include "PlugletManager.h"
|
|
#include "PlugletLog.h"
|
|
|
|
#include "XPCOMShutdownObserver.h"
|
|
|
|
#ifdef XP_PC
|
|
#define SEP "\\"
|
|
#define PATH_SEP ";"
|
|
#endif
|
|
|
|
|
|
#ifndef OJI_DISABLE
|
|
#include "ProxyJNI.h"
|
|
static NS_DEFINE_CID(kJVMManagerCID,NS_JVMMANAGER_CID);
|
|
PlugletSecurityContext *PlugletEngine::securityContext = NULL;
|
|
nsJVMManager * PlugletEngine::jvmManager = NULL;
|
|
#endif /* OJI_DISABLE */
|
|
|
|
static NS_DEFINE_CID(kIPluginIID,NS_IPLUGIN_IID);
|
|
static NS_DEFINE_CID(kPluginCID,NS_PLUGIN_CID);
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
|
|
static NS_DEFINE_CID(kPluginManagerCID, NS_PLUGINMANAGER_CID);
|
|
|
|
PRLogModuleInfo* PlugletLog::log = NULL;
|
|
|
|
typedef jint (*PJNI_CreateJavaVM)(JavaVM **pvm, void **penv, void *args);
|
|
typedef jint (*PJNI_GetCreatedJavaVMs)(JavaVM **, jsize, jsize *);
|
|
|
|
static PJNI_GetCreatedJavaVMs pJNI_GetCreatedJavaVMs = nsnull;
|
|
static PJNI_CreateJavaVM pJNI_CreateJavaVM = nsnull;
|
|
|
|
void PlugletEngine::LoadJNIFuntions()
|
|
{
|
|
char *path = nsnull;
|
|
char *java_home = nsnull;
|
|
char *buf = nsnull;
|
|
char *jvmDllPath = nsnull;
|
|
char *relativePathToJvmDll;
|
|
PRUint32 capVariant = 0;
|
|
PRUint32 len = 0;
|
|
// Get the path environment variable, accounting for capitilzation variants
|
|
if (nsnull == (capVariant = 0, path = PR_GetEnv("PATH"))) {
|
|
if (nsnull == (capVariant = 1, path = PR_GetEnv("path"))) {
|
|
if (nsnull == (capVariant = 2, path = PR_GetEnv("Path"))) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the path does not already have java in it
|
|
if ((nsnull == PL_strstr(path, "Java")) &&
|
|
(nsnull == PL_strstr(path, "java")) &&
|
|
(nsnull == PL_strstr(path, "JAVA"))) {
|
|
// Get the JAVA_HOME environment variable
|
|
if (nsnull == (java_home = PR_GetEnv("JAVA_HOME"))) {
|
|
return;
|
|
}
|
|
|
|
// get the path to jvm.dll, relative to JAVA_HOME
|
|
relativePathToJvmDll = "jre\\bin\\client";
|
|
|
|
// Build the absolute path to the jvm.dll
|
|
len = PL_strlen(java_home) + PL_strlen(relativePathToJvmDll) +
|
|
2; // 1 for \\ 1 for \0
|
|
buf = new char[len];
|
|
memset(buf, 0, len);
|
|
PL_strcat(buf, java_home);
|
|
PL_strcat(buf, SEP);
|
|
PL_strcat(buf, relativePathToJvmDll);
|
|
|
|
jvmDllPath = PR_GetLibraryName(buf, "jvm.dll");
|
|
delete [] buf;
|
|
}
|
|
else {
|
|
jvmDllPath = "jvm.dll";
|
|
}
|
|
|
|
PRLibrary *jvmDll = PR_LoadLibrary((const char *) jvmDllPath);
|
|
if (0 != PL_strstr("jvm.dll", jvmDllPath)) {
|
|
PR_FreeLibraryName(jvmDllPath);
|
|
}
|
|
if (nsnull != jvmDllPath) {
|
|
pJNI_GetCreatedJavaVMs = (PJNI_GetCreatedJavaVMs)
|
|
PR_FindFunctionSymbol(jvmDll, "JNI_GetCreatedJavaVMs");
|
|
pJNI_CreateJavaVM = (PJNI_CreateJavaVM)
|
|
PR_FindFunctionSymbol(jvmDll, "JNI_CreateJavaVM");
|
|
}
|
|
}
|
|
|
|
void PlugletEngine::PopulateClasspath()
|
|
{
|
|
const char *classpath = nsnull;
|
|
char *buf = nsnull;
|
|
PRUint32 len = 0;
|
|
|
|
if (nsnull == (classpath = PR_GetEnv("CLASSPATH"))) {
|
|
if (nsnull == (classpath = PR_GetEnv("Classpath"))) {
|
|
if (nsnull == (classpath = PR_GetEnv("classpath"))) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the profile directory
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIProperties> dirService
|
|
(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
|
|
nsCOMPtr<nsIFile> profileDir;
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = dirService->Get(NS_APP_USER_PROFILE_50_DIR,
|
|
NS_GET_IID(nsIFile),
|
|
getter_AddRefs(profileDir));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = profileDir->AppendNative(NS_LITERAL_CSTRING("extensions"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = profileDir->AppendNative(NS_LITERAL_CSTRING("pluglet@ridingthecrest.com"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = profileDir->AppendNative(NS_LITERAL_CSTRING("pluglet.jar"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsXPIDLCString plugletJar;
|
|
rv = profileDir->GetNativePath(plugletJar);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (nsnull == classpath) {
|
|
// 10 for CLASSPATH= and 1 for \0
|
|
len = PL_strlen(plugletJar.get()) + 11;
|
|
buf = new char[len];
|
|
memset(buf, 0, len);
|
|
PL_strcat(buf, "CLASSPATH=");
|
|
}
|
|
else {
|
|
// 10 for CLASSPATH= and 1 for \0
|
|
len = PL_strlen(classpath) +
|
|
PL_strlen(plugletJar.get()) + 11;
|
|
buf = new char[len];
|
|
memset(buf, 0, len);
|
|
PL_strcat(buf, "CLASSPATH=");
|
|
PL_strcat(buf, classpath);
|
|
PL_strcat(buf, PATH_SEP);
|
|
}
|
|
PL_strcat(buf, plugletJar.get());
|
|
PR_SetEnv(buf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlugletEngine::SatisfyJavaPreconditions()
|
|
{
|
|
LoadJNIFuntions();
|
|
PopulateClasspath();
|
|
}
|
|
|
|
|
|
int PlugletEngine::objectCount = 0;
|
|
PlugletsDir * PlugletEngine::dir = NULL;
|
|
PRInt32 PlugletEngine::lockCount = 0;
|
|
nsCOMPtr<nsIPluginManager> PlugletEngine::pluginManager;
|
|
nsCOMPtr<nsIObserver> PlugletEngine::shutdownObserver;
|
|
jobject PlugletEngine::plugletManager = NULL;
|
|
|
|
|
|
#define PLUGIN_MIME_DESCRIPTION "*:*:Pluglet Engine"
|
|
|
|
PlugletEngine::PlugletEngine() {
|
|
NS_INIT_ISUPPORTS();
|
|
|
|
PlugletLog::log = PR_NewLogModule("pluglets");
|
|
dir = new PlugletsDir();
|
|
objectCount++;
|
|
}
|
|
|
|
PlugletEngine::~PlugletEngine(void) {
|
|
delete dir;
|
|
objectCount--;
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS3(PlugletEngine, nsIObserver, iPlugletEngine, nsIPlugin);
|
|
NS_IMETHODIMP
|
|
PlugletEngine::Observe(nsISupports *aSubject, const char *aTopic,
|
|
const PRUnichar *aData)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PlugletEngine::Initialize(void)
|
|
{
|
|
//nb ???
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PlugletEngine::Shutdown(void)
|
|
{
|
|
//nb ???
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PlugletEngine::CreateInstance(nsISupports *aOuter, REFNSIID aIID,
|
|
void **aResult)
|
|
{
|
|
return NS_ERROR_FAILURE; //nb to do
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PlugletEngine::LockFactory(PRBool aLock)
|
|
{
|
|
if(aLock) {
|
|
PR_AtomicIncrement(&lockCount);
|
|
} else {
|
|
PR_AtomicDecrement(&lockCount);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
PlugletEngine::CreatePluginInstance(nsISupports *aOuter, REFNSIID aIID,
|
|
const char* aPluginMIMEType,
|
|
void **aResult)
|
|
{
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::CreatePluginInstance\n"));
|
|
if (!aResult) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
PlugletFactory * plugletFactory = NULL;
|
|
nsresult res = NS_ERROR_NULL_POINTER;
|
|
if ((res = dir->GetPlugletFactory(aPluginMIMEType,&plugletFactory)) != NS_OK
|
|
|| !plugletFactory) {
|
|
return res;
|
|
}
|
|
//we do not delete pluglet because we do not allocate new memory in dir->GetPluglet()
|
|
return plugletFactory->CreatePluginInstance(aPluginMIMEType,aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::GetMIMEDescription(const char* *result) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::GetMimeDescription\n"));
|
|
if (!result) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
*result = strdup(PLUGIN_MIME_DESCRIPTION);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::GetValue(nsPluginVariable variable, void *value) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::GetValue; stub\n"));
|
|
//nb ????
|
|
return NS_OK;
|
|
}
|
|
|
|
char *ToString(jobject obj,JNIEnv *env) {
|
|
static jmethodID toStringID = NULL;
|
|
if (!toStringID) {
|
|
jclass clazz = env->FindClass("java/lang/Object");
|
|
toStringID = env->GetMethodID(clazz,"toString","()Ljava/lang/String;");
|
|
}
|
|
jstring jstr = (jstring) env->CallObjectMethod(obj,toStringID);
|
|
const char * str = NULL;
|
|
str = env->GetStringUTFChars(jstr,NULL);
|
|
char * res = new char[strlen(str)];
|
|
strcpy(res,str);
|
|
env->ReleaseStringUTFChars(jstr,str);
|
|
return res;
|
|
}
|
|
|
|
|
|
#ifdef OJI_DISABLE
|
|
|
|
#ifdef XP_PC
|
|
#define PATH_SEPARATOR ';'
|
|
#else /* XP_PC */
|
|
#define PATH_SEPARATOR ':'
|
|
#endif /* XP_PC */
|
|
|
|
JavaVM *PlugletEngine::jvm = NULL;
|
|
|
|
void PlugletEngine::StartJVM() {
|
|
if (nsnull == pJNI_CreateJavaVM) {
|
|
SatisfyJavaPreconditions();
|
|
}
|
|
if (nsnull == pJNI_CreateJavaVM) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::StartJVM SEVERE ERROR: Cannot start JVM. Is Java in your path?\n"));
|
|
return;
|
|
}
|
|
|
|
|
|
JNIEnv *env = NULL;
|
|
jint res;
|
|
jsize jvmCount;
|
|
pJNI_GetCreatedJavaVMs(&jvm, 1, &jvmCount);
|
|
if (jvmCount) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::StartJVM we got already started JVM\n"));
|
|
return;
|
|
}
|
|
char classpath[4096]="";
|
|
char debug[256]="";
|
|
char runjdwp[256]="";
|
|
char jniLibPath[4096] ="";
|
|
|
|
sprintf(debug, "-Xdebug");
|
|
sprintf(runjdwp,
|
|
"-Xrunjdwp:transport=dt_shmem,address=jdbconn,server=y,suspend=y");
|
|
JavaVMInitArgs vm_args;
|
|
JavaVMOption options[5];
|
|
char * classpathEnv = PR_GetEnv("CLASSPATH");
|
|
if (classpathEnv != NULL) {
|
|
sprintf(classpath, "-Djava.class.path=%s",classpathEnv);
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::StartJVM about to create JVM classpath=%s\n",classpath));
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIProperties> dirService
|
|
(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
|
|
nsCOMPtr<nsIFile> file;
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = dirService->Get(NS_APP_USER_PROFILE_50_DIR,
|
|
NS_GET_IID(nsIFile),
|
|
getter_AddRefs(file));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("extensions"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("pluglet@ridingthecrest.com"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("platform"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
#ifdef XP_PC
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("WINNT_x86-msvc"));
|
|
#endif
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("plugletjni.dll"));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsXPIDLCString plugletJni;
|
|
rv = file->GetNativePath(plugletJni);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// 20 for -Djava.library.path=, 1 for \0
|
|
PRUint32 len = PL_strlen(plugletJni.get())+
|
|
21;
|
|
PL_strcat(jniLibPath,
|
|
"-Djava.library.path=");
|
|
PL_strcat(jniLibPath, plugletJni.get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
options[0].optionString = classpath;
|
|
options[1].optionString = jniLibPath;
|
|
options[2].optionString = debug;
|
|
options[3].optionString = runjdwp;
|
|
options[4].optionString=""; //-Djava.compiler=NONE";
|
|
vm_args.version = JNI_VERSION_1_4;
|
|
vm_args.options = options;
|
|
vm_args.nOptions = 2; // EDBURNS: Change to 4 for debugging, 2 for non-debuging
|
|
vm_args.ignoreUnrecognized = JNI_FALSE;
|
|
/* Create the Java VM */
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::StartJVM about to start JVM with options %s %s %s\n",
|
|
options[0].optionString, options[1].optionString,
|
|
options[2].optionString));
|
|
res = pJNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
|
|
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::StartJVM after CreateJavaVM res = %d\n",res));
|
|
}
|
|
|
|
#endif /* OJI_DISABLE */
|
|
|
|
NS_IMETHODIMP PlugletEngine::GetJNIEnv(JNIEnv * *jniEnv)
|
|
{
|
|
JNIEnv * res = NULL;
|
|
if (nsnull == jniEnv) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
#ifndef OJI_DISABLE
|
|
nsresult result;
|
|
if (!jvmManager) {
|
|
NS_WITH_SERVICE(nsIJVMManager, _jvmManager, kJVMManagerCID, &result);
|
|
if (NS_SUCCEEDED(result)) {
|
|
jvmManager = (nsJVMManager*)((nsIJVMManager*)_jvmManager);
|
|
}
|
|
}
|
|
if (!jvmManager) {
|
|
return result;
|
|
}
|
|
if (NS_FAILED(result = jvmManager->CreateProxyJNI(NULL,&res))) {
|
|
return result;
|
|
}
|
|
if (!securityContext) {
|
|
securityContext = new PlugletSecurityContext();
|
|
}
|
|
SetSecurityContext(res,securityContext);
|
|
#else /* OJI_DISABLE */
|
|
if (!jvm) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::GetJNIEnv going to start our own jvm \n"));
|
|
StartJVM();
|
|
}
|
|
if (jvm) {
|
|
jvm->AttachCurrentThread((void**)&res,NULL);
|
|
}
|
|
#endif /* OJI_DISABLE */
|
|
*jniEnv = res;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::GetPlugletManager(void * *jobj)
|
|
{
|
|
if (nsnull == jobj) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("PlugletEngine::GetPlugletManager\n"));
|
|
//Changed by John Sublet NS_WITH_SERVICE deprecated currently is
|
|
//problematic: lxr.mozilla.org indicates version of
|
|
//do_GetService that allows the res to be included in the
|
|
//do_GetService call but that wouldn't work: FIXME
|
|
|
|
//NS_WITH_SERVICE(nsIPluginManager,_pluginManager,kPluginManagerCID,&res);
|
|
nsCOMPtr<nsIPluginManager> _pluginManager (do_GetService(kPluginManagerCID));
|
|
|
|
// Changed by John Sublet : FIXME this assumes _pluginManager will be properly set to NULL
|
|
if (_pluginManager) {
|
|
pluginManager = _pluginManager;
|
|
}
|
|
if (!pluginManager) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
if (!plugletManager) {
|
|
plugletManager = PlugletManager::GetJObject(pluginManager.get());
|
|
}
|
|
*jobj = pluginManager;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::IncObjectCount()
|
|
{
|
|
objectCount++;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::DecObjectCount()
|
|
{
|
|
objectCount--;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP PlugletEngine::GetUnloadable(PRBool *aUnloadable)
|
|
{
|
|
if (nsnull == aUnloadable) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
*aUnloadable = (PRBool) (lockCount == 0
|
|
&& objectCount == 0);
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
static NS_METHOD PlugletEngineRegistration(nsIComponentManager *aCompMgr,
|
|
nsIFile *aPath,
|
|
const char *registryLocation,
|
|
const char *componentType,
|
|
const nsModuleComponentInfo *info)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIServiceManager> servman =
|
|
do_QueryInterface((nsISupports*)aCompMgr, &rv);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
nsCOMPtr<nsICategoryManager> catman;
|
|
servman->GetServiceByContractID(NS_CATEGORYMANAGER_CONTRACTID,
|
|
NS_GET_IID(nsICategoryManager),
|
|
getter_AddRefs(catman));
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
char* previous = nsnull;
|
|
rv = catman->AddCategoryEntry("xpcom-startup",
|
|
"PlugletEngine",
|
|
PLUGLETENGINE_ContractID,
|
|
PR_TRUE,
|
|
PR_TRUE,
|
|
&previous);
|
|
if (previous) {
|
|
nsMemory::Free(previous);
|
|
}
|
|
|
|
PlugletEngine::shutdownObserver = new XPCOMShutdownObserver();
|
|
nsCOMPtr<nsIObserverService> obs
|
|
(do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = obs->AddObserver(PlugletEngine::shutdownObserver,
|
|
NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
|
|
}
|
|
|
|
|
|
return rv;
|
|
}
|
|
static NS_METHOD PlugletEngineUnregistration(nsIComponentManager *aCompMgr,
|
|
nsIFile *aPath,
|
|
const char *registryLocation,
|
|
const nsModuleComponentInfo *info)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIServiceManager> servman =
|
|
do_QueryInterface((nsISupports*)aCompMgr, &rv);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
nsCOMPtr<nsICategoryManager> catman;
|
|
servman->GetServiceByContractID(NS_CATEGORYMANAGER_CONTRACTID,
|
|
NS_GET_IID(nsICategoryManager),
|
|
getter_AddRefs(catman));
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
rv = catman->DeleteCategoryEntry("xpcom-startup",
|
|
"PlugletEngine",
|
|
PR_TRUE);
|
|
return rv;
|
|
}
|
|
|
|
NS_EXPORT
|
|
nsresult
|
|
iPlugletEngine::GetInstance(void ** result)
|
|
{
|
|
nsIServiceManager *servman = nsnull;
|
|
NS_GetServiceManager(&servman);
|
|
nsresult rv;
|
|
rv = servman->GetServiceByContractID(PLUGLETENGINE_ContractID,
|
|
NS_GET_IID(iPlugletEngine),
|
|
(void **) &result);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
PR_LOG(PlugletLog::log, PR_LOG_DEBUG,
|
|
("Pluglet::PlugletFactory: Cannot access iPlugletEngine service\n"));
|
|
return rv;
|
|
}
|
|
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
PlugletEngine *PlugletEngine::_NewInstance()
|
|
{
|
|
PlugletEngine *result = new PlugletEngine();
|
|
return result;
|
|
}
|
|
|
|
NS_GENERIC_FACTORY_CONSTRUCTOR(PlugletEngine)
|
|
|
|
static const nsModuleComponentInfo components[] =
|
|
{
|
|
{ "PlugletEngine",
|
|
PLUGLETENGINE_CID,
|
|
PLUGLETENGINE_ContractID,
|
|
PlugletEngineConstructor,
|
|
PlugletEngineRegistration,
|
|
PlugletEngineUnregistration
|
|
}
|
|
};
|
|
NS_IMPL_NSGETMODULE(PlugletEngineModule, components)
|