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