Back to index

lightning-sunbird  0.9+nobinonly
Defines | Functions | Variables
nsXPComInit.cpp File Reference
#include "nsXPCOM.h"
#include "nsXPCOMPrivate.h"
#include "nscore.h"
#include "nsStaticComponents.h"
#include "prlink.h"
#include "nsCOMPtr.h"
#include "nsObserverList.h"
#include "nsObserverService.h"
#include "nsProperties.h"
#include "nsIProperties.h"
#include "nsPersistentProperties.h"
#include "nsScriptableInputStream.h"
#include "nsBinaryStream.h"
#include "nsStorageStream.h"
#include "nsPipe.h"
#include "nsMemoryImpl.h"
#include "nsDebugImpl.h"
#include "nsTraceRefcntImpl.h"
#include "nsErrorService.h"
#include "nsByteBuffer.h"
#include "nsSupportsArray.h"
#include "nsArray.h"
#include "nsSupportsPrimitives.h"
#include "nsConsoleService.h"
#include "nsExceptionService.h"
#include "nsComponentManager.h"
#include "nsCategoryManagerUtils.h"
#include "nsIServiceManager.h"
#include "nsGenericFactory.h"
#include "nsEventQueueService.h"
#include "nsEventQueue.h"
#include "nsIProxyObjectManager.h"
#include "nsProxyEventPrivate.h"
#include "xptinfo.h"
#include "nsIInterfaceInfoManager.h"
#include "nsTimerImpl.h"
#include "TimerThread.h"
#include "nsThread.h"
#include "nsProcess.h"
#include "nsEnvironment.h"
#include "nsVersionComparatorImpl.h"
#include "nsEmptyEnumerator.h"
#include "nsILocalFile.h"
#include "nsLocalFile.h"
#include "nsDirectoryService.h"
#include "nsDirectoryServiceDefs.h"
#include "nsCategoryManager.h"
#include "nsICategoryManager.h"
#include "nsStringStream.h"
#include "nsMultiplexInputStream.h"
#include "nsFastLoadService.h"
#include "nsAtomService.h"
#include "nsAtomTable.h"
#include "nsTraceRefcnt.h"
#include "nsTimelineService.h"
#include "nsHashPropertyBag.h"
#include "nsVariant.h"
#include "nsUUIDGenerator.h"
#include "nsRecyclingAllocator.h"
#include "SpecialSystemDirectory.h"
#include "nsSystemInfo.h"
#include <locale.h>

Go to the source code of this file.

Defines

#define NS_ENVIRONMENT_CLASSNAME   "Environment Service"
#define NS_SUPPORTS_ID_CLASSNAME   "Supports ID"
#define NS_SUPPORTS_CSTRING_CLASSNAME   "Supports String"
#define NS_SUPPORTS_STRING_CLASSNAME   "Supports WString"
#define NS_SUPPORTS_PRBOOL_CLASSNAME   "Supports PRBool"
#define NS_SUPPORTS_PRUINT8_CLASSNAME   "Supports PRUint8"
#define NS_SUPPORTS_PRUINT16_CLASSNAME   "Supports PRUint16"
#define NS_SUPPORTS_PRUINT32_CLASSNAME   "Supports PRUint32"
#define NS_SUPPORTS_PRUINT64_CLASSNAME   "Supports PRUint64"
#define NS_SUPPORTS_PRTIME_CLASSNAME   "Supports PRTime"
#define NS_SUPPORTS_CHAR_CLASSNAME   "Supports Char"
#define NS_SUPPORTS_PRINT16_CLASSNAME   "Supports PRInt16"
#define NS_SUPPORTS_PRINT32_CLASSNAME   "Supports PRInt32"
#define NS_SUPPORTS_PRINT64_CLASSNAME   "Supports PRInt64"
#define NS_SUPPORTS_FLOAT_CLASSNAME   "Supports float"
#define NS_SUPPORTS_DOUBLE_CLASSNAME   "Supports double"
#define NS_SUPPORTS_VOID_CLASSNAME   "Supports void"
#define NS_SUPPORTS_INTERFACE_POINTER_CLASSNAME   "Supports interface pointer"
#define COMPONENT(NAME, Ctor)   { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor }
#define COMPONENT_CI(NAME, Ctor, Class)
#define COMPONENT_CI_FLAGS(NAME, Ctor, Class, Flags)
#define NS_ERRORSERVICE_CLASSNAME   NS_ERRORSERVICE_NAME
#define NS_PROPERTIES_CLASSNAME   "Properties"
#define NS_PERSISTENTPROPERTIES_CID   NS_IPERSISTENTPROPERTIES_CID /* sigh */
#define NS_XPCOMPROXY_CID   NS_PROXYEVENT_MANAGER_CID
#define COMPONENT_SUPPORTS(TYPE, Type)   COMPONENT(SUPPORTS_##TYPE, nsSupports##Type##ImplConstructor)
#define NS_LOCAL_FILE_CLASSNAME   "Local File Specification"
#define NS_DIRECTORY_SERVICE_CLASSNAME   "nsIFile Directory Service"
#define NS_HASH_PROPERTY_BAG_CLASSNAME   "Hashtable Property Bag"

