xpcom/components/nsComponentManager.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef nsComponentManager_h__
   7 #define nsComponentManager_h__
   8
   9 #include "nsXPCOM.h"
  10
  11 #include "xpcom-private.h"
  12 #include "nsIComponentManager.h"
  13 #include "nsIComponentRegistrar.h"
  14 #include "nsIMemoryReporter.h"
  15 #include "nsIServiceManager.h"
  16 #include "nsIFile.h"
  17 #include "mozilla/MemoryReporting.h"
  18 #include "mozilla/Module.h"
  19 #include "mozilla/ModuleLoader.h"
  20 #include "mozilla/Mutex.h"
  21 #include "nsXULAppAPI.h"
  22 #include "nsNativeModuleLoader.h"
  23 #include "nsIFactory.h"
  24 #include "nsIInterfaceRequestor.h"
  25 #include "nsIInterfaceRequestorUtils.h"
  26 #include "pldhash.h"
  27 #include "prtime.h"
  28 #include "nsCOMPtr.h"
  29 #include "nsAutoPtr.h"
  30 #include "nsWeakReference.h"
  31 #include "plarena.h"
  32 #include "nsCOMArray.h"
  33 #include "nsDataHashtable.h"
  34 #include "nsInterfaceHashtable.h"
  35 #include "nsClassHashtable.h"
  36 #include "nsTArray.h"
  37
  38 #include "mozilla/Omnijar.h"
  39 #include "mozilla/Attributes.h"
  40
  41 #ifdef MOZ_B2G_LOADER
  42 #include "mozilla/FileLocation.h"
  43 #endif
  44
  45 struct nsFactoryEntry;
  46 class nsIServiceManager;
  47 struct PRThread;
  48
  49 #define NS_COMPONENTMANAGER_CID                      \
  50 { /* 91775d60-d5dc-11d2-92fb-00e09805570f */         \
  51     0x91775d60,                                      \
  52     0xd5dc,                                          \
  53     0x11d2,                                          \
  54     {0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f} \
  55 }
  56
  57 /* keys for registry use */
  58 extern const char xpcomKeyName[];
  59 extern const char xpcomComponentsKeyName[];
  60 extern const char lastModValueName[];
  61 extern const char fileSizeValueName[];
  62 extern const char nativeComponentType[];
  63 extern const char staticComponentType[];
  64
  65 #ifdef DEBUG
  66 #define XPCOM_CHECK_PENDING_CIDS
  67 #endif
  68 ////////////////////////////////////////////////////////////////////////////////
  69
  70 extern const mozilla::Module kXPCOMModule;
  71
  72 /**
  73  * This is a wrapper around mozilla::Mutex which provides runtime
  74  * checking for a deadlock where the same thread tries to lock a mutex while
  75  * it is already locked. This checking is present in both debug and release
  76  * builds.
  77  */
  78 class SafeMutex
  79 {
  80 public:
  81   explicit SafeMutex(const char* aName)
  82     : mMutex(aName)
  83     , mOwnerThread(nullptr)
  84   {
  85   }
  86
  87   ~SafeMutex() {}
  88
  89   void Lock()
  90   {
  91     AssertNotCurrentThreadOwns();
  92     mMutex.Lock();
  93     MOZ_ASSERT(mOwnerThread == nullptr);
  94     mOwnerThread = PR_GetCurrentThread();
  95   }
  96
  97   void Unlock()
  98   {
  99     MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
 100     mOwnerThread = nullptr;
 101     mMutex.Unlock();
 102   }
 103
 104   void AssertCurrentThreadOwns() const
 105   {
 106     // This method is a debug-only check
 107     MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
 108   }
 109
 110   MOZ_NEVER_INLINE void AssertNotCurrentThreadOwns() const
 111   {
 112     // This method is a release-mode check
 113     if (PR_GetCurrentThread() == mOwnerThread) {
 114       MOZ_CRASH();
 115     }
 116   }
 117
 118 private:
 119   mozilla::Mutex mMutex;
 120   volatile PRThread* mOwnerThread;
 121 };
 122
 123 typedef mozilla::BaseAutoLock<SafeMutex> SafeMutexAutoLock;
 124 typedef mozilla::BaseAutoUnlock<SafeMutex> SafeMutexAutoUnlock;
 125
 126 class nsComponentManagerImpl MOZ_FINAL
 127   : public nsIComponentManager
 128   , public nsIServiceManager
 129   , public nsSupportsWeakReference
 130   , public nsIComponentRegistrar
 131   , public nsIInterfaceRequestor
 132   , public nsIMemoryReporter
 133 {
 134 public:
 135   NS_DECL_THREADSAFE_ISUPPORTS
 136   NS_DECL_NSIINTERFACEREQUESTOR
 137   NS_DECL_NSICOMPONENTMANAGER
 138   NS_DECL_NSICOMPONENTREGISTRAR
 139   NS_DECL_NSIMEMORYREPORTER
 140
 141   static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 142
 143   nsresult RegistryLocationForFile(nsIFile* aFile,
 144                                    nsCString& aResult);
 145   nsresult FileForRegistryLocation(const nsCString& aLocation,
 146                                    nsIFile** aSpec);
 147
 148   NS_DECL_NSISERVICEMANAGER
 149
 150   // nsComponentManagerImpl methods:
 151   nsComponentManagerImpl();
 152
 153   static nsComponentManagerImpl* gComponentManager;
 154   nsresult Init();
 155
 156   nsresult Shutdown(void);
 157
 158   nsresult FreeServices();
 159
 160   already_AddRefed<mozilla::ModuleLoader> LoaderForExtension(const nsACString& aExt);
 161   nsInterfaceHashtable<nsCStringHashKey, mozilla::ModuleLoader> mLoaderMap;
 162
 163   already_AddRefed<nsIFactory> FindFactory(const nsCID& aClass);
 164   already_AddRefed<nsIFactory> FindFactory(const char* aContractID,
 165                                            uint32_t aContractIDLen);
 166
 167   already_AddRefed<nsIFactory> LoadFactory(nsFactoryEntry* aEntry);
 168
 169   nsFactoryEntry* GetFactoryEntry(const char* aContractID,
 170                                   uint32_t aContractIDLen);
 171   nsFactoryEntry* GetFactoryEntry(const nsCID& aClass);
 172
 173   nsDataHashtable<nsIDHashKey, nsFactoryEntry*> mFactories;
 174   nsDataHashtable<nsCStringHashKey, nsFactoryEntry*> mContractIDs;
 175
 176   SafeMutex mLock;
 177
 178   static void InitializeStaticModules();
 179   static void InitializeModuleLocations();
 180
 181   struct ComponentLocation
 182   {
 183     NSLocationType type;
 184     mozilla::FileLocation location;
 185   };
 186
 187   class ComponentLocationComparator
 188   {
 189   public:
 190     bool Equals(const ComponentLocation& aA, const ComponentLocation& aB) const
 191     {
 192       return (aA.type == aB.type && aA.location.Equals(aB.location));
 193     }
 194   };
 195
 196   static nsTArray<const mozilla::Module*>* sStaticModules;
 197   static nsTArray<ComponentLocation>* sModuleLocations;
 198
 199   nsNativeModuleLoader mNativeModuleLoader;
 200
 201   class KnownModule
 202   {
 203   public:
 204     /**
 205      * Static or binary module.
 206      */
 207     KnownModule(const mozilla::Module* aModule, mozilla::FileLocation& aFile)
 208       : mModule(aModule)
 209       , mFile(aFile)
 210       , mLoaded(false)
 211       , mFailed(false)
 212     {
 213     }
 214
 215     explicit KnownModule(const mozilla::Module* aModule)
 216       : mModule(aModule)
 217       , mLoaded(false)
 218       , mFailed(false)
 219     {
 220     }
 221
 222     explicit KnownModule(mozilla::FileLocation& aFile)
 223       : mModule(nullptr)
 224       , mFile(aFile)
 225       , mLoader(nullptr)
 226       , mLoaded(false)
 227       , mFailed(false)
 228     {
 229     }
 230
 231     ~KnownModule()
 232     {
 233       if (mLoaded && mModule->unloadProc) {
 234         mModule->unloadProc();
 235       }
 236     }
 237
 238     bool EnsureLoader();
 239     bool Load();
 240
 241     const mozilla::Module* Module() const { return mModule; }
 242
 243     /**
 244      * For error logging, get a description of this module, either the
 245      * file path, or <static module>.
 246      */
 247     nsCString Description() const;
 248
 249   private:
 250     const mozilla::Module* mModule;
 251     mozilla::FileLocation mFile;
 252     nsCOMPtr<mozilla::ModuleLoader> mLoader;
 253     bool mLoaded;
 254     bool mFailed;
 255   };
 256
 257   // The KnownModule is kept alive by these members, it is
 258   // referenced by pointer from the factory entries.
 259   nsTArray<nsAutoPtr<KnownModule>> mKnownStaticModules;
 260   // The key is the URI string of the module
 261   nsClassHashtable<nsCStringHashKey, KnownModule> mKnownModules;
 262
 263   // Mutex not held
 264   void RegisterModule(const mozilla::Module* aModule,
 265                       mozilla::FileLocation* aFile);
 266
 267
 268   // Mutex held
 269   void RegisterCIDEntryLocked(const mozilla::Module::CIDEntry* aEntry,
 270                               KnownModule* aModule);
 271   void RegisterContractIDLocked(const mozilla::Module::ContractIDEntry* aEntry);
 272
 273   // Mutex not held
 274   void RegisterManifest(NSLocationType aType, mozilla::FileLocation& aFile,
 275                         bool aChromeOnly);
 276
 277   struct ManifestProcessingContext
 278   {
 279     ManifestProcessingContext(NSLocationType aType,
 280                               mozilla::FileLocation& aFile, bool aChromeOnly)
 281       : mType(aType)
 282       , mFile(aFile)
 283       , mChromeOnly(aChromeOnly)
 284     {
 285     }
 286
 287     ~ManifestProcessingContext() {}
 288
 289     NSLocationType mType;
 290     mozilla::FileLocation mFile;
 291     bool mChromeOnly;
 292   };
 293
 294   void ManifestManifest(ManifestProcessingContext& aCx, int aLineNo,
 295                         char* const* aArgv);
 296   void ManifestBinaryComponent(ManifestProcessingContext& aCx, int aLineNo,
 297                                char* const* aArgv);
 298   void ManifestXPT(ManifestProcessingContext& aCx, int aLineNo,
 299                    char* const* aArgv);
 300   void ManifestComponent(ManifestProcessingContext& aCx, int aLineNo,
 301                          char* const* aArgv);
 302   void ManifestContract(ManifestProcessingContext& aCx, int aLineNo,
 303                         char* const* aArgv);
 304   void ManifestCategory(ManifestProcessingContext& aCx, int aLineNo,
 305                         char* const* aArgv);
 306
 307   void RereadChromeManifests(bool aChromeOnly = true);
 308
 309   // Shutdown
 310   enum
 311   {
 312     NOT_INITIALIZED,
 313     NORMAL,
 314     SHUTDOWN_IN_PROGRESS,
 315     SHUTDOWN_COMPLETE
 316   } mStatus;
 317
 318   PLArenaPool   mArena;
 319
 320   struct PendingServiceInfo
 321   {
 322     const nsCID* cid;
 323     PRThread* thread;
 324   };
 325
 326   inline PendingServiceInfo* AddPendingService(const nsCID& aServiceCID,
 327                                                PRThread* aThread);
 328   inline void RemovePendingService(const nsCID& aServiceCID);
 329   inline PRThread* GetPendingServiceThread(const nsCID& aServiceCID) const;
 330
 331   nsTArray<PendingServiceInfo> mPendingServices;
 332
 333   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 334
 335 #ifdef MOZ_B2G_LOADER
 336   // Preload XPT interface info for B2G loader.
 337   // This function is called before XPCOM has been initialized.
 338   static void PreloadXPT(nsIFile* aFile);
 339 #endif
 340
 341 #ifdef MOZ_B2G_LOADER
 342   // Parsing functions of directives of manifest for XPT only parsing.
 343   struct XPTOnlyManifestProcessingContext
 344   {
 345     XPTOnlyManifestProcessingContext(mozilla::FileLocation& aFile)
 346       : mFile(aFile)
 347     {
 348     }
 349
 350     ~XPTOnlyManifestProcessingContext() {}
 351
 352     mozilla::FileLocation mFile;
 353   };
 354   static void XPTOnlyManifestManifest(XPTOnlyManifestProcessingContext& aCx,
 355                                       int aLineNo, char* const* aArgv);
 356   static void XPTOnlyManifestXPT(XPTOnlyManifestProcessingContext& aCx,
 357                                  int aLineNo, char* const* aArgv);
 358 #endif
 359
 360 private:
 361   ~nsComponentManagerImpl();
 362 };
 363
 364
 365 #define NS_MAX_FILENAME_LEN     1024
 366
 367 #define NS_ERROR_IS_DIR NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XPCOM, 24)
 368
 369 struct nsFactoryEntry
 370 {
 371   nsFactoryEntry(const mozilla::Module::CIDEntry* aEntry,
 372                  nsComponentManagerImpl::KnownModule* aModule);
 373
 374   // nsIComponentRegistrar.registerFactory support
 375   nsFactoryEntry(const nsCID& aClass, nsIFactory* aFactory);
 376
 377   ~nsFactoryEntry();
 378
 379   already_AddRefed<nsIFactory> GetFactory();
 380
 381   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 382
 383   const mozilla::Module::CIDEntry* mCIDEntry;
 384   nsComponentManagerImpl::KnownModule* mModule;
 385
 386   nsCOMPtr<nsIFactory>   mFactory;
 387   nsCOMPtr<nsISupports>  mServiceObject;
 388 };
 389
 390 #endif // nsComponentManager_h__