SupportErrorInfo.cpp@ 26600

Last change on this file since 26600 was 26236, checked in by vboxsync, 15 years ago
Main: remove some dead errorinfo code
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 12.0 KB

Line
1	/* $Id: SupportErrorInfo.cpp 26236 2010-02-04 14:38:16Z vboxsync $ */
2
3	/** @file
4	* MS COM / XPCOM Abstraction Layer:
5	* SupportErrorInfo* class family implementations
6	*/
7
8	/*
9	* Copyright (C) 2008 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#include "VBox/com/SupportErrorInfo.h"
25
26	#include "VBox/com/ptr.h"
27	#include "VBox/com/VirtualBoxErrorInfo.h"
28
29	#include "../include/Logging.h"
30
31	#include <iprt/thread.h>
32
33	#if defined (VBOX_WITH_XPCOM)
34	# include <nsIServiceManager.h>
35	# include <nsIExceptionService.h>
36	#endif /* defined (VBOX_WITH_XPCOM) */
37
38	namespace com
39	{
40
41	// MultiResult methods
42	////////////////////////////////////////////////////////////////////////////////
43
44	RTTLS MultiResult::sCounter = NIL_RTTLS;
45
46	/static/
47	void MultiResult::incCounter()
48	{
49	if (sCounter == NIL_RTTLS)
50	{
51	sCounter = RTTlsAlloc();
52	AssertReturnVoid(sCounter != NIL_RTTLS);
53	}
54
55	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
56	++counter;
57	RTTlsSet(sCounter, (void*)counter);
58	}
59
60	/static/
61	void MultiResult::decCounter()
62	{
63	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
64	AssertReturnVoid(counter != 0);
65	--counter;
66	RTTlsSet(sCounter, (void*)counter);
67	}
68
69	// SupportErrorInfoBase methods
70	////////////////////////////////////////////////////////////////////////////////
71
72	/**
73	* Sets error info for the current thread. This is an internal function that
74	* gets eventually called by all public setError(), setWarning() and
75	* setErrorInfo() variants.
76	*
77	* The previous error info object (if any) will be preserved if the multi-error
78	* mode (see MultiResult) is turned on for the current thread.
79	*
80	* If @a aWarning is @c true, then the highest (31) bit in the @a aResultCode
81	* value which indicates the error severity is reset to zero to make sure the
82	* receiver will recognize that the created error info object represents a
83	* warning rather than an error.
84	*
85	* If @a aInfo is not NULL then all other paremeters are ignored and the given
86	* error info object is set on the current thread. Note that in this case, the
87	* existing error info object (if any) will be preserved by attaching it to the
88	* tail of the error chain of the given aInfo object in multi-error mode.
89	*
90	* If the error info is successfully set then this method returns aResultCode
91	* (or the result code returned as an output parameter of the
92	* aInfo->GetResultCode() call when @a aInfo is not NULL). This is done for
93	* conveinence: this way, setError() and friends may be used in return
94	* statements of COM method implementations.
95	*
96	* If setting error info fails then this method asserts and the failed result
97	* code is returned.
98	*/
99	/* static */
100	HRESULT SupportErrorInfoBase::setErrorInternal(HRESULT aResultCode,
101	const GUID *aIID,
102	const char *aComponent,
103	const Utf8Str &strText,
104	bool aWarning,
105	IVirtualBoxErrorInfo aInfo /= NULL*/)
106	{
107	/* whether multi-error mode is turned on */
108	bool preserve = ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
109
110	LogRel(("ERROR [COM]: aRC=%#08x aIID={%RTuuid} aComponent={%s} aText={%s} aWarning=%RTbool, aInfo=%p, preserve=%RTbool\n",
111	aResultCode,
112	aIID,
113	aComponent,
114	strText.c_str(),
115	aWarning,
116	aInfo,
117	preserve));
118
119	if (aInfo == NULL)
120	{
121	/* these are mandatory, others -- not */
122	AssertReturn((!aWarning && FAILED(aResultCode)) \|\|
123	(aWarning && aResultCode != S_OK),
124	E_FAIL);
125	AssertReturn(!strText.isEmpty(), E_FAIL);
126
127	/* reset the error severity bit if it's a warning */
128	if (aWarning)
129	aResultCode &= ~0x80000000;
130	}
131
132	HRESULT rc = S_OK;
133
134	do
135	{
136	ComPtr<IVirtualBoxErrorInfo> info;
137
138	#if !defined (VBOX_WITH_XPCOM)
139
140	ComPtr<IVirtualBoxErrorInfo> curInfo;
141	if (preserve)
142	{
143	/* get the current error info if any */
144	ComPtr<IErrorInfo> err;
145	rc = ::GetErrorInfo(0, err.asOutParam());
146	if (FAILED(rc)) break;
147	rc = err.queryInterfaceTo(curInfo.asOutParam());
148	if (FAILED(rc))
149	{
150	/* create a IVirtualBoxErrorInfo wrapper for the native
151	* IErrorInfo object */
152	ComObjPtr<VirtualBoxErrorInfo> wrapper;
153	rc = wrapper.createObject();
154	if (SUCCEEDED(rc))
155	{
156	rc = wrapper->init(err);
157	if (SUCCEEDED(rc))
158	curInfo = wrapper;
159	}
160	}
161	}
162	/* On failure, curInfo will stay null */
163	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
164
165	/* set the current error info and preserve the previous one if any */
166	if (aInfo != NULL)
167	{
168	if (curInfo.isNull())
169	{
170	info = aInfo;
171	}
172	else
173	{
174	ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
175	rc = infoObj.createObject();
176	if (FAILED(rc)) break;
177
178	rc = infoObj->init(aInfo, curInfo);
179	if (FAILED(rc)) break;
180
181	info = infoObj;
182	}
183
184	/* we want to return the head's result code */
185	rc = info->COMGETTER(ResultCode)(&aResultCode);
186	if (FAILED(rc)) break;
187	}
188	else
189	{
190	ComObjPtr<VirtualBoxErrorInfo> infoObj;
191	rc = infoObj.createObject();
192	if (FAILED(rc)) break;
193
194	rc = infoObj->init(aResultCode, aIID, aComponent, strText.c_str(), curInfo);
195	if (FAILED(rc)) break;
196
197	info = infoObj;
198	}
199
200	ComPtr<IErrorInfo> err;
201	rc = info.queryInterfaceTo(err.asOutParam());
202	if (SUCCEEDED(rc))
203	rc = ::SetErrorInfo(0, err);
204
205	#else // !defined (VBOX_WITH_XPCOM)
206
207	nsCOMPtr <nsIExceptionService> es;
208	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
209	if (NS_SUCCEEDED(rc))
210	{
211	nsCOMPtr <nsIExceptionManager> em;
212	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
213	if (FAILED(rc)) break;
214
215	ComPtr<IVirtualBoxErrorInfo> curInfo;
216	if (preserve)
217	{
218	/* get the current error info if any */
219	ComPtr<nsIException> ex;
220	rc = em->GetCurrentException(ex.asOutParam());
221	if (FAILED(rc)) break;
222	rc = ex.queryInterfaceTo(curInfo.asOutParam());
223	if (FAILED(rc))
224	{
225	/* create a IVirtualBoxErrorInfo wrapper for the native
226	* nsIException object */
227	ComObjPtr<VirtualBoxErrorInfo> wrapper;
228	rc = wrapper.createObject();
229	if (SUCCEEDED(rc))
230	{
231	rc = wrapper->init(ex);
232	if (SUCCEEDED(rc))
233	curInfo = wrapper;
234	}
235	}
236	}
237	/* On failure, curInfo will stay null */
238	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
239
240	/* set the current error info and preserve the previous one if any */
241	if (aInfo != NULL)
242	{
243	if (curInfo.isNull())
244	{
245	info = aInfo;
246	}
247	else
248	{
249	ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
250	rc = infoObj.createObject();
251	if (FAILED(rc)) break;
252
253	rc = infoObj->init(aInfo, curInfo);
254	if (FAILED(rc)) break;
255
256	info = infoObj;
257	}
258
259	/* we want to return the head's result code */
260	PRInt32 lrc;
261	rc = info->COMGETTER(ResultCode)(&lrc); aResultCode = lrc;
262	if (FAILED(rc)) break;
263	}
264	else
265	{
266	ComObjPtr<VirtualBoxErrorInfo> infoObj;
267	rc = infoObj.createObject();
268	if (FAILED(rc)) break;
269
270	rc = infoObj->init(aResultCode, aIID, aComponent, strText, curInfo);
271	if (FAILED(rc)) break;
272
273	info = infoObj;
274	}
275
276	ComPtr<nsIException> ex;
277	rc = info.queryInterfaceTo(ex.asOutParam());
278	if (SUCCEEDED(rc))
279	rc = em->SetCurrentException(ex);
280	}
281	else if (rc == NS_ERROR_UNEXPECTED)
282	{
283	/*
284	* It is possible that setError() is being called by the object
285	* after the XPCOM shutdown sequence has been initiated
286	* (for example, when XPCOM releases all instances it internally
287	* references, which can cause object's FinalConstruct() and then
288	* uninit()). In this case, do_GetService() above will return
289	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
290	* set the exception (nobody will be able to read it).
291	*/
292	LogWarningFunc (("Will not set an exception because "
293	"nsIExceptionService is not available "
294	"(NS_ERROR_UNEXPECTED). "
295	"XPCOM is being shutdown?\n"));
296	rc = NS_OK;
297	}
298
299	#endif // !defined (VBOX_WITH_XPCOM)
300	}
301	while (0);
302
303	AssertComRC(rc);
304
305	return SUCCEEDED(rc) ? aResultCode : rc;
306	}
307
308	/* static */
309	HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const GUID &aIID,
310	const char aComponent, const char aText,
311	...)
312	{
313	va_list args;
314	va_start(args, aText);
315	HRESULT rc = setErrorV(aResultCode, aIID, aComponent, aText, args);
316	va_end(args);
317	return rc;
318	}
319
320	/* static */
321	HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const GUID &aIID,
322	const char aComponent, const char aText,
323	...)
324	{
325	va_list args;
326	va_start(args, aText);
327	HRESULT rc = setWarningV(aResultCode, aIID, aComponent, aText, args);
328	va_end(args);
329	return rc;
330	}
331
332	HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const char *aText, ...)
333	{
334	va_list args;
335	va_start(args, aText);
336	HRESULT rc = setErrorV(aResultCode, mainInterfaceID(), componentName(),
337	aText, args);
338	va_end(args);
339	return rc;
340	}
341
342	HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const char *aText, ...)
343	{
344	va_list args;
345	va_start(args, aText);
346	HRESULT rc = setWarningV(aResultCode, mainInterfaceID(), componentName(),
347	aText, args);
348	va_end(args);
349	return rc;
350	}
351
352	HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const GUID &aIID,
353	const char *aText, ...)
354	{
355	va_list args;
356	va_start(args, aText);
357	HRESULT rc = setErrorV(aResultCode, aIID, componentName(), aText, args);
358	va_end(args);
359	return rc;
360	}
361
362	HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const GUID &aIID,
363	const char *aText, ...)
364	{
365	va_list args;
366	va_start(args, aText);
367	HRESULT rc = setWarningV(aResultCode, aIID, componentName(), aText, args);
368	va_end(args);
369	return rc;
370	}
371
372	} /* namespace com */
373

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/glue/SupportErrorInfo.cpp@ 26600

Download in other formats: