/src/mozilla-central/xpcom/components/nsComponentManagerUtils.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsXPCOM_h__
#include "nsXPCOM.h"
#endif

#ifndef nsCOMPtr_h__
#include "nsCOMPtr.h"
#endif

#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"

#include "nsIComponentManager.h"

#ifndef MOZILLA_INTERNAL_API

nsresult
CallGetService(const nsCID& aCID, const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIServiceManager> servMgr;
  nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
  if (servMgr) {
    status = servMgr->GetService(aCID, aIID, aResult);
  }
  return status;
}

nsresult
CallGetService(const char* aContractID, const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIServiceManager> servMgr;
  nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
  if (servMgr) {
    status = servMgr->GetServiceByContractID(aContractID, aIID, aResult);
  }
  return status;
}

#else

#include "nsComponentManager.h"

nsresult
CallGetService(const nsCID& aCID, const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (!compMgr) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);
}

nsresult
CallGetService(const char* aContractID, const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (!compMgr) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return compMgr->nsComponentManagerImpl::GetServiceByContractID(aContractID,
                                                                 aIID,
                                                                 aResult);
}

#endif

#ifndef MOZILLA_INTERNAL_API

nsresult
CallCreateInstance(const nsCID& aCID, nsISupports* aDelegate,
                   const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIComponentManager> compMgr;
  nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  if (compMgr) {
    status = compMgr->CreateInstance(aCID, aDelegate, aIID, aResult);
  }
  return status;
}

nsresult
CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
                   const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIComponentManager> compMgr;
  nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  if (compMgr)
    status = compMgr->CreateInstanceByContractID(aContractID, aDelegate,
                                                 aIID, aResult);
  return status;
}

nsresult
CallGetClassObject(const nsCID& aCID, const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIComponentManager> compMgr;
  nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  if (compMgr) {
    status = compMgr->GetClassObject(aCID, aIID, aResult);
  }
  return status;
}

nsresult
CallGetClassObject(const char* aContractID, const nsIID& aIID, void** aResult)
{
  nsCOMPtr<nsIComponentManager> compMgr;
  nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
  if (compMgr)
    status = compMgr->GetClassObjectByContractID(aContractID, aIID,
                                                 aResult);
  return status;
}

#else

#include "nsComponentManager.h"