Functions

nsresult NS_RegistryGetFactory (nsIFactory **aFactory)
nsresult NS_CategoryManagerGetFactory (nsIFactory **)
static NS_DEFINE_CID (kComponentManagerCID, NS_COMPONENTMANAGER_CID)
static NS_DEFINE_CID (kMemoryCID, NS_MEMORY_CID)
static NS_DEFINE_CID (kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID)
static NS_METHOD nsXPTIInterfaceInfoManagerGetSingleton (nsISupports *outer, const nsIID &aIID, void **aInstancePtr)
 RegisterGenericFactory (nsIComponentRegistrar *registrar, const nsModuleComponentInfo *info)
static PRBool CheckUpdateFile ()
nsresult NS_COM NS_GetDebug (nsIDebug **result)
nsresult NS_COM NS_GetTraceRefcnt (nsITraceRefcnt **result)
nsresult NS_COM NS_InitXPCOM (nsIServiceManager **result, nsIFile *binDirectory)
nsresult NS_COM NS_InitXPCOM2 (nsIServiceManager **result, nsIFile *binDirectory, nsIDirectoryServiceProvider *appFileLocationProvider)
 Initialises XPCOM.
nsresult NS_COM NS_InitXPCOM3 (nsIServiceManager **result, nsIFile *binDirectory, nsIDirectoryServiceProvider *appFileLocationProvider, nsStaticModuleInfo const *staticComponents, PRUint32 componentCount)
 Initialises XPCOM with static components.
static void CallExitRoutines ()
nsresult NS_COM NS_RegisterXPCOMExitRoutine (XPCOMExitRoutine exitRoutine, PRUint32 priority)
nsresult NS_COM NS_UnregisterXPCOMExitRoutine (XPCOMExitRoutine exitRoutine)
nsresult NS_COM NS_ShutdownXPCOM (nsIServiceManager *servMgr)
 Shutdown XPCOM.

Variables

PRBool gXPCOMShuttingDown = PR_FALSE
static const nsModuleComponentInfo components []
const int components_length = sizeof(components) / sizeof(components[0])
static nsIDebuggDebug = nsnull
static nsVoidArraygExitRoutines

Define Documentation

#define COMPONENT (   NAME,
  Ctor 
)    { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor }

Definition at line 311 of file nsXPComInit.cpp.

#define COMPONENT_CI (   NAME,
  Ctor,
  Class 
)
Value:
{ NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor,       \
   NULL, NULL, NULL, NS_CI_INTERFACE_GETTER_NAME(Class), NULL,                 \
   &NS_CLASSINFO_NAME(Class) }

Definition at line 314 of file nsXPComInit.cpp.

#define COMPONENT_CI_FLAGS (   NAME,
  Ctor,
  Class,
  Flags 
)
Value:
{ NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor,       \
   NULL, NULL, NULL, NS_CI_INTERFACE_GETTER_NAME(Class), NULL,                 \
   &NS_CLASSINFO_NAME(Class), Flags }

Definition at line 319 of file nsXPComInit.cpp.

