xpcom/components/nsComponentManagerUtils.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 nsComponentManagerUtils_h__
   8 #define nsComponentManagerUtils_h__
   9
  10 #include "nscore.h"
  11 #include "nsCOMPtr.h"
  12
  13 #include "nsIFactory.h"
  14
  15 nsresult CallCreateInstance(const nsCID& aClass, nsISupports* aDelegate,
  16                             const nsIID& aIID, void** aResult);
  17
  18 nsresult CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
  19                             const nsIID& aIID, void** aResult);
  20
  21 nsresult CallGetClassObject(const nsCID& aClass, const nsIID& aIID,
  22                             void** aResult);
  23
  24 nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
  25                             void** aResult);
  26
  27 class MOZ_STACK_CLASS nsCreateInstanceByCID final : public nsCOMPtr_helper {
  28  public:
  29   nsCreateInstanceByCID(const nsCID& aCID, nsresult* aErrorPtr)
  30       : mCID(aCID), mErrorPtr(aErrorPtr) {}
  31
  32   virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
  33
  34  private:
  35   const nsCID& mCID;
  36   nsresult* mErrorPtr;
  37 };
  38
  39 class MOZ_STACK_CLASS nsCreateInstanceByContractID final
  40     : public nsCOMPtr_helper {
  41  public:
  42   nsCreateInstanceByContractID(const char* aContractID, nsresult* aErrorPtr)
  43       : mContractID(aContractID), mErrorPtr(aErrorPtr) {}
  44
  45   virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
  46
  47  private:
  48   const char* mContractID;
  49   nsresult* mErrorPtr;
  50 };
  51
  52 class MOZ_STACK_CLASS nsCreateInstanceFromFactory final
  53     : public nsCOMPtr_helper {
  54  public:
  55   nsCreateInstanceFromFactory(nsIFactory* aFactory, nsresult* aErrorPtr)
  56       : mFactory(aFactory), mErrorPtr(aErrorPtr) {}
  57
  58   virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
  59
  60  private:
  61   nsIFactory* MOZ_NON_OWNING_REF mFactory;
  62   nsresult* mErrorPtr;
  63 };
  64
  65 inline const nsCreateInstanceByCID do_CreateInstance(const nsCID& aCID,
  66                                                      nsresult* aError = 0) {
  67   return nsCreateInstanceByCID(aCID, aError);
  68 }
  69
  70 inline const nsCreateInstanceByContractID do_CreateInstance(
  71     const char* aContractID, nsresult* aError = 0) {
  72   return nsCreateInstanceByContractID(aContractID, aError);
  73 }
  74
  75 inline const nsCreateInstanceFromFactory do_CreateInstance(
  76     nsIFactory* aFactory, nsresult* aError = 0) {
  77   return nsCreateInstanceFromFactory(aFactory, aError);
  78 }
  79
  80 class MOZ_STACK_CLASS nsGetClassObjectByCID final : public nsCOMPtr_helper {
  81  public:
  82   nsGetClassObjectByCID(const nsCID& aCID, nsresult* aErrorPtr)
  83       : mCID(aCID), mErrorPtr(aErrorPtr) {}
  84
  85   virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
  86
  87  private:
  88   const nsCID& mCID;
  89   nsresult* mErrorPtr;
  90 };
  91
  92 class MOZ_STACK_CLASS nsGetClassObjectByContractID final
  93     : public nsCOMPtr_helper {
  94  public:
  95   nsGetClassObjectByContractID(const char* aContractID, nsresult* aErrorPtr)
  96       : mContractID(aContractID), mErrorPtr(aErrorPtr) {}
  97
  98   virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
  99
 100  private:
 101   const char* mContractID;
 102   nsresult* mErrorPtr;
 103 };
 104
 105 /**
 106  * do_GetClassObject can be used to improve performance of callers
 107  * that call |CreateInstance| many times.  They can cache the factory
 108  * and call do_CreateInstance or CallCreateInstance with the cached
 109  * factory rather than having the component manager retrieve it every
 110  * time.
 111  */
 112 inline const nsGetClassObjectByCID do_GetClassObject(const nsCID& aCID,
 113                                                      nsresult* aError = 0) {
 114   return nsGetClassObjectByCID(aCID, aError);
 115 }
 116
 117 inline const nsGetClassObjectByContractID do_GetClassObject(
 118     const char* aContractID, nsresult* aError = 0) {
 119   return nsGetClassObjectByContractID(aContractID, aError);
 120 }
 121
 122 // type-safe shortcuts for calling |CreateInstance|
 123 template <class DestinationType>
 124 inline nsresult CallCreateInstance(const nsCID& aClass, nsISupports* aDelegate,
 125                                    DestinationType** aDestination) {
 126   MOZ_ASSERT(aDestination, "null parameter");
 127
 128   return CallCreateInstance(aClass, aDelegate,
 129                             NS_GET_TEMPLATE_IID(DestinationType),
 130                             reinterpret_cast<void**>(aDestination));
 131 }
 132
 133 template <class DestinationType>
 134 inline nsresult CallCreateInstance(const nsCID& aClass,
 135                                    DestinationType** aDestination) {
 136   MOZ_ASSERT(aDestination, "null parameter");
 137
 138   return CallCreateInstance(aClass, nullptr,
 139                             NS_GET_TEMPLATE_IID(DestinationType),
 140                             reinterpret_cast<void**>(aDestination));
 141 }
 142
 143 template <class DestinationType>
 144 inline nsresult CallCreateInstance(const char* aContractID,
 145                                    nsISupports* aDelegate,
 146                                    DestinationType** aDestination) {
 147   MOZ_ASSERT(aContractID, "null parameter");
 148   MOZ_ASSERT(aDestination, "null parameter");
 149
 150   return CallCreateInstance(aContractID, aDelegate,
 151                             NS_GET_TEMPLATE_IID(DestinationType),
 152                             reinterpret_cast<void**>(aDestination));
 153 }
 154
 155 template <class DestinationType>
 156 inline nsresult CallCreateInstance(const char* aContractID,
 157                                    DestinationType** aDestination) {
 158   MOZ_ASSERT(aContractID, "null parameter");
 159   MOZ_ASSERT(aDestination, "null parameter");
 160
 161   return CallCreateInstance(aContractID, nullptr,
 162                             NS_GET_TEMPLATE_IID(DestinationType),
 163                             reinterpret_cast<void**>(aDestination));
 164 }
 165
 166 template <class DestinationType>
 167 inline nsresult CallCreateInstance(nsIFactory* aFactory, nsISupports* aDelegate,
 168                                    DestinationType** aDestination) {
 169   MOZ_ASSERT(aFactory, "null parameter");
 170   MOZ_ASSERT(aDestination, "null parameter");
 171
 172   return aFactory->CreateInstance(aDelegate,
 173                                   NS_GET_TEMPLATE_IID(DestinationType),
 174                                   reinterpret_cast<void**>(aDestination));
 175 }
 176
 177 template <class DestinationType>
 178 inline nsresult CallCreateInstance(nsIFactory* aFactory,
 179                                    DestinationType** aDestination) {
 180   MOZ_ASSERT(aFactory, "null parameter");
 181   MOZ_ASSERT(aDestination, "null parameter");
 182
 183   return aFactory->CreateInstance(nullptr, NS_GET_TEMPLATE_IID(DestinationType),
 184                                   reinterpret_cast<void**>(aDestination));
 185 }
 186
 187 template <class DestinationType>
 188 inline nsresult CallGetClassObject(const nsCID& aClass,
 189                                    DestinationType** aDestination) {
 190   MOZ_ASSERT(aDestination, "null parameter");
 191
 192   return CallGetClassObject(aClass, NS_GET_TEMPLATE_IID(DestinationType),
 193                             reinterpret_cast<void**>(aDestination));
 194 }
 195
 196 template <class DestinationType>
 197 inline nsresult CallGetClassObject(const char* aContractID,
 198                                    DestinationType** aDestination) {
 199   MOZ_ASSERT(aDestination, "null parameter");
 200
 201   return CallGetClassObject(aContractID, NS_GET_TEMPLATE_IID(DestinationType),
 202                             reinterpret_cast<void**>(aDestination));
 203 }
 204
 205 #endif /* nsComponentManagerUtils_h__ */