xpcom/glue/nsComponentManagerUtils.cpp

   1 /* -*- Mode: C++; tab-width: 4; 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 nsXPCOM_h__
   7 #include "nsXPCOM.h"
   8 #endif
   9
  10 #ifndef nsCOMPtr_h__
  11 #include "nsCOMPtr.h"
  12 #endif
  13
  14 #include "nsComponentManagerUtils.h"
  15 #include "nsServiceManagerUtils.h"
  16
  17 #include "nsIComponentManager.h"
  18
  19 #ifndef MOZILLA_INTERNAL_API
  20
  21 nsresult
  22 CallGetService(const nsCID &aCID, const nsIID &aIID, void **aResult)
  23 {
  24     nsCOMPtr<nsIServiceManager> servMgr;
  25     nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
  26     if (servMgr)
  27         status = servMgr->GetService(aCID, aIID, aResult);
  28     return status;
  29 }
  30
  31 nsresult
  32 CallGetService(const char *aContractID, const nsIID &aIID, void **aResult)
  33 {
  34     nsCOMPtr<nsIServiceManager> servMgr;
  35     nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
  36     if (servMgr)
  37         status = servMgr->GetServiceByContractID(aContractID, aIID, aResult);
  38     return status;
  39 }
  40
  41 #else
  42
  43 #include "nsComponentManager.h"
  44
  45 nsresult
  46 CallGetService(const nsCID &aCID, const nsIID &aIID, void **aResult)
  47 {
  48     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
  49     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
  50
  51     return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);
  52 }
  53
  54 nsresult
  55 CallGetService(const char *aContractID, const nsIID &aIID, void **aResult)
  56 {
  57     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
  58     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
  59
  60     return compMgr->
  61         nsComponentManagerImpl::GetServiceByContractID(aContractID,
  62                                                        aIID, aResult);
  63 }
  64
  65 #endif
  66
  67 #ifndef MOZILLA_INTERNAL_API
  68
  69 nsresult
  70 CallCreateInstance(const nsCID &aCID, nsISupports *aDelegate,
  71                    const nsIID &aIID, void **aResult)
  72 {
  73     nsCOMPtr<nsIComponentManager> compMgr;
  74     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  75     if (compMgr)
  76         status = compMgr->CreateInstance(aCID, aDelegate, aIID, aResult);
  77     return status;
  78 }
  79
  80 nsresult
  81 CallCreateInstance(const char *aContractID, nsISupports *aDelegate,
  82                    const nsIID &aIID, void **aResult)
  83 {
  84     nsCOMPtr<nsIComponentManager> compMgr;
  85     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  86     if (compMgr)
  87         status = compMgr->CreateInstanceByContractID(aContractID, aDelegate,
  88                                                      aIID, aResult);
  89     return status;
  90 }
  91
  92 nsresult
  93 CallGetClassObject(const nsCID &aCID, const nsIID &aIID, void **aResult)
  94 {
  95     nsCOMPtr<nsIComponentManager> compMgr;
  96     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  97     if (compMgr)
  98         status = compMgr->GetClassObject(aCID, aIID, aResult);
  99     return status;
 100 }
 101
 102 nsresult
 103 CallGetClassObject(const char *aContractID, const nsIID &aIID, void **aResult)
 104 {
 105     nsCOMPtr<nsIComponentManager> compMgr;
 106     nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
 107     if (compMgr)
 108         status = compMgr->GetClassObjectByContractID(aContractID, aIID,
 109                                                      aResult);
 110     return status;
 111 }
 112
 113 #else
 114
 115 #include "nsComponentManager.h"
 116
 117 nsresult
 118 CallCreateInstance(const nsCID &aCID, nsISupports *aDelegate,
 119                    const nsIID &aIID, void **aResult)
 120 {
 121     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
 122     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 123
 124     return compMgr->
 125         nsComponentManagerImpl::CreateInstance(aCID, aDelegate, aIID, aResult);
 126 }
 127
 128 nsresult
 129 CallCreateInstance(const char *aContractID, nsISupports *aDelegate,
 130                    const nsIID &aIID, void **aResult)
 131 {
 132     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
 133     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 134
 135     return compMgr->
 136         nsComponentManagerImpl::CreateInstanceByContractID(aContractID,
 137                                                            aDelegate, aIID,
 138                                                            aResult);
 139 }
 140
 141 nsresult
 142 CallGetClassObject(const nsCID &aCID, const nsIID &aIID, void **aResult)
 143 {
 144     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
 145     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 146
 147     return compMgr->
 148         nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);
 149 }
 150
 151 nsresult
 152 CallGetClassObject(const char *aContractID, const nsIID &aIID, void **aResult)
 153 {
 154     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
 155     NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 156
 157     return compMgr->
 158         nsComponentManagerImpl::GetClassObjectByContractID(aContractID, aIID,
 159                                                            aResult);
 160 }
 161
 162 #endif
 163
 164 nsresult
 165 nsCreateInstanceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 166 {
 167     nsresult status = CallCreateInstance(mCID, mOuter, aIID, aInstancePtr);
 168     if ( NS_FAILED(status) )
 169         *aInstancePtr = 0;
 170     if ( mErrorPtr )
 171         *mErrorPtr = status;
 172     return status;
 173 }
 174
 175 nsresult
 176 nsCreateInstanceByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 177 {
 178     nsresult status = CallCreateInstance(mContractID, mOuter, aIID, aInstancePtr);
 179     if (NS_FAILED(status))
 180         *aInstancePtr = 0;
 181     if ( mErrorPtr )
 182         *mErrorPtr = status;
 183     return status;
 184 }
 185
 186 nsresult
 187 nsCreateInstanceFromFactory::operator()( const nsIID& aIID, void** aInstancePtr ) const
 188 {
 189     nsresult status = mFactory->CreateInstance(mOuter, aIID, aInstancePtr);
 190     if ( NS_FAILED(status) )
 191         *aInstancePtr = 0;
 192     if ( mErrorPtr )
 193         *mErrorPtr = status;
 194     return status;
 195 }
 196
 197
 198 nsresult
 199 nsGetClassObjectByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 200 {
 201     nsresult status = CallGetClassObject(mCID, aIID, aInstancePtr);
 202     if ( NS_FAILED(status) )
 203         *aInstancePtr = 0;
 204     if ( mErrorPtr )
 205         *mErrorPtr = status;
 206     return status;
 207 }
 208
 209 nsresult
 210 nsGetClassObjectByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 211 {
 212     nsresult status = CallGetClassObject(mContractID, aIID, aInstancePtr);
 213     if ( NS_FAILED(status) )
 214         *aInstancePtr = 0;
 215     if ( mErrorPtr )
 216         *mErrorPtr = status;
 217     return status;
 218 }
 219
 220
 221 nsresult
 222 nsGetServiceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 223 {
 224     nsresult status = CallGetService(mCID, aIID, aInstancePtr);
 225     if ( NS_FAILED(status) )
 226         *aInstancePtr = 0;
 227
 228     return status;
 229 }
 230
 231 nsresult
 232 nsGetServiceByCIDWithError::operator()( const nsIID& aIID, void** aInstancePtr ) const
 233 {
 234     nsresult status = CallGetService(mCID, aIID, aInstancePtr);
 235     if ( NS_FAILED(status) )
 236         *aInstancePtr = 0;
 237
 238     if ( mErrorPtr )
 239         *mErrorPtr = status;
 240     return status;
 241 }
 242
 243 nsresult
 244 nsGetServiceByContractID::operator()( const nsIID& aIID, void** aInstancePtr ) const
 245 {
 246     nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
 247     if ( NS_FAILED(status) )
 248         *aInstancePtr = 0;
 249
 250     return status;
 251 }
 252
 253 nsresult
 254 nsGetServiceByContractIDWithError::operator()( const nsIID& aIID, void** aInstancePtr ) const
 255 {
 256     nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
 257     if ( NS_FAILED(status) )
 258         *aInstancePtr = 0;
 259
 260     if ( mErrorPtr )
 261         *mErrorPtr = status;
 262     return status;
 263 }