xpcom/components/StaticComponents.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef StaticComponents_h
   8 #define StaticComponents_h
   9
  10 #include "mozilla/AlreadyAddRefed.h"
  11 #include "mozilla/Module.h"
  12 #include "mozilla/Span.h"
  13 #include "nsID.h"
  14 #include "nsStringFwd.h"
  15 #include "nscore.h"
  16
  17 #include "mozilla/Components.h"
  18 #include "StaticComponentData.h"
  19
  20 class nsIFactory;
  21 class nsIUTF8StringEnumerator;
  22 class nsISupports;
  23 template <typename T, size_t N>
  24 class AutoTArray;
  25
  26 namespace mozilla {
  27 namespace xpcom {
  28
  29 struct ContractEntry;
  30 struct StaticModule;
  31
  32 struct StaticCategoryEntry;
  33 struct StaticCategory;
  34
  35 struct StaticProtocolHandler;
  36
  37 extern const StaticModule gStaticModules[kStaticModuleCount];
  38
  39 extern const ContractEntry gContractEntries[kContractCount];
  40 extern uint8_t gInvalidContracts[kContractCount / 8 + 1];
  41
  42 extern const StaticCategory gStaticCategories[kStaticCategoryCount];
  43 extern const StaticCategoryEntry gStaticCategoryEntries[];
  44
  45 extern const StaticProtocolHandler
  46     gStaticProtocolHandlers[kStaticProtocolHandlerCount];
  47
  48 template <size_t N>
  49 static inline bool GetBit(const uint8_t (&aBits)[N], size_t aBit) {
  50   static constexpr size_t width = sizeof(aBits[0]) * 8;
  51
  52   size_t idx = aBit / width;
  53   MOZ_ASSERT(idx < N);
  54   return aBits[idx] & (1 << (aBit % width));
  55 }
  56
  57 template <size_t N>
  58 static inline void SetBit(uint8_t (&aBits)[N], size_t aBit,
  59                           bool aValue = true) {
  60   static constexpr size_t width = sizeof(aBits[0]) * 8;
  61
  62   size_t idx = aBit / width;
  63   MOZ_ASSERT(idx < N);
  64   if (aValue) {
  65     aBits[idx] |= 1 << (aBit % width);
  66   } else {
  67     aBits[idx] &= ~(1 << (aBit % width));
  68   }
  69 }
  70
  71 /**
  72  * Represents a string entry in the static string table. Can be converted to a
  73  * nsCString using GetString() in StaticComponents.cpp.
  74  *
  75  * This is a struct rather than a pure offset primarily for the purposes of type
  76  * safety, but also so that it can easily be extended to include a static length
  77  * in the future, if efficiency concerns warrant it.
  78  */
  79 struct StringOffset final {
  80   uint32_t mOffset;
  81 };
  82
  83 /**
  84  * Represents an offset into the interfaces table.
  85  */
  86 struct InterfaceOffset final {
  87   uint16_t mOffset;
  88 };
  89
  90 /**
  91  * Represents a static component entry defined in a `Classes` list in an XPCOM
  92  * manifest. Handles creating instances of and caching service instances for
  93  * that class.
  94  */
  95 struct StaticModule {
  96   nsID mCID;
  97   StringOffset mContractID;
  98   Module::ProcessSelector mProcessSelector;
  99
 100   const nsID& CID() const { return mCID; }
 101
 102   ModuleID ID() const { return ModuleID(this - gStaticModules); }
 103
 104   /**
 105    * Returns this entry's index in the gStaticModules array.
 106    */
 107   size_t Idx() const { return size_t(ID()); }
 108
 109   /**
 110    * Returns true if this component's corresponding contract ID is expected to
 111    * be overridden at runtime. If so, it should always be looked up by its
 112    * ContractID() when retrieving its service instance.
 113    */
 114   bool Overridable() const;
 115
 116   /**
 117    * If this entry is overridable, returns its associated contract ID string.
 118    * The component should always be looked up by this contract ID when
 119    * retrieving its service instance.
 120    *
 121    * Note: This may *only* be called if Overridable() returns true.
 122    */
 123   nsCString ContractID() const;
 124
 125   /**
 126    * Returns true if this entry is active. Typically this will only return false
 127    * if the entry's process selector does not match this process.
 128    */
 129   bool Active() const;
 130
 131   already_AddRefed<nsIFactory> GetFactory() const;
 132
 133   nsresult CreateInstance(const nsIID& aIID, void** aResult) const;
 134
 135   GetServiceHelper GetService() const;
 136   GetServiceHelper GetService(nsresult*) const;
 137
 138   nsISupports* ServiceInstance() const;
 139   void SetServiceInstance(already_AddRefed<nsISupports> aInst) const;
 140 };
 141
 142 /**
 143  * Represents a static mapping between a contract ID string and a StaticModule
 144  * entry.
 145  */
 146 struct ContractEntry final {
 147   StringOffset mContractID;
 148   ModuleID mModuleID;
 149
 150   size_t Idx() const { return this - gContractEntries; }
 151
 152   nsCString ContractID() const;
 153
 154   const StaticModule& Module() const {
 155     return gStaticModules[size_t(mModuleID)];
 156   }
 157
 158   /**
 159    * Returns true if this entry's underlying module is active, and its contract
 160    * ID matches the given contract ID string. This is used by the PerfectHash
 161    * function to determine whether to return a result for this entry.
 162    */
 163   bool Matches(const nsACString& aContractID) const;
 164
 165   /**
 166    * Returns true if this entry has been invalidated, and should be ignored.
 167    *
 168    * Contract IDs may be overwritten at runtime. When that happens for a static
 169    * contract ID, we mark its entry invalid, and ignore it thereafter.
 170    */
 171   bool Invalid() const { return GetBit(gInvalidContracts, Idx()); }
 172
 173   /**
 174    * Marks this entry invalid (or unsets the invalid bit if aInvalid is false),
 175    * after which it will be ignored in contract ID lookup attempts. See
 176    * `Invalid()` above.
 177    */
 178   void SetInvalid(bool aInvalid = true) const {
 179     return SetBit(gInvalidContracts, Idx(), aInvalid);
 180   }
 181 };
 182
 183 /**
 184  * Represents a declared category manager entry declared in an XPCOM manifest.
 185  *
 186  * The entire set of static category entries is read at startup and loaded into
 187  * the category manager's dynamic hash tables, so there is memory and
 188  * initialization overhead for each entry in these tables. This may be further
 189  * optimized in the future to reduce some of that overhead.
 190  */
 191 struct StaticCategoryEntry final {
 192   StringOffset mEntry;
 193   StringOffset mValue;
 194   Module::BackgroundTasksSelector mBackgroundTasksSelector;
 195   Module::ProcessSelector mProcessSelector;
 196
 197   nsCString Entry() const;
 198   nsCString Value() const;
 199   bool Active() const;
 200 };
 201
 202 struct StaticCategory final {
 203   StringOffset mName;
 204   uint16_t mStart;
 205   uint16_t mCount;
 206
 207   nsCString Name() const;
 208
 209   const StaticCategoryEntry* begin() const {
 210     return &gStaticCategoryEntries[mStart];
 211   }
 212   const StaticCategoryEntry* end() const {
 213     return &gStaticCategoryEntries[mStart + mCount];
 214   }
 215 };
 216
 217 struct JSServiceEntry final {
 218   using InterfaceList = AutoTArray<const nsIID*, 4>;
 219
 220   static const JSServiceEntry* Lookup(const nsACString& aName);
 221
 222   StringOffset mName;
 223   ModuleID mModuleID;
 224
 225   InterfaceOffset mInterfaceOffset;
 226
 227   uint8_t mInterfaceCount;
 228
 229   nsCString Name() const;
 230
 231   const StaticModule& Module() const {
 232     return gStaticModules[size_t(mModuleID)];
 233   }
 234
 235   InterfaceList Interfaces() const;
 236 };
 237
 238 struct StaticProtocolHandler final {
 239   static const StaticProtocolHandler* Lookup(const nsACString& aScheme);
 240   static const StaticProtocolHandler& Default() {
 241     return gStaticProtocolHandlers[kDefaultProtocolHandlerIndex];
 242   }
 243
 244   StringOffset mScheme;
 245   uint32_t mProtocolFlags;
 246   int32_t mDefaultPort;
 247   ModuleID mModuleID;
 248   bool mHasDynamicFlags;
 249
 250   nsCString Scheme() const;
 251
 252   const StaticModule& Module() const {
 253     return gStaticModules[size_t(mModuleID)];
 254   }
 255 };
 256
 257 class StaticComponents final {
 258  public:
 259   static const StaticModule* LookupByCID(const nsID& aCID);
 260
 261   static const StaticModule* LookupByContractID(const nsACString& aContractID);
 262
 263   /**
 264    * Marks a static contract ID entry invalid (or unsets the invalid bit if
 265    * aInvalid is false). See `CategoryEntry::Invalid()`.
 266    */
 267   static bool InvalidateContractID(const nsACString& aContractID,
 268                                    bool aInvalid = true);
 269
 270   static already_AddRefed<nsIUTF8StringEnumerator> GetComponentJSMs();
 271   static already_AddRefed<nsIUTF8StringEnumerator> GetComponentESModules();
 272
 273   static Span<const JSServiceEntry> GetJSServices();
 274
 275   /**
 276    * Calls any module unload from manifests whose components have been loaded.
 277    */
 278   static void Shutdown();
 279 };
 280
 281 }  // namespace xpcom
 282 }  // namespace mozilla
 283
 284 #endif  // defined StaticComponents_h