#define COMPONENT_SUPPORTS (   TYPE,
  Type 
)    COMPONENT(SUPPORTS_##TYPE, nsSupports##Type##ImplConstructor)
#define NS_DIRECTORY_SERVICE_CLASSNAME   "nsIFile Directory Service"
#define NS_ENVIRONMENT_CLASSNAME   "Environment Service"

Definition at line 154 of file nsXPComInit.cpp.

#define NS_HASH_PROPERTY_BAG_CLASSNAME   "Hashtable Property Bag"
#define NS_LOCAL_FILE_CLASSNAME   "Local File Specification"
#define NS_PROPERTIES_CLASSNAME   "Properties"

Definition at line 167 of file nsXPComInit.cpp.

Definition at line 159 of file nsXPComInit.cpp.

#define NS_SUPPORTS_DOUBLE_CLASSNAME   "Supports double"

Definition at line 172 of file nsXPComInit.cpp.

#define NS_SUPPORTS_FLOAT_CLASSNAME   "Supports float"

Definition at line 171 of file nsXPComInit.cpp.

Definition at line 158 of file nsXPComInit.cpp.

Definition at line 174 of file nsXPComInit.cpp.

Definition at line 161 of file nsXPComInit.cpp.

Definition at line 168 of file nsXPComInit.cpp.

Definition at line 169 of file nsXPComInit.cpp.

Definition at line 170 of file nsXPComInit.cpp.

Definition at line 166 of file nsXPComInit.cpp.

Definition at line 163 of file nsXPComInit.cpp.

Definition at line 164 of file nsXPComInit.cpp.

Definition at line 165 of file nsXPComInit.cpp.

Definition at line 162 of file nsXPComInit.cpp.

#define NS_SUPPORTS_STRING_CLASSNAME   "Supports WString"

Definition at line 160 of file nsXPComInit.cpp.

Definition at line 173 of file nsXPComInit.cpp.


Function Documentation

static void CallExitRoutines ( ) [static]

Definition at line 735 of file nsXPComInit.cpp.

{
    if (!gExitRoutines)
        return;

    PRInt32 count = gExitRoutines->Count();
    for (PRInt32 i = 0; i < count; i++) {
        XPCOMExitRoutine func = (XPCOMExitRoutine) gExitRoutines->ElementAt(i);
        func();
    }
    gExitRoutines->Clear();
    delete gExitRoutines;
    gExitRoutines = nsnull;
}

Here is the caller graph for this function:

static PRBool CheckUpdateFile ( ) [static]

Definition at line 263 of file nsXPComInit.cpp.

{
    nsresult rv;
    nsCOMPtr<nsIFile> file;
    rv = nsDirectoryService::gService->Get(NS_XPCOM_CURRENT_PROCESS_DIR, 
                                           NS_GET_IID(nsIFile), 
                                           getter_AddRefs(file));

    if (NS_FAILED(rv)) {
        NS_WARNING("Getting NS_XPCOM_CURRENT_PROCESS_DIR failed");
        return PR_FALSE;
    }

    file->AppendNative(nsDependentCString(".autoreg"));
    
    PRBool exists;
    file->Exists(&exists);
    if (!exists)
        return PR_FALSE;

    nsCOMPtr<nsIFile> compregFile;
    rv = nsDirectoryService::gService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE,
                                           NS_GET_IID(nsIFile),
                                           getter_AddRefs(compregFile));

    
    if (NS_FAILED(rv)) {
        NS_WARNING("Getting NS_XPCOM_COMPONENT_REGISTRY_FILE failed");
        return PR_FALSE;
    }

    // Don't need to check whether compreg exists; if it doesn't
    // we won't even be here.

    PRInt64 compregModTime, autoregModTime;
    compregFile->GetLastModifiedTime(&compregModTime);
    file->GetLastModifiedTime(&autoregModTime);

    return LL_CMP(autoregModTime, >, compregModTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 804 of file nsCategoryManager.cpp.

  {
    // assert(aFactory);

    nsresult status;

    *aFactory = 0;
    nsIFactory* new_factory = NS_STATIC_CAST(nsIFactory*, new nsCategoryManagerFactory);
    if (new_factory)
      {
        *aFactory = new_factory;
        NS_ADDREF(*aFactory);
        status = NS_OK;
      }
    else
      status = NS_ERROR_OUT_OF_MEMORY;

    return status;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static NS_DEFINE_CID ( kComponentManagerCID  ,
NS_COMPONENTMANAGER_CID   
) [static]
static NS_DEFINE_CID ( kMemoryCID  ,
NS_MEMORY_CID   
) [static]

Definition at line 429 of file nsXPComInit.cpp.

{
    nsresult rv = NS_OK;
    if (!gDebug)
    {
        rv = nsDebugImpl::Create(nsnull, 
                                 NS_GET_IID(nsIDebug), 
                                 (void**)&gDebug);
    }
    NS_IF_ADDREF(*result = gDebug);
    return rv;
}

Here is the call graph for this function:

Definition at line 447 of file nsXPComInit.cpp.

{
#ifdef NS_BUILD_REFCNT_LOGGING
    nsresult rv = NS_OK;
    if (!gTraceRefcnt)
    {
        rv = nsTraceRefcntImpl::Create(nsnull, 
                                       NS_GET_IID(nsITraceRefcnt), 
                                       (void**)&gTraceRefcnt);
    }
    NS_IF_ADDREF(*result = gTraceRefcnt);
    return rv;
#else
    return NS_ERROR_NOT_INITIALIZED;
#endif
}

Here is the call graph for this function:

nsresult NS_COM NS_InitXPCOM ( nsIServiceManager **  result,
nsIFile binDirectory 
)

Definition at line 464 of file nsXPComInit.cpp.

{
    return NS_InitXPCOM3(result, binDirectory, nsnull, nsnull, 0);
}

Here is the call graph for this function:

nsresult NS_COM NS_InitXPCOM2 ( nsIServiceManager **  result,
nsIFile binDirectory,
nsIDirectoryServiceProvider appFileLocationProvider 
)

Initialises XPCOM.

You must call one of the NS_InitXPCOM methods before proceeding to use xpcom. The one exception is that you may call NS_NewLocalFile to create a nsIFile.

FROZEN

Note:
Use NS_NewLocalFile or NS_NewNativeLocalFile to create the file object you supply as the bin directory path in this call. The function may be safely called before the rest of XPCOM or embedding has been initialised.
Parameters:
resultThe service manager. You may pass null.
binDirectoryThe directory containing the component registry and runtime libraries; or use nsnull to use the working directory.
appFileLocationProviderThe object to be used by Gecko that specifies to Gecko where to find profiles, the component registry preferences and so on; or use nsnull for the default behaviour.
See also:
NS_NewLocalFile
nsILocalFile
nsIDirectoryServiceProvider
Returns:
NS_OK for success; NS_ERROR_NOT_INITIALIZED if static globals were not initialized, which can happen if XPCOM is reloaded, but did not completly shutdown. Other error codes indicate a failure during initialisation.

Definition at line 470 of file nsXPComInit.cpp.

{
    return NS_InitXPCOM3(result, binDirectory, appFileLocationProvider, nsnull, 0);
}

Here is the call graph for this function:

nsresult NS_COM NS_InitXPCOM3 ( nsIServiceManager **  result,
nsIFile binDirectory,
nsIDirectoryServiceProvider appFileLocationProvider,
nsStaticModuleInfo const staticComponents,
PRUint32  componentCount 
)

Initialises XPCOM with static components.

You must call one of the NS_InitXPCOM methods before proceeding to use xpcom. The one exception is that you may call NS_NewLocalFile to create a nsIFile.

FROZEN

Note:
Use NS_NewLocalFile or NS_NewNativeLocalFile to create the file object you supply as the bin directory path in this call. The function may be safely called before the rest of XPCOM or embedding has been initialised.
Parameters:
resultThe service manager. You may pass null.
binDirectoryThe directory containing the component registry and runtime libraries; or use nsnull to use the working directory.
appFileLocationProviderThe object to be used by Gecko that specifies to Gecko where to find profiles, the component registry preferences and so on; or use nsnull for the default behaviour.
staticComponentsAn array of static components. Passing null causes default (builtin) components to be registered, if present.
componentCountNumber of elements in staticComponents
See also:
NS_NewLocalFile
nsILocalFile
nsIDirectoryServiceProvider
XRE_GetStaticComponents
Returns:
NS_OK for success; NS_ERROR_NOT_INITIALIZED if static globals were not initialized, which can happen if XPCOM is reloaded, but did not completly shutdown. Other error codes indicate a failure during initialisation.

Definition at line 477 of file nsXPComInit.cpp.

{
    nsresult rv = NS_OK;

#ifdef MOZ_ENABLE_LIBXUL
    if (!staticComponents) {
        staticComponents = kPStaticModules;
        componentCount = kStaticModuleCount;
    }
#endif

     // We are not shutting down
    gXPCOMShuttingDown = PR_FALSE;

#ifdef NS_BUILD_REFCNT_LOGGING
    nsTraceRefcntImpl::Startup();
#endif

    // Establish the main thread here.
    rv = nsIThread::SetMainThread();
    if (NS_FAILED(rv)) return rv;

    // Set up the timer globals/timer thread
    rv = nsTimerImpl::Startup();
    NS_ENSURE_SUCCESS(rv, rv);

    // Startup the memory manager
    rv = nsMemoryImpl::Startup();
    if (NS_FAILED(rv)) return rv;

#ifndef WINCE
    // If the locale hasn't already been setup by our embedder,
    // get us out of the "C" locale and into the system 
    if (strcmp(setlocale(LC_ALL, NULL), "C") == 0)
        setlocale(LC_ALL, "");
#endif

#if defined(XP_UNIX) || defined(XP_OS2)
    NS_StartupNativeCharsetUtils();
#endif
    NS_StartupLocalFile();

    StartupSpecialSystemDirectory();

    rv = nsDirectoryService::RealInit();
    if (NS_FAILED(rv))
        return rv;

    // Create the Component/Service Manager
    nsComponentManagerImpl *compMgr = NULL;

    if (nsComponentManagerImpl::gComponentManager == NULL)
    {
        compMgr = new nsComponentManagerImpl();
        if (compMgr == NULL)
            return NS_ERROR_OUT_OF_MEMORY;
        NS_ADDREF(compMgr);
        
        nsCOMPtr<nsIFile> xpcomLib;
                
        PRBool value;
        if (binDirectory)
        {
            rv = binDirectory->IsDirectory(&value);

            if (NS_SUCCEEDED(rv) && value) {
                nsDirectoryService::gService->Set(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, binDirectory);
                binDirectory->Clone(getter_AddRefs(xpcomLib));
            }
        }
        else {
            nsDirectoryService::gService->Get(NS_XPCOM_CURRENT_PROCESS_DIR, 
                                              NS_GET_IID(nsIFile), 
                                              getter_AddRefs(xpcomLib));
        }

        if (xpcomLib) {
            xpcomLib->AppendNative(nsDependentCString(XPCOM_DLL));
            nsDirectoryService::gService->Set(NS_XPCOM_LIBRARY_FILE, xpcomLib);
        }
        
        if (appFileLocationProvider) {
            rv = nsDirectoryService::gService->RegisterProvider(appFileLocationProvider);
            if (NS_FAILED(rv)) return rv;
        }

        rv = compMgr->Init(staticComponents, componentCount);
        if (NS_FAILED(rv))
        {
            NS_RELEASE(compMgr);
            return rv;
        }

        nsComponentManagerImpl::gComponentManager = compMgr;

        if (result) {
            nsIServiceManager *serviceManager =
                NS_STATIC_CAST(nsIServiceManager*, compMgr);

            NS_ADDREF(*result = serviceManager);
        }
    }

    nsCOMPtr<nsIMemory> memory;
    NS_GetMemoryManager(getter_AddRefs(memory));
    // dougt - these calls will be moved into a new interface when nsIComponentManager is frozen.
    rv = compMgr->RegisterService(kMemoryCID, memory);
    if (NS_FAILED(rv)) return rv;

    rv = compMgr->RegisterService(kComponentManagerCID, NS_STATIC_CAST(nsIComponentManager*, compMgr));
    if (NS_FAILED(rv)) return rv;

#ifdef GC_LEAK_DETECTOR
  rv = NS_InitLeakDetector();
    if (NS_FAILED(rv)) return rv;
#endif

    // 2. Register the global services with the component manager so that
    //    clients can create new objects.

    // Category Manager
    {
      nsCOMPtr<nsIFactory> categoryManagerFactory;
      if ( NS_FAILED(rv = NS_CategoryManagerGetFactory(getter_AddRefs(categoryManagerFactory))) )
        return rv;

      NS_DEFINE_CID(kCategoryManagerCID, NS_CATEGORYMANAGER_CID);

      rv = compMgr->RegisterFactory(kCategoryManagerCID,
                                    NS_CATEGORYMANAGER_CLASSNAME,
                                    NS_CATEGORYMANAGER_CONTRACTID,
                                    categoryManagerFactory,
                                    PR_TRUE);
      if ( NS_FAILED(rv) ) return rv;
    }

    // what I want to do here is QI for a Component Registration Manager.  Since this
    // has not been invented yet, QI to the obsolete manager.  Kids, don't do this at home.
    nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(
        NS_STATIC_CAST(nsIComponentManager*,compMgr), &rv);
    if (registrar) {
        for (int i = 0; i < components_length; i++)
            RegisterGenericFactory(registrar, &components[i]);
    }
    rv = nsComponentManagerImpl::gComponentManager->ReadPersistentRegistry();
#ifdef DEBUG    
    if (NS_FAILED(rv)) {
        printf("No Persistent Registry Found.\n");        
    }
#endif

    if ( NS_FAILED(rv) || CheckUpdateFile()) {
        // if we find no persistent registry, we will try to autoregister
        // the default components directory.
        nsComponentManagerImpl::gComponentManager->AutoRegister(nsnull);

        // If the application is using a GRE, then, 
        // auto register components in the GRE directory as well.
        //
        // The application indicates that it's using an GRE by
        // returning a valid nsIFile when queried (via appFileLocProvider)
        // for the NS_GRE_DIR atom as shown below
        //

        if ( appFileLocationProvider ) {
            nsCOMPtr<nsIFile> greDir;
            PRBool persistent = PR_TRUE;

            appFileLocationProvider->GetFile(NS_GRE_DIR, &persistent, getter_AddRefs(greDir));

            if (greDir) {
#ifdef DEBUG_dougt
                printf("start - Registering GRE components\n");
#endif
                rv = nsDirectoryService::gService->Get(NS_GRE_COMPONENT_DIR,
                                                       NS_GET_IID(nsIFile),
                                                       getter_AddRefs(greDir));
                if (NS_FAILED(rv)) {
                    NS_ERROR("Could not get GRE components directory!");
                    return rv;
                }

                // If the GRE contains any loaders, we want to know about it so that we can cause another
                // autoregistration of the applications component directory.
                int loaderCount = nsComponentManagerImpl::gComponentManager->GetLoaderCount();
                rv = nsComponentManagerImpl::gComponentManager->AutoRegister(greDir);
                
                if (loaderCount != nsComponentManagerImpl::gComponentManager->GetLoaderCount()) 
                    nsComponentManagerImpl::gComponentManager->AutoRegisterNonNativeComponents(nsnull);        

#ifdef DEBUG_dougt
                printf("end - Registering GRE components\n");
#endif          
                if (NS_FAILED(rv)) {
                    NS_ERROR("Could not AutoRegister GRE components");
                    return rv;
                }
            }
        }

        //
        // If additional component directories have been specified, then
        // register them as well.
        //

        nsCOMPtr<nsISimpleEnumerator> dirList;
        nsDirectoryService::gService->Get(NS_XPCOM_COMPONENT_DIR_LIST,
                                          NS_GET_IID(nsISimpleEnumerator),
                                          getter_AddRefs(dirList));
        if (dirList) {
            PRBool hasMore;
            while (NS_SUCCEEDED(dirList->HasMoreElements(&hasMore)) && hasMore) {
                nsCOMPtr<nsISupports> elem;
                dirList->GetNext(getter_AddRefs(elem));
                if (elem) {
                    nsCOMPtr<nsIFile> dir = do_QueryInterface(elem);
                    if (dir)
                        nsComponentManagerImpl::gComponentManager->AutoRegister(dir);

                    // XXX should we worry about new component loaders being
                    // XXX defined by this process?
                }
            }
        }


        // Make sure the compreg file's mod time is current.
        nsCOMPtr<nsIFile> compregFile;
        rv = nsDirectoryService::gService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE,
                                               NS_GET_IID(nsIFile),
                                               getter_AddRefs(compregFile));
        compregFile->SetLastModifiedTime(PR_Now() / 1000);
    }
    
    // Pay the cost at startup time of starting this singleton.
    nsIInterfaceInfoManager* iim = XPTI_GetInterfaceInfoManager();
    NS_IF_RELEASE(iim);

    // After autoreg, but before we actually instantiate any components,
    // add any services listed in the "xpcom-directory-providers" category
    // to the directory service.
    nsDirectoryService::gService->RegisterCategoryProviders();

    // Notify observers of xpcom autoregistration start
    NS_CreateServicesFromCategory(NS_XPCOM_STARTUP_OBSERVER_ID, 
                                  nsnull,
                                  NS_XPCOM_STARTUP_OBSERVER_ID);
    
    return NS_OK;
}

Here is the call graph for this function:

Definition at line 751 of file nsXPComInit.cpp.

{
    // priority are not used right now.  It will need to be implemented as more
    // classes are moved into the glue library --dougt
    if (!gExitRoutines) {
        gExitRoutines = new nsVoidArray();
        if (!gExitRoutines) {
            NS_WARNING("Failed to allocate gExitRoutines");
            return NS_ERROR_FAILURE;
        }
    }

    PRBool okay = gExitRoutines->AppendElement((void*)exitRoutine);
    return okay ? NS_OK : NS_ERROR_FAILURE;
}

Here is the caller graph for this function:

Definition at line 2001 of file nsRegistry.cpp.

                                              {
    nsresult rv = NS_OK;

    if( aFactory == 0 ) {
        return NS_ERROR_NULL_POINTER;
    } else {
        *aFactory = 0;
    }

    nsIFactory* inst = new nsRegistryFactory();
    if(0 == inst) {
        rv = NS_ERROR_OUT_OF_MEMORY;
    } else {
        NS_ADDREF(inst);
        *aFactory = inst;
    }

    return rv;
}

Here is the call graph for this function:

Shutdown XPCOM.

You must call this method after you are finished using xpcom.

FROZEN

Parameters:
servMgrThe service manager which was returned by NS_InitXPCOM. This will release servMgr. You may pass null.
Returns:
NS_OK for success; other error codes indicate a failure during initialisation.

Definition at line 794 of file nsXPComInit.cpp.

{

    // Notify observers of xpcom shutting down
    nsresult rv = NS_OK;
    {
        // Block it so that the COMPtr will get deleted before we hit
        // servicemanager shutdown
        nsCOMPtr<nsIObserverService> observerService =
                 do_GetService("@mozilla.org/observer-service;1", &rv);
        if (NS_SUCCEEDED(rv))
        {
            nsCOMPtr<nsIServiceManager> mgr;
            rv = NS_GetServiceManager(getter_AddRefs(mgr));
            if (NS_SUCCEEDED(rv))
            {
                (void) observerService->NotifyObservers(mgr,
                                                        NS_XPCOM_SHUTDOWN_OBSERVER_ID,
                                                        nsnull);
            }
        }
    }

    // grab the event queue so that we can process events one last time before exiting
    nsCOMPtr <nsIEventQueue> currentQ;
    {
        nsCOMPtr<nsIEventQueueService> eventQService =
                 do_GetService(kEventQueueServiceCID, &rv);

        if (eventQService) {
            eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(currentQ));
        }
    }
    // XPCOM is officially in shutdown mode NOW
    // Set this only after the observers have been notified as this
    // will cause servicemanager to become inaccessible.
    gXPCOMShuttingDown = PR_TRUE;

#ifdef DEBUG_dougt
    fprintf(stderr, "* * * * XPCOM shutdown. Access will be denied * * * * \n");
#endif
    // We may have AddRef'd for the caller of NS_InitXPCOM, so release it
    // here again:
    NS_IF_RELEASE(servMgr);

    // Shutdown global servicemanager
    if (nsComponentManagerImpl::gComponentManager) {
        nsComponentManagerImpl::gComponentManager->FreeServices();
    }

    if (currentQ) {
        currentQ->ProcessPendingEvents();
        currentQ = 0;
    }
    
    nsProxyObjectManager::Shutdown();

    // Release the directory service
    NS_IF_RELEASE(nsDirectoryService::gService);

    // Shutdown nsLocalFile string conversion
    NS_ShutdownLocalFile();
#ifdef XP_UNIX
    NS_ShutdownNativeCharsetUtils();
#endif

    // Shutdown the timer thread and all timers that might still be alive before
    // shutting down the component manager
    nsTimerImpl::Shutdown();

    CallExitRoutines();

    // Shutdown xpcom. This will release all loaders and cause others holding
    // a refcount to the component manager to release it.
    if (nsComponentManagerImpl::gComponentManager) {
        rv = (nsComponentManagerImpl::gComponentManager)->Shutdown();
        NS_ASSERTION(NS_SUCCEEDED(rv), "Component Manager shutdown failed.");
    } else
        NS_WARNING("Component Manager was never created ...");

    // Release our own singletons
    // Do this _after_ shutting down the component manager, because the
    // JS component loader will use XPConnect to call nsIModule::canUnload,
    // and that will spin up the InterfaceInfoManager again -- bad mojo
    XPTI_FreeInterfaceInfoManager();

    // Finally, release the component manager last because it unloads the
    // libraries:
    if (nsComponentManagerImpl::gComponentManager) {
      nsrefcnt cnt;
      NS_RELEASE2(nsComponentManagerImpl::gComponentManager, cnt);
      NS_WARN_IF_FALSE(cnt == 0, "Component Manager being held past XPCOM shutdown.");
    }
    nsComponentManagerImpl::gComponentManager = nsnull;

#ifdef DEBUG
    _FreeAutoLockStatics();
#endif

    ShutdownSpecialSystemDirectory();

    EmptyEnumeratorImpl::Shutdown();
    nsMemoryImpl::Shutdown();

    nsThread::Shutdown();
    NS_PurgeAtomTable();

    NS_IF_RELEASE(gDebug);

#ifdef NS_BUILD_REFCNT_LOGGING
    nsTraceRefcntImpl::DumpStatistics();
    nsTraceRefcntImpl::ResetStatistics();
    nsTraceRefcntImpl::Shutdown();
#endif

#ifdef GC_LEAK_DETECTOR
    // Shutdown the Leak detector.
    NS_ShutdownLeakDetector();
#endif

    return NS_OK;
}

Here is the call graph for this function:

Definition at line 768 of file nsXPComInit.cpp.

{
    if (!gExitRoutines)
        return NS_ERROR_FAILURE;

    PRBool okay = gExitRoutines->RemoveElement((void*)exitRoutine);
    return okay ? NS_OK : NS_ERROR_FAILURE;
}
static NS_METHOD nsXPTIInterfaceInfoManagerGetSingleton ( nsISupports *  outer,
const nsIID aIID,
void **  aInstancePtr 
) [static]

Definition at line 225 of file nsXPComInit.cpp.

{
    NS_ENSURE_ARG_POINTER(aInstancePtr);
    NS_ENSURE_TRUE(!outer, NS_ERROR_NO_AGGREGATION);

    nsCOMPtr<nsIInterfaceInfoManager> iim(dont_AddRef(XPTI_GetInterfaceInfoManager()));
    if (!iim) {
        return NS_ERROR_FAILURE;
    }

    return iim->QueryInterface(aIID, aInstancePtr);
}

Here is the call graph for this function:

Definition at line 242 of file nsXPComInit.cpp.

{
    nsresult rv;
    nsIGenericFactory* fact;
    rv = NS_NewGenericFactory(&fact, info);
    if (NS_FAILED(rv)) return rv;

    rv = registrar->RegisterFactory(info->mCID, 
                                    info->mDescription,
                                    info->mContractID, 
                                    fact);
    NS_RELEASE(fact);
    return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 324 of file nsXPComInit.cpp.

Definition at line 425 of file nsXPComInit.cpp.

nsIDebug* gDebug = nsnull [static]

Definition at line 428 of file nsXPComInit.cpp.

Definition at line 733 of file nsXPComInit.cpp.

Definition at line 306 of file nsXPComInit.cpp.