nsresult
CallCreateInstance(const nsCID& aCID, nsISupports* aDelegate,
                   const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (NS_WARN_IF(!compMgr)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return compMgr->nsComponentManagerImpl::CreateInstance(aCID, aDelegate, aIID,
                                                         aResult);
}

nsresult
CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
                   const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (NS_WARN_IF(!compMgr)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return
    compMgr->nsComponentManagerImpl::CreateInstanceByContractID(aContractID,
                                                                aDelegate, aIID,
                                                                aResult);
}

nsresult
CallGetClassObject(const nsCID& aCID, const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (NS_WARN_IF(!compMgr)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return compMgr->nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);
}

nsresult
CallGetClassObject(const char* aContractID, const nsIID& aIID, void** aResult)
{
  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
  if (NS_WARN_IF(!compMgr)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  return
    compMgr->nsComponentManagerImpl::GetClassObjectByContractID(aContractID,
                                                                aIID, aResult);
}

#endif

nsresult
nsCreateInstanceByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
{
  nsresult status = CallCreateInstance(mCID, nullptr, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }
  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}

nsresult
nsCreateInstanceByContractID::operator()(const nsIID& aIID,
                                         void** aInstancePtr) const
{
  nsresult status = CallCreateInstance(mContractID, nullptr, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }
  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}

nsresult
nsCreateInstanceFromFactory::operator()(const nsIID& aIID,
                                        void** aInstancePtr) const
{
  nsresult status = mFactory->CreateInstance(nullptr, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }
  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}


nsresult
nsGetClassObjectByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
{
  nsresult status = CallGetClassObject(mCID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }
  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}

nsresult
nsGetClassObjectByContractID::operator()(const nsIID& aIID,
                                         void** aInstancePtr) const
{
  nsresult status = CallGetClassObject(mContractID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }
  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}


nsresult
nsGetServiceByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
{
  nsresult status = CallGetService(mCID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }

  return status;
}

nsresult
nsGetServiceByCIDWithError::operator()(const nsIID& aIID,
                                       void** aInstancePtr) const
{
  nsresult status = CallGetService(mCID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }

  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}

nsresult
nsGetServiceByContractID::operator()(const nsIID& aIID,
                                     void** aInstancePtr) const
{
  nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }

  return status;
}

nsresult
nsGetServiceByContractIDWithError::operator()(const nsIID& aIID,
                                              void** aInstancePtr) const
{
  nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
  if (NS_FAILED(status)) {
    *aInstancePtr = 0;
  }

  if (mErrorPtr) {
    *mErrorPtr = status;
  }
  return status;
}

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
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		CallGetService(const nsCID& aCID, const nsIID& aIID, void** aResult)
50	9	{
51	9	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
52	9	if (!compMgr) {
53	0	return NS_ERROR_NOT_INITIALIZED;
54	0	}
55	9
56	9	return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);
57	9	}
58
59		nsresult
60		CallGetService(const char* aContractID, const nsIID& aIID, void** aResult)
61	2.51M	{
62	2.51M	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
63	2.51M	if (!compMgr) {
64	0	return NS_ERROR_NOT_INITIALIZED;
65	0	}
66	2.51M
67	2.51M	return compMgr->nsComponentManagerImpl::GetServiceByContractID(aContractID,
68	2.51M	aIID,
69	2.51M	aResult);
70	2.51M	}
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		CallCreateInstance(const nsCID& aCID, nsISupports* aDelegate,
128		const nsIID& aIID, void** aResult)
129	3	{
130	3	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
131	3	if (NS_WARN_IF(!compMgr)) {
132	0	return NS_ERROR_NOT_INITIALIZED;
133	0	}
134	3
135	3	return compMgr->nsComponentManagerImpl::CreateInstance(aCID, aDelegate, aIID,
136	3	aResult);
137	3	}
138
139		nsresult
140		CallCreateInstance(const char* aContractID, nsISupports* aDelegate,
141		const nsIID& aIID, void** aResult)
142	296k	{
143	296k	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
144	296k	if (NS_WARN_IF(!compMgr)) {
145	0	return NS_ERROR_NOT_INITIALIZED;
146	0	}
147	296k
148	296k	return
149	296k	compMgr->nsComponentManagerImpl::CreateInstanceByContractID(aContractID,
150	296k	aDelegate, aIID,
151	296k	aResult);
152	296k	}
153
154		nsresult
155		CallGetClassObject(const nsCID& aCID, const nsIID& aIID, void** aResult)
156	0	{
157	0	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
158	0	if (NS_WARN_IF(!compMgr)) {
159	0	return NS_ERROR_NOT_INITIALIZED;
160	0	}
161	0
162	0	return compMgr->nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);
163	0	}
164
165		nsresult
166		CallGetClassObject(const char* aContractID, const nsIID& aIID, void** aResult)
167	0	{
168	0	nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
169	0	if (NS_WARN_IF(!compMgr)) {
170	0	return NS_ERROR_NOT_INITIALIZED;
171	0	}
172	0
173	0	return
174	0	compMgr->nsComponentManagerImpl::GetClassObjectByContractID(aContractID,
175	0	aIID, aResult);
176	0	}
177
178		#endif
179
180		nsresult
181		nsCreateInstanceByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
182	3	{
183	3	nsresult status = CallCreateInstance(mCID, nullptr, aIID, aInstancePtr);
184	3	if (NS_FAILED(status)) {
185	0	*aInstancePtr = 0;
186	0	}
187	3	if (mErrorPtr) {
188	3	*mErrorPtr = status;
189	3	}
190	3	return status;
191	3	}
192
193		nsresult
194		nsCreateInstanceByContractID::operator()(const nsIID& aIID,
195		void** aInstancePtr) const
196	296k	{
197	296k	nsresult status = CallCreateInstance(mContractID, nullptr, aIID, aInstancePtr);
198	296k	if (NS_FAILED(status)) {
199	0	*aInstancePtr = 0;
200	0	}
201	296k	if (mErrorPtr) {
202	296k	*mErrorPtr = status;
203	296k	}
204	296k	return status;
205	296k	}
206
207		nsresult
208		nsCreateInstanceFromFactory::operator()(const nsIID& aIID,
209		void** aInstancePtr) const
210	0	{
211	0	nsresult status = mFactory->CreateInstance(nullptr, aIID, aInstancePtr);
212	0	if (NS_FAILED(status)) {
213	0	*aInstancePtr = 0;
214	0	}
215	0	if (mErrorPtr) {
216	0	*mErrorPtr = status;
217	0	}
218	0	return status;
219	0	}
220
221
222		nsresult
223		nsGetClassObjectByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
224	0	{
225	0	nsresult status = CallGetClassObject(mCID, aIID, aInstancePtr);
226	0	if (NS_FAILED(status)) {
227	0	*aInstancePtr = 0;
228	0	}
229	0	if (mErrorPtr) {
230	0	*mErrorPtr = status;
231	0	}
232	0	return status;
233	0	}
234
235		nsresult
236		nsGetClassObjectByContractID::operator()(const nsIID& aIID,
237		void** aInstancePtr) const
238	0	{
239	0	nsresult status = CallGetClassObject(mContractID, aIID, aInstancePtr);
240	0	if (NS_FAILED(status)) {
241	0	*aInstancePtr = 0;
242	0	}
243	0	if (mErrorPtr) {
244	0	*mErrorPtr = status;
245	0	}
246	0	return status;
247	0	}
248
249
250		nsresult
251		nsGetServiceByCID::operator()(const nsIID& aIID, void** aInstancePtr) const
252	6	{
253	6	nsresult status = CallGetService(mCID, aIID, aInstancePtr);
254	6	if (NS_FAILED(status)) {
255	0	*aInstancePtr = 0;
256	0	}
257	6
258	6	return status;
259	6	}
260
261		nsresult
262		nsGetServiceByCIDWithError::operator()(const nsIID& aIID,
263		void** aInstancePtr) const
264	0	{
265	0	nsresult status = CallGetService(mCID, aIID, aInstancePtr);
266	0	if (NS_FAILED(status)) {
267	0	*aInstancePtr = 0;
268	0	}
269	0
270	0	if (mErrorPtr) {
271	0	*mErrorPtr = status;
272	0	}
273	0	return status;
274	0	}
275
276		nsresult
277		nsGetServiceByContractID::operator()(const nsIID& aIID,
278		void** aInstancePtr) const
279	9.59k	{
280	9.59k	nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
281	9.59k	if (NS_FAILED(status)) {
282	0	*aInstancePtr = 0;
283	0	}
284	9.59k
285	9.59k	return status;
286	9.59k	}
287
288		nsresult
289		nsGetServiceByContractIDWithError::operator()(const nsIID& aIID,
290		void** aInstancePtr) const
291	55	{
292	55	nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
293	55	if (NS_FAILED(status)) {
294	0	*aInstancePtr = 0;
295	0	}
296	55
297	55	if (mErrorPtr) {
298	55	*mErrorPtr = status;
299	55	}
300	55	return status;
301	55	}