VirtualBox

source: vbox/trunk/src/libs/xpcom18a4/xpcom/build/nsXPComInit.cpp

Last change on this file was 103533, checked in by vboxsync, 4 months ago

libs/xpcom: Remove unused ipcLockservice and tmTransactionManager interfaces and code, bugref:10602
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 27.1 KB
Line 
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/* ***** BEGIN LICENSE BLOCK *****
3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 *
5 * The contents of this file are subject to the Mozilla Public License Version
6 * 1.1 (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 * http://www.mozilla.org/MPL/
9 *
10 * Software distributed under the License is distributed on an "AS IS" basis,
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 * for the specific language governing rights and limitations under the
13 * License.
14 *
15 * The Original Code is mozilla.org code.
16 *
17 * The Initial Developer of the Original Code is
18 * Netscape Communications Corporation.
19 * Portions created by the Initial Developer are Copyright (C) 1998
20 * the Initial Developer. All Rights Reserved.
21 *
22 * Contributor(s):
23 *
24 * Alternatively, the contents of this file may be used under the terms of
25 * either of the GNU General Public License Version 2 or later (the "GPL"),
26 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 * in which case the provisions of the GPL or the LGPL are applicable instead
28 * of those above. If you wish to allow use of your version of this file only
29 * under the terms of either the GPL or the LGPL, and not to allow others to
30 * use your version of this file under the terms of the MPL, indicate your
31 * decision by deleting the provisions above and replace them with the notice
32 * and other provisions required by the GPL or the LGPL. If you do not delete
33 * the provisions above, a recipient may use your version of this file under
34 * the terms of any one of the MPL, the GPL or the LGPL.
35 *
36 * ***** END LICENSE BLOCK ***** */
37
38#include <iprt/initterm.h>
39#include <iprt/time.h>
40
41#include "nsXPCOM.h"
42#include "nsXPCOMPrivate.h"
43#include "nscore.h"
44#include "nsCOMPtr.h"
45#include "nsObserverList.h"
46#include "nsObserverService.h"
47#include "nsProperties.h"
48#include "nsIProperties.h"
49
50#include "nsDebugImpl.h"
51#include "nsTraceRefcntImpl.h"
52#include "nsErrorService.h"
53
54#include "nsSupportsArray.h"
55#include "nsArray.h"
56#include "nsSupportsPrimitives.h"
57#include "nsExceptionService.h"
58
59#include "nsComponentManager.h"
60#include "nsCategoryManagerUtils.h"
61#include "nsIServiceManager.h"
62#include "nsGenericFactory.h"
63
64#include "nsEventQueueService.h"
65#include "nsEventQueue.h"
66#ifdef VBOX
67# include "nsEventQueueUtils.h"
68# include "nsProxyRelease.h"
69#endif /* VBOX */
70
71#include "nsIProxyObjectManager.h"
72#include "nsProxyEventPrivate.h" // access to the impl of nsProxyObjectManager for the generic factory registration.
73
74#include "xptinfo.h"
75#include "nsIInterfaceInfoManager.h"
76
77#include "nsEmptyEnumerator.h"
78
79#include "nsILocalFile.h"
80#include "nsLocalFile.h"
81#if defined(XP_UNIX) || defined(XP_OS2)
82#include "nsNativeCharsetUtils.h"
83#endif
84#include "nsDirectoryService.h"
85#include "nsDirectoryServiceDefs.h"
86#include "nsCategoryManager.h"
87#include "nsICategoryManager.h"
88
89#include "nsAtomService.h"
90#include "nsAtomTable.h"
91#include "nsTraceRefcnt.h"
92
93#include "nsVariant.h"
94
95#include "SpecialSystemDirectory.h"
96
97#include "ipcdclient.h"
98#include "ipcService.h"
99#include "ipcConfig.h"
100#include "ipcCID.h"
101#include "ipcDConnectService.h"
102
103#include <locale.h>
104
105// Registry Factory creation function defined in nsRegistry.cpp
106// We hook into this function locally to create and register the registry
107// Since noone outside xpcom needs to know about this and nsRegistry.cpp
108// does not have a local include file, we are putting this definition
109// here rather than in nsIRegistry.h
110extern nsresult NS_RegistryGetFactory(nsIFactory** aFactory);
111extern nsresult NS_CategoryManagerGetFactory( nsIFactory** );
112
113static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
114static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
115
116NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsEventQueueServiceImpl, Init)
117
118static RTTHREAD g_hMainThread = 0;
119
120#define NS_ENVIRONMENT_CLASSNAME "Environment Service"
121
122#include "nsXPCOM.h"
123// ds/nsISupportsPrimitives
124#define NS_SUPPORTS_ID_CLASSNAME "Supports ID"
125#define NS_SUPPORTS_CSTRING_CLASSNAME "Supports String"
126#define NS_SUPPORTS_STRING_CLASSNAME "Supports WString"
127#define NS_SUPPORTS_PRBOOL_CLASSNAME "Supports PRBool"
128#define NS_SUPPORTS_PRUINT8_CLASSNAME "Supports PRUint8"
129#define NS_SUPPORTS_PRUINT16_CLASSNAME "Supports PRUint16"
130#define NS_SUPPORTS_PRUINT32_CLASSNAME "Supports PRUint32"
131#define NS_SUPPORTS_PRUINT64_CLASSNAME "Supports PRUint64"
132#define NS_SUPPORTS_PRTIME_CLASSNAME "Supports PRTime"
133#define NS_SUPPORTS_CHAR_CLASSNAME "Supports Char"
134#define NS_SUPPORTS_PRINT16_CLASSNAME "Supports PRInt16"
135#define NS_SUPPORTS_PRINT32_CLASSNAME "Supports PRInt32"
136#define NS_SUPPORTS_PRINT64_CLASSNAME "Supports PRInt64"
137#define NS_SUPPORTS_FLOAT_CLASSNAME "Supports float"
138#define NS_SUPPORTS_DOUBLE_CLASSNAME "Supports double"
139#define NS_SUPPORTS_VOID_CLASSNAME "Supports void"
140#define NS_SUPPORTS_INTERFACE_POINTER_CLASSNAME "Supports interface pointer"
141
142NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsIDImpl)
143NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsStringImpl)
144NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsCStringImpl)
145NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRBoolImpl)
146NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint8Impl)
147NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint16Impl)
148NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint32Impl)
149NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint64Impl)
150NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRTimeImpl)
151NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsCharImpl)
152NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt16Impl)
153NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt32Impl)
154NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt64Impl)
155NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsFloatImpl)
156NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsDoubleImpl)
157NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsVoidImpl)
158NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsInterfacePointerImpl)
159
160NS_GENERIC_FACTORY_CONSTRUCTOR(nsArray)
161NS_GENERIC_FACTORY_CONSTRUCTOR(nsAtomService)
162NS_GENERIC_FACTORY_CONSTRUCTOR(nsExceptionService)
163
164NS_GENERIC_FACTORY_CONSTRUCTOR(nsVariant)
165
166static NS_METHOD
167nsXPTIInterfaceInfoManagerGetSingleton(nsISupports* outer,
168 const nsIID& aIID,
169 void* *aInstancePtr)
170{
171 NS_ENSURE_ARG_POINTER(aInstancePtr);
172 NS_ENSURE_TRUE(!outer, NS_ERROR_NO_AGGREGATION);
173
174 nsCOMPtr<nsIInterfaceInfoManager> iim(dont_AddRef(XPTI_GetInterfaceInfoManager()));
175 if (!iim) {
176 return NS_ERROR_FAILURE;
177 }
178
179 return iim->QueryInterface(aIID, aInstancePtr);
180}
181
182
183PR_STATIC_CALLBACK(nsresult)
184RegisterGenericFactory(nsIComponentRegistrar* registrar,
185 const nsModuleComponentInfo *info)
186{
187 nsresult rv;
188 nsIGenericFactory* fact;
189 rv = NS_NewGenericFactory(&fact, info);
190 if (NS_FAILED(rv)) return rv;
191
192 rv = registrar->RegisterFactory(info->mCID,
193 info->mDescription,
194 info->mContractID,
195 fact);
196 NS_RELEASE(fact);
197 return rv;
198}
199
200// In order to support the installer, we need
201// to be told out of band if we should cause
202// an autoregister. If the file ".autoreg" exists in the binary
203// directory, we check its timestamp against the timestamp of the
204// compreg.dat file. If the .autoreg file is newer, we autoregister.
205static PRBool CheckUpdateFile()
206{
207 nsresult rv;
208 nsCOMPtr<nsIProperties> directoryService;
209 nsDirectoryService::Create(nsnull,
210 NS_GET_IID(nsIProperties),
211 getter_AddRefs(directoryService));
212
213 if (!directoryService)
214 return PR_FALSE;
215
216 nsCOMPtr<nsIFile> file;
217 rv = directoryService->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
218 NS_GET_IID(nsIFile),
219 getter_AddRefs(file));
220
221 if (NS_FAILED(rv)) {
222 NS_WARNING("Getting NS_XPCOM_CURRENT_PROCESS_DIR failed");
223 return PR_FALSE;
224 }
225
226 file->AppendNative(nsDependentCString(".autoreg"));
227
228 PRBool exists;
229 file->Exists(&exists);
230 if (!exists)
231 return PR_FALSE;
232
233 nsCOMPtr<nsIFile> compregFile;
234 rv = directoryService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE,
235 NS_GET_IID(nsIFile),
236 getter_AddRefs(compregFile));
237
238
239 if (NS_FAILED(rv)) {
240 NS_WARNING("Getting NS_XPCOM_COMPONENT_REGISTRY_FILE failed");
241 return PR_FALSE;
242 }
243
244 // Don't need to check whether compreg exists; if it doesn't
245 // we won't even be here.
246
247 PRInt64 compregModTime, autoregModTime;
248 compregFile->GetLastModifiedTime(&compregModTime);
249 file->GetLastModifiedTime(&autoregModTime);
250
251 return LL_CMP(autoregModTime, >, compregModTime);
252}
253
254nsComponentManagerImpl* nsComponentManagerImpl::gComponentManager = NULL;
255nsIProperties *gDirectoryService = NULL;
256PRBool gXPCOMShuttingDown = PR_FALSE;
257#ifdef VBOX
258static PRBool gXPCOMInitialized = PR_FALSE;
259#endif
260
261// For each class that wishes to support nsIClassInfo, add a line like this
262// NS_DECL_CLASSINFO(nsMyClass)
263
264#define COMPONENT(NAME, Ctor) \
265 { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor }
266
267#define COMPONENT_CI(NAME, Ctor, Class) \
268 { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor, \
269 NULL, NULL, NULL, NS_CI_INTERFACE_GETTER_NAME(Class), NULL, \
270 &NS_CLASSINFO_NAME(Class) }
271
272static const nsModuleComponentInfo components[] = {
273 COMPONENT(DEBUG, nsDebugImpl::Create),
274#define NS_ERRORSERVICE_CLASSNAME NS_ERRORSERVICE_NAME
275 COMPONENT(ERRORSERVICE, nsErrorService::Create),
276
277#define NS_PROPERTIES_CLASSNAME "Properties"
278 COMPONENT(PROPERTIES, nsProperties::Create),
279
280 COMPONENT(SUPPORTSARRAY, nsSupportsArray::Create),
281 COMPONENT(ARRAY, nsArrayConstructor),
282 COMPONENT(EXCEPTIONSERVICE, nsExceptionServiceConstructor),
283 COMPONENT(ATOMSERVICE, nsAtomServiceConstructor),
284 COMPONENT(OBSERVERSERVICE, nsObserverService::Create),
285 COMPONENT(GENERICFACTORY, nsGenericFactory::Create),
286 COMPONENT(EVENTQUEUESERVICE, nsEventQueueServiceImplConstructor),
287 COMPONENT(EVENTQUEUE, nsEventQueueImpl::Create),
288
289#define NS_XPCOMPROXY_CID NS_PROXYEVENT_MANAGER_CID
290 COMPONENT(XPCOMPROXY, nsProxyObjectManager::Create),
291
292#define COMPONENT_SUPPORTS(TYPE, Type) \
293 COMPONENT(SUPPORTS_##TYPE, nsSupports##Type##ImplConstructor)
294
295 COMPONENT_SUPPORTS(ID, ID),
296 COMPONENT_SUPPORTS(STRING, String),
297 COMPONENT_SUPPORTS(CSTRING, CString),
298 COMPONENT_SUPPORTS(PRBOOL, PRBool),
299 COMPONENT_SUPPORTS(PRUINT8, PRUint8),
300 COMPONENT_SUPPORTS(PRUINT16, PRUint16),
301 COMPONENT_SUPPORTS(PRUINT32, PRUint32),
302 COMPONENT_SUPPORTS(PRUINT64, PRUint64),
303 COMPONENT_SUPPORTS(PRTIME, PRTime),
304 COMPONENT_SUPPORTS(CHAR, Char),
305 COMPONENT_SUPPORTS(PRINT16, PRInt16),
306 COMPONENT_SUPPORTS(PRINT32, PRInt32),
307 COMPONENT_SUPPORTS(PRINT64, PRInt64),
308 COMPONENT_SUPPORTS(FLOAT, Float),
309 COMPONENT_SUPPORTS(DOUBLE, Double),
310 COMPONENT_SUPPORTS(VOID, Void),
311 COMPONENT_SUPPORTS(INTERFACE_POINTER, InterfacePointer),
312
313#undef COMPONENT_SUPPORTS
314#define NS_LOCAL_FILE_CLASSNAME "Local File Specification"
315 COMPONENT(LOCAL_FILE, nsLocalFile::nsLocalFileConstructor),
316#define NS_DIRECTORY_SERVICE_CLASSNAME "nsIFile Directory Service"
317 COMPONENT(DIRECTORY_SERVICE, nsDirectoryService::Create),
318
319 COMPONENT(VARIANT, nsVariantConstructor),
320 COMPONENT(INTERFACEINFOMANAGER_SERVICE, nsXPTIInterfaceInfoManagerGetSingleton),
321};
322
323#undef COMPONENT
324
325const int components_length = sizeof(components) / sizeof(components[0]);
326
327// gDebug will be freed during shutdown.
328static nsIDebug* gDebug = nsnull;
329nsresult NS_COM NS_GetDebug(nsIDebug** result)
330{
331 nsresult rv = NS_OK;
332 if (!gDebug)
333 {
334 rv = nsDebugImpl::Create(nsnull,
335 NS_GET_IID(nsIDebug),
336 (void**)&gDebug);
337 }
338 NS_IF_ADDREF(*result = gDebug);
339 return rv;
340}
341
342#ifdef NS_BUILD_REFCNT_LOGGING
343// gTraceRefcnt will be freed during shutdown.
344static nsITraceRefcnt* gTraceRefcnt = nsnull;
345#endif
346
347nsresult NS_COM NS_GetTraceRefcnt(nsITraceRefcnt** result)
348{
349#ifdef NS_BUILD_REFCNT_LOGGING
350 nsresult rv = NS_OK;
351 if (!gTraceRefcnt)
352 {
353 rv = nsTraceRefcntImpl::Create(nsnull,
354 NS_GET_IID(nsITraceRefcnt),
355 (void**)&gTraceRefcnt);
356 }
357 NS_IF_ADDREF(*result = gTraceRefcnt);
358 return rv;
359#else
360 return NS_ERROR_NOT_INITIALIZED;
361#endif
362}
363
364#ifdef VBOX
365PRBool NS_COM NS_IsXPCOMInitialized(void)
366{
367 return gXPCOMInitialized;
368}
369#endif
370
371nsresult NS_COM
372NS_GetMainThread(RTTHREAD *phThreadMain)
373{
374 NS_ASSERTION(phThreadMain, "bad result pointer");
375 if (g_hMainThread == NIL_RTTHREAD)
376 return NS_ERROR_FAILURE;
377 *phThreadMain = g_hMainThread;
378 return NS_OK;
379}
380
381nsresult NS_COM NS_InitXPCOM2(nsIServiceManager* *result,
382 nsIFile* binDirectory,
383 nsIDirectoryServiceProvider* appFileLocationProvider)
384{
385 nsresult rv = NS_OK;
386
387 /* Make sure IPRT is initialized. */
388 RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE);
389
390 // We are not shutting down
391 gXPCOMShuttingDown = PR_FALSE;
392
393#ifdef NS_BUILD_REFCNT_LOGGING
394 nsTraceRefcntImpl::Startup();
395#endif
396
397 // Establish the main thread here.
398 g_hMainThread = RTThreadSelf();
399
400 // If the locale hasn't already been setup by our embedder,
401 // get us out of the "C" locale and into the system
402 if (strcmp(setlocale(LC_ALL, NULL), "C") == 0)
403 setlocale(LC_ALL, "");
404
405#if defined(XP_UNIX) || defined(XP_OS2)
406 NS_StartupNativeCharsetUtils();
407#endif
408 NS_StartupLocalFile();
409
410 StartupSpecialSystemDirectory();
411
412 // Start the directory service so that the component manager init can use it.
413 rv = nsDirectoryService::Create(nsnull,
414 NS_GET_IID(nsIProperties),
415 (void**)&gDirectoryService);
416 if (NS_FAILED(rv))
417 return rv;
418
419 nsCOMPtr<nsIDirectoryService> dirService = do_QueryInterface(gDirectoryService, &rv);
420 if (NS_FAILED(rv))
421 return rv;
422 rv = dirService->Init();
423 if (NS_FAILED(rv))
424 return rv;
425
426 // Create the Component/Service Manager
427 nsComponentManagerImpl *compMgr = NULL;
428
429 if (nsComponentManagerImpl::gComponentManager == NULL)
430 {
431 compMgr = new nsComponentManagerImpl();
432 if (compMgr == NULL)
433 return NS_ERROR_OUT_OF_MEMORY;
434 NS_ADDREF(compMgr);
435
436 nsCOMPtr<nsIFile> xpcomLib;
437
438 PRBool value;
439 if (binDirectory)
440 {
441 rv = binDirectory->IsDirectory(&value);
442
443 if (NS_SUCCEEDED(rv) && value) {
444 gDirectoryService->Set(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, binDirectory);
445 binDirectory->Clone(getter_AddRefs(xpcomLib));
446 }
447 }
448 else {
449 gDirectoryService->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
450 NS_GET_IID(nsIFile),
451 getter_AddRefs(xpcomLib));
452 }
453
454 if (xpcomLib) {
455 xpcomLib->AppendNative(nsDependentCString(XPCOM_DLL));
456 gDirectoryService->Set(NS_XPCOM_LIBRARY_FILE, xpcomLib);
457 }
458
459 if (appFileLocationProvider) {
460 rv = dirService->RegisterProvider(appFileLocationProvider);
461 if (NS_FAILED(rv)) return rv;
462 }
463
464 rv = compMgr->Init();
465 if (NS_FAILED(rv))
466 {
467 NS_RELEASE(compMgr);
468 return rv;
469 }
470
471 nsComponentManagerImpl::gComponentManager = compMgr;
472
473 if (result) {
474 nsIServiceManager *serviceManager =
475 NS_STATIC_CAST(nsIServiceManager*, compMgr);
476
477 NS_ADDREF(*result = serviceManager);
478 }
479 }
480
481 rv = compMgr->RegisterService(kComponentManagerCID, NS_STATIC_CAST(nsIComponentManager*, compMgr));
482 if (NS_FAILED(rv)) return rv;
483
484 // 2. Register the global services with the component manager so that
485 // clients can create new objects.
486
487 // Category Manager
488 {
489 nsCOMPtr<nsIFactory> categoryManagerFactory;
490 if ( NS_FAILED(rv = NS_CategoryManagerGetFactory(getter_AddRefs(categoryManagerFactory))) )
491 return rv;
492
493 NS_DEFINE_CID(kCategoryManagerCID, NS_CATEGORYMANAGER_CID);
494
495 rv = compMgr->RegisterFactory(kCategoryManagerCID,
496 NS_CATEGORYMANAGER_CLASSNAME,
497 NS_CATEGORYMANAGER_CONTRACTID,
498 categoryManagerFactory,
499 PR_TRUE);
500 if ( NS_FAILED(rv) ) return rv;
501 }
502
503 // what I want to do here is QI for a Component Registration Manager. Since this
504 // has not been invented yet, QI to the obsolete manager. Kids, don't do this at home.
505 nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(
506 NS_STATIC_CAST(nsIComponentManager*,compMgr), &rv);
507 if (registrar) {
508 for (int i = 0; i < components_length; i++)
509 RegisterGenericFactory(registrar, &components[i]);
510 }
511 rv = nsComponentManagerImpl::gComponentManager->ReadPersistentRegistry();
512#ifdef DEBUG
513 if (NS_FAILED(rv)) {
514 printf("No Persistent Registry Found.\n");
515 }
516#endif
517
518#if 0 /// @todo later
519 rv = IPC_Init();
520 if (NS_FAILED(rv))
521 return rv;
522#endif
523
524 if ( NS_FAILED(rv) || CheckUpdateFile()) {
525 // if we find no persistent registry, we will try to autoregister
526 // the default components directory.
527 nsComponentManagerImpl::gComponentManager->AutoRegister(nsnull);
528
529 // If the application is using a GRE, then,
530 // auto register components in the GRE directory as well.
531 //
532 // The application indicates that it's using an GRE by
533 // returning a valid nsIFile when queried (via appFileLocProvider)
534 // for the NS_GRE_DIR atom as shown below
535 //
536
537 if ( appFileLocationProvider ) {
538 nsCOMPtr<nsIFile> greDir;
539 PRBool persistent = PR_TRUE;
540
541 appFileLocationProvider->GetFile(NS_GRE_DIR, &persistent, getter_AddRefs(greDir));
542
543 if (greDir) {
544#ifdef DEBUG_dougt
545 printf("start - Registering GRE components\n");
546#endif
547 rv = gDirectoryService->Get(NS_GRE_COMPONENT_DIR,
548 NS_GET_IID(nsIFile),
549 getter_AddRefs(greDir));
550 if (NS_FAILED(rv)) {
551 NS_ERROR("Could not get GRE components directory!");
552 return rv;
553 }
554
555 // If the GRE contains any loaders, we want to know about it so that we can cause another
556 // autoregistration of the applications component directory.
557 int loaderCount = nsComponentManagerImpl::gComponentManager->GetLoaderCount();
558 rv = nsComponentManagerImpl::gComponentManager->AutoRegister(greDir);
559
560 if (loaderCount != nsComponentManagerImpl::gComponentManager->GetLoaderCount())
561 nsComponentManagerImpl::gComponentManager->AutoRegisterNonNativeComponents(nsnull);
562
563#ifdef DEBUG_dougt
564 printf("end - Registering GRE components\n");
565#endif
566 if (NS_FAILED(rv)) {
567 NS_ERROR("Could not AutoRegister GRE components");
568 return rv;
569 }
570 }
571 }
572
573 //
574 // If additional component directories have been specified, then
575 // register them as well.
576 //
577
578 nsCOMPtr<nsISimpleEnumerator> dirList;
579 gDirectoryService->Get(NS_XPCOM_COMPONENT_DIR_LIST,
580 NS_GET_IID(nsISimpleEnumerator),
581 getter_AddRefs(dirList));
582 if (dirList) {
583 PRBool hasMore;
584 while (NS_SUCCEEDED(dirList->HasMoreElements(&hasMore)) && hasMore) {
585 nsCOMPtr<nsISupports> elem;
586 dirList->GetNext(getter_AddRefs(elem));
587 if (elem) {
588 nsCOMPtr<nsIFile> dir = do_QueryInterface(elem);
589 if (dir)
590 nsComponentManagerImpl::gComponentManager->AutoRegister(dir);
591
592 // XXX should we worry about new component loaders being
593 // XXX defined by this process?
594 }
595 }
596 }
597
598
599 // Make sure the compreg file's mod time is current.
600 nsCOMPtr<nsIFile> compregFile;
601 rv = gDirectoryService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE,
602 NS_GET_IID(nsIFile),
603 getter_AddRefs(compregFile));
604 RTTIMESPEC Time;
605 RTTimeNow(&Time);
606 compregFile->SetLastModifiedTime(RTTimeSpecGetMilli(&Time));
607 }
608
609 // Pay the cost at startup time of starting this singleton.
610 nsIInterfaceInfoManager* iim = XPTI_GetInterfaceInfoManager();
611 NS_IF_RELEASE(iim);
612#ifdef VBOX
613 // Must initialize the EventQueueService singleton before anyone is
614 // using it. The notification below creates a thread which races creating
615 // the EventQueueService creation otherwise, no matter what.
616 nsCOMPtr<nsIEventQueue> eventQ;
617 rv = NS_GetMainEventQ(getter_AddRefs(eventQ));
618 if (NS_FAILED(rv)) {
619 NS_ERROR("Could not create event queue for main thread");
620 /* this is just a build-time hack, to reference NS_ProxyRelease */
621 if (rv == 666)
622 NS_ProxyRelease(nsnull, nsnull);
623 return rv;
624 }
625#endif /* VBOX */
626
627 // Notify observers of xpcom autoregistration start
628 NS_CreateServicesFromCategory(NS_XPCOM_STARTUP_OBSERVER_ID,
629 nsnull,
630 NS_XPCOM_STARTUP_OBSERVER_ID);
631
632#ifdef VBOX
633 gXPCOMInitialized = PR_TRUE;
634#endif
635 return NS_OK;
636}
637
638
639static nsVoidArray* gExitRoutines;
640
641static void CallExitRoutines()
642{
643 if (!gExitRoutines)
644 return;
645
646 PRInt32 count = gExitRoutines->Count();
647 for (PRInt32 i = 0; i < count; i++) {
648 XPCOMExitRoutine func = (XPCOMExitRoutine) gExitRoutines->ElementAt(i);
649 func();
650 }
651 gExitRoutines->Clear();
652 delete gExitRoutines;
653 gExitRoutines = nsnull;
654}
655
656nsresult NS_COM
657NS_RegisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine, PRUint32 priority)
658{
659 // priority are not used right now. It will need to be implemented as more
660 // classes are moved into the glue library --dougt
661 if (!gExitRoutines) {
662 gExitRoutines = new nsVoidArray();
663 if (!gExitRoutines) {
664 NS_WARNING("Failed to allocate gExitRoutines");
665 return NS_ERROR_FAILURE;
666 }
667 }
668
669 PRBool okay = gExitRoutines->AppendElement((void*)exitRoutine);
670 return okay ? NS_OK : NS_ERROR_FAILURE;
671}
672
673nsresult NS_COM
674NS_UnregisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine)
675{
676 if (!gExitRoutines)
677 return NS_ERROR_FAILURE;
678
679 PRBool okay = gExitRoutines->RemoveElement((void*)exitRoutine);
680 return okay ? NS_OK : NS_ERROR_FAILURE;
681}
682
683
684//
685// NS_ShutdownXPCOM()
686//
687// The shutdown sequence for xpcom would be
688//
689// - Release the Global Service Manager
690// - Release all service instances held by the global service manager
691// - Release the Global Service Manager itself
692// - Release the Component Manager
693// - Release all factories cached by the Component Manager
694// - Unload Libraries
695// - Release Contractid Cache held by Component Manager
696// - Release dll abstraction held by Component Manager
697// - Release the Registry held by Component Manager
698// - Finally, release the component manager itself
699//
700nsresult NS_COM NS_ShutdownXPCOM(nsIServiceManager* servMgr)
701{
702
703 // Notify observers of xpcom shutting down
704 nsresult rv = NS_OK;
705 {
706 // Block it so that the COMPtr will get deleted before we hit
707 // servicemanager shutdown
708 nsCOMPtr<nsIObserverService> observerService =
709 do_GetService("@mozilla.org/observer-service;1", &rv);
710 if (NS_SUCCEEDED(rv))
711 {
712 nsCOMPtr<nsIServiceManager> mgr;
713 rv = NS_GetServiceManager(getter_AddRefs(mgr));
714 if (NS_SUCCEEDED(rv))
715 {
716 (void) observerService->NotifyObservers(mgr,
717 NS_XPCOM_SHUTDOWN_OBSERVER_ID,
718 nsnull);
719 }
720 }
721 }
722
723 // grab the event queue so that we can process events one last time before exiting
724 nsCOMPtr <nsIEventQueue> currentQ;
725 {
726 nsCOMPtr<nsIEventQueueService> eventQService =
727 do_GetService(kEventQueueServiceCID, &rv);
728
729 if (eventQService) {
730 eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(currentQ));
731 }
732 }
733 // XPCOM is officially in shutdown mode NOW
734 // Set this only after the observers have been notified as this
735 // will cause servicemanager to become inaccessible.
736 gXPCOMShuttingDown = PR_TRUE;
737
738#ifdef DEBUG_dougt
739 fprintf(stderr, "* * * * XPCOM shutdown. Access will be denied * * * * \n");
740#endif
741
742#if 0 /// @todo later
743 IPC_Shutdown();
744#endif
745
746 // We may have AddRef'd for the caller of NS_InitXPCOM, so release it
747 // here again:
748 NS_IF_RELEASE(servMgr);
749
750 // Shutdown global servicemanager
751 if (nsComponentManagerImpl::gComponentManager) {
752 nsComponentManagerImpl::gComponentManager->FreeServices();
753 }
754 nsServiceManager::ShutdownGlobalServiceManager(nsnull);
755
756 if (currentQ) {
757 currentQ->ProcessPendingEvents();
758 currentQ = 0;
759 }
760
761 nsProxyObjectManager::Shutdown();
762
763 // Release the directory service
764 NS_IF_RELEASE(gDirectoryService);
765
766 // Shutdown nsLocalFile string conversion
767 NS_ShutdownLocalFile();
768#ifdef XP_UNIX
769 NS_ShutdownNativeCharsetUtils();
770#endif
771
772 CallExitRoutines();
773
774 // Shutdown xpcom. This will release all loaders and cause others holding
775 // a refcount to the component manager to release it.
776 if (nsComponentManagerImpl::gComponentManager) {
777 rv = (nsComponentManagerImpl::gComponentManager)->Shutdown();
778 NS_ASSERTION(NS_SUCCEEDED(rv), "Component Manager shutdown failed.");
779 } else
780 NS_WARNING("Component Manager was never created ...");
781
782 // Release our own singletons
783 // Do this _after_ shutting down the component manager, because the
784 // JS component loader will use XPConnect to call nsIModule::canUnload,
785 // and that will spin up the InterfaceInfoManager again -- bad mojo
786 XPTI_FreeInterfaceInfoManager();
787
788 // Finally, release the component manager last because it unloads the
789 // libraries:
790 if (nsComponentManagerImpl::gComponentManager) {
791 nsrefcnt cnt;
792 NS_RELEASE2(nsComponentManagerImpl::gComponentManager, cnt);
793 NS_WARN_IF_FALSE(cnt == 0, "Component Manager being held past XPCOM shutdown.");
794 }
795 nsComponentManagerImpl::gComponentManager = nsnull;
796
797 ShutdownSpecialSystemDirectory();
798
799 EmptyEnumeratorImpl::Shutdown();
800
801 NS_PurgeAtomTable();
802
803 NS_IF_RELEASE(gDebug);
804
805#ifdef NS_BUILD_REFCNT_LOGGING
806 nsTraceRefcntImpl::DumpStatistics();
807 nsTraceRefcntImpl::ResetStatistics();
808 nsTraceRefcntImpl::Shutdown();
809#endif
810
811#ifdef VBOX
812 gXPCOMInitialized = PR_FALSE;
813#endif
814 return NS_OK;
815}
816
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use