VirtualBoxBase.cpp@ 59090

Last change on this file since 59090 was 58132, checked in by vboxsync, 9 years ago
*: Doxygen fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.5 KB

Line
1	/* $Id: VirtualBoxBase.cpp 58132 2015-10-09 00:09:37Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM base classes implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2014 Oracle Corporation
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
20	#include <iprt/semaphore.h>
21	#include <iprt/asm.h>
22	#include <iprt/cpp/exception.h>
23
24	#include <typeinfo>
25
26	#if !defined(VBOX_WITH_XPCOM)
27	#include <windows.h>
28	#include <dbghelp.h>
29	#else /* !defined(VBOX_WITH_XPCOM) */
30	/// @todo remove when VirtualBoxErrorInfo goes away from here
31	#include <nsIServiceManager.h>
32	#include <nsIExceptionService.h>
33	#endif /* !defined(VBOX_WITH_XPCOM) */
34
35	#include "VirtualBoxBase.h"
36	#include "AutoCaller.h"
37	#include "VirtualBoxErrorInfoImpl.h"
38	#include "Logging.h"
39	#include "Global.h"
40
41	#include "VBox/com/ErrorInfo.h"
42	#include "VBox/com/MultiResult.h"
43
44	////////////////////////////////////////////////////////////////////////////////
45	//
46	// VirtualBoxBase
47	//
48	////////////////////////////////////////////////////////////////////////////////
49
50	VirtualBoxBase::VirtualBoxBase() : mState(this)
51	{
52	mObjectLock = NULL;
53	}
54
55	VirtualBoxBase::~VirtualBoxBase()
56	{
57	if (mObjectLock)
58	delete mObjectLock;
59	}
60
61	/**
62	* This virtual method returns an RWLockHandle that can be used to
63	* protect instance data. This RWLockHandle is generally referred to
64	* as the "object lock"; its locking class (for lock order validation)
65	* must be returned by another virtual method, getLockingClass(), which
66	* by default returns LOCKCLASS_OTHEROBJECT but is overridden by several
67	* subclasses such as VirtualBox, Host, Machine and others.
68	*
69	* On the first call this method lazily creates the RWLockHandle.
70	*
71	* @return
72	*/
73	/* virtual */
74	RWLockHandle *VirtualBoxBase::lockHandle() const
75	{
76	/* lazy initialization */
77	if (RT_LIKELY(mObjectLock))
78	return mObjectLock;
79
80	AssertCompile(sizeof(RWLockHandle ) == sizeof(void ));
81
82	// getLockingClass() is overridden by many subclasses to return
83	// one of the locking classes listed at the top of AutoLock.h
84	RWLockHandle *objLock = new RWLockHandle(getLockingClass());
85	if (!ASMAtomicCmpXchgPtr(&mObjectLock, objLock, NULL))
86	{
87	delete objLock;
88	objLock = ASMAtomicReadPtrT(&mObjectLock, RWLockHandle *);
89	}
90	return objLock;
91	}
92
93	/**
94	* Handles unexpected exceptions by turning them into COM errors in release
95	* builds or by hitting a breakpoint in the release builds.
96	*
97	* Usage pattern:
98	* @code
99	try
100	{
101	// ...
102	}
103	catch (LaLalA)
104	{
105	// ...
106	}
107	catch (...)
108	{
109	rc = VirtualBox::handleUnexpectedExceptions(this, RT_SRC_POS);
110	}
111	* @endcode
112	*
113	* @param aThis object where the exception happened
114	* @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
115	* */
116	/* static */
117	HRESULT VirtualBoxBase::handleUnexpectedExceptions(VirtualBoxBase *const aThis, RT_SRC_POS_DECL)
118	{
119	try
120	{
121	/* re-throw the current exception */
122	throw;
123	}
124	catch (const RTCError &err) // includes all XML exceptions
125	{
126	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
127	Utf8StrFmt(tr("%s.\n%s[%d] (%s)"),
128	err.what(),
129	pszFile, iLine, pszFunction).c_str(),
130	false /* aWarning */,
131	true /* aLogIt */);
132	}
133	catch (const std::exception &err)
134	{
135	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
136	Utf8StrFmt(tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
137	err.what(), typeid(err).name(),
138	pszFile, iLine, pszFunction).c_str(),
139	false /* aWarning */,
140	true /* aLogIt */);
141	}
142	catch (...)
143	{
144	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
145	Utf8StrFmt(tr("Unknown exception\n%s[%d] (%s)"),
146	pszFile, iLine, pszFunction).c_str(),
147	false /* aWarning */,
148	true /* aLogIt */);
149	}
150
151	/* should not get here */
152	AssertFailed();
153	return E_FAIL;
154	}
155
156	/**
157	* Sets error info for the current thread. This is an internal function that
158	* gets eventually called by all public variants. If @a aWarning is
159	* @c true, then the highest (31) bit in the @a aResultCode value which
160	* indicates the error severity is reset to zero to make sure the receiver will
161	* recognize that the created error info object represents a warning rather
162	* than an error.
163	*/
164	/* static */
165	HRESULT VirtualBoxBase::setErrorInternal(HRESULT aResultCode,
166	const GUID &aIID,
167	const char *pcszComponent,
168	Utf8Str aText,
169	bool aWarning,
170	bool aLogIt,
171	LONG aResultDetail /* = 0*/)
172	{
173	/* whether multi-error mode is turned on */
174	bool preserve = MultiResult::isMultiEnabled();
175
176	if (aLogIt)
177	LogRel(("%s [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%s} aText={%s}, preserve=%RTbool aResultDetail=%d\n",
178	aWarning ? "WARNING" : "ERROR",
179	aResultCode,
180	aResultCode,
181	&aIID,
182	pcszComponent,
183	aText.c_str(),
184	preserve,
185	aResultDetail));
186
187	/* these are mandatory, others -- not */
188	AssertReturn((!aWarning && FAILED(aResultCode)) \|\|
189	(aWarning && aResultCode != S_OK),
190	E_FAIL);
191
192	/* reset the error severity bit if it's a warning */
193	if (aWarning)
194	aResultCode &= ~0x80000000;
195
196	HRESULT rc = S_OK;
197
198	if (aText.isEmpty())
199	{
200	/* Some default info */
201	switch (aResultCode)
202	{
203	case E_INVALIDARG: aText = "A parameter has an invalid value"; break;
204	case E_POINTER: aText = "A parameter is an invalid pointer"; break;
205	case E_UNEXPECTED: aText = "The result of the operation is unexpected"; break;
206	case E_ACCESSDENIED: aText = "The access to an object is not allowed"; break;
207	case E_OUTOFMEMORY: aText = "The allocation of new memory failed"; break;
208	case E_NOTIMPL: aText = "The requested operation is not implemented"; break;
209	case E_NOINTERFACE: aText = "The requested interface is not implemented"; break;
210	case E_FAIL: aText = "A general error occurred"; break;
211	case E_ABORT: aText = "The operation was canceled"; break;
212	case VBOX_E_OBJECT_NOT_FOUND: aText = "Object corresponding to the supplied arguments does not exist"; break;
213	case VBOX_E_INVALID_VM_STATE: aText = "Current virtual machine state prevents the operation"; break;
214	case VBOX_E_VM_ERROR: aText = "Virtual machine error occurred attempting the operation"; break;
215	case VBOX_E_FILE_ERROR: aText = "File not accessible or erroneous file contents"; break;
216	case VBOX_E_IPRT_ERROR: aText = "Runtime subsystem error"; break;
217	case VBOX_E_PDM_ERROR: aText = "Pluggable Device Manager error"; break;
218	case VBOX_E_INVALID_OBJECT_STATE: aText = "Current object state prohibits operation"; break;
219	case VBOX_E_HOST_ERROR: aText = "Host operating system related error"; break;
220	case VBOX_E_NOT_SUPPORTED: aText = "Requested operation is not supported"; break;
221	case VBOX_E_XML_ERROR: aText = "Invalid XML found"; break;
222	case VBOX_E_INVALID_SESSION_STATE: aText = "Current session state prohibits operation"; break;
223	case VBOX_E_OBJECT_IN_USE: aText = "Object being in use prohibits operation"; break;
224	default: aText = "Unknown error"; break;
225	}
226	}
227
228	do
229	{
230	ComObjPtr<VirtualBoxErrorInfo> info;
231	rc = info.createObject();
232	if (FAILED(rc)) break;
233
234	#if !defined(VBOX_WITH_XPCOM)
235
236	ComPtr<IVirtualBoxErrorInfo> curInfo;
237	if (preserve)
238	{
239	/* get the current error info if any */
240	ComPtr<IErrorInfo> err;
241	rc = ::GetErrorInfo(0, err.asOutParam());
242	if (FAILED(rc)) break;
243	rc = err.queryInterfaceTo(curInfo.asOutParam());
244	if (FAILED(rc))
245	{
246	/* create a IVirtualBoxErrorInfo wrapper for the native
247	* IErrorInfo object */
248	ComObjPtr<VirtualBoxErrorInfo> wrapper;
249	rc = wrapper.createObject();
250	if (SUCCEEDED(rc))
251	{
252	rc = wrapper->init(err);
253	if (SUCCEEDED(rc))
254	curInfo = wrapper;
255	}
256	}
257	}
258	/* On failure, curInfo will stay null */
259	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
260
261	/* set the current error info and preserve the previous one if any */
262	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, aText, curInfo);
263	if (FAILED(rc)) break;
264
265	ComPtr<IErrorInfo> err;
266	rc = info.queryInterfaceTo(err.asOutParam());
267	if (SUCCEEDED(rc))
268	rc = ::SetErrorInfo(0, err);
269
270	#else // !defined(VBOX_WITH_XPCOM)
271
272	nsCOMPtr <nsIExceptionService> es;
273	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
274	if (NS_SUCCEEDED(rc))
275	{
276	nsCOMPtr <nsIExceptionManager> em;
277	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
278	if (FAILED(rc)) break;
279
280	ComPtr<IVirtualBoxErrorInfo> curInfo;
281	if (preserve)
282	{
283	/* get the current error info if any */
284	ComPtr<nsIException> ex;
285	rc = em->GetCurrentException(ex.asOutParam());
286	if (FAILED(rc)) break;
287	rc = ex.queryInterfaceTo(curInfo.asOutParam());
288	if (FAILED(rc))
289	{
290	/* create a IVirtualBoxErrorInfo wrapper for the native
291	* nsIException object */
292	ComObjPtr<VirtualBoxErrorInfo> wrapper;
293	rc = wrapper.createObject();
294	if (SUCCEEDED(rc))
295	{
296	rc = wrapper->init(ex);
297	if (SUCCEEDED(rc))
298	curInfo = wrapper;
299	}
300	}
301	}
302	/* On failure, curInfo will stay null */
303	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
304
305	/* set the current error info and preserve the previous one if any */
306	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, Bstr(aText), curInfo);
307	if (FAILED(rc)) break;
308
309	ComPtr<nsIException> ex;
310	rc = info.queryInterfaceTo(ex.asOutParam());
311	if (SUCCEEDED(rc))
312	rc = em->SetCurrentException(ex);
313	}
314	else if (rc == NS_ERROR_UNEXPECTED)
315	{
316	/*
317	* It is possible that setError() is being called by the object
318	* after the XPCOM shutdown sequence has been initiated
319	* (for example, when XPCOM releases all instances it internally
320	* references, which can cause object's FinalConstruct() and then
321	* uninit()). In this case, do_GetService() above will return
322	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
323	* set the exception (nobody will be able to read it).
324	*/
325	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
326	rc = NS_OK;
327	}
328
329	#endif // !defined(VBOX_WITH_XPCOM)
330	}
331	while (0);
332
333	AssertComRC(rc);
334
335	return SUCCEEDED(rc) ? aResultCode : rc;
336	}
337
338	/**
339	* Shortcut instance method to calling the static setErrorInternal with the
340	* class interface ID and component name inserted correctly. This uses the
341	* virtual getClassIID() and getComponentName() methods which are automatically
342	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
343	* @param aResultCode
344	* @param pcsz
345	* @return
346	*/
347	HRESULT VirtualBoxBase::setError(HRESULT aResultCode)
348	{
349	return setErrorInternal(aResultCode,
350	this->getClassIID(),
351	this->getComponentName(),
352	"",
353	false /* aWarning */,
354	true /* aLogIt */);
355	}
356
357	/**
358	* Shortcut instance method to calling the static setErrorInternal with the
359	* class interface ID and component name inserted correctly. This uses the
360	* virtual getClassIID() and getComponentName() methods which are automatically
361	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
362	* @param aResultCode
363	* @return
364	*/
365	HRESULT VirtualBoxBase::setError(HRESULT aResultCode, const char *pcsz, ...)
366	{
367	va_list args;
368	va_start(args, pcsz);
369	HRESULT rc = setErrorInternal(aResultCode,
370	this->getClassIID(),
371	this->getComponentName(),
372	Utf8Str(pcsz, args),
373	false /* aWarning */,
374	true /* aLogIt */);
375	va_end(args);
376	return rc;
377	}
378
379	/**
380	* Shortcut instance method to calling the static setErrorInternal with the
381	* class interface ID and component name inserted correctly. This uses the
382	* virtual getClassIID() and getComponentName() methods which are automatically
383	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
384	* @param ei
385	* @return
386	*/
387	HRESULT VirtualBoxBase::setError(const com::ErrorInfo &ei)
388	{
389	/* whether multi-error mode is turned on */
390	bool preserve = MultiResult::isMultiEnabled();
391
392	HRESULT rc = S_OK;
393
394	do
395	{
396	ComObjPtr<VirtualBoxErrorInfo> info;
397	rc = info.createObject();
398	if (FAILED(rc)) break;
399
400	#if !defined(VBOX_WITH_XPCOM)
401
402	ComPtr<IVirtualBoxErrorInfo> curInfo;
403	if (preserve)
404	{
405	/* get the current error info if any */
406	ComPtr<IErrorInfo> err;
407	rc = ::GetErrorInfo(0, err.asOutParam());
408	if (FAILED(rc)) break;
409	rc = err.queryInterfaceTo(curInfo.asOutParam());
410	if (FAILED(rc))
411	{
412	/* create a IVirtualBoxErrorInfo wrapper for the native
413	* IErrorInfo object */
414	ComObjPtr<VirtualBoxErrorInfo> wrapper;
415	rc = wrapper.createObject();
416	if (SUCCEEDED(rc))
417	{
418	rc = wrapper->init(err);
419	if (SUCCEEDED(rc))
420	curInfo = wrapper;
421	}
422	}
423	}
424	/* On failure, curInfo will stay null */
425	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
426
427	/* set the current error info and preserve the previous one if any */
428	rc = info->init(ei, curInfo);
429	if (FAILED(rc)) break;
430
431	ComPtr<IErrorInfo> err;
432	rc = info.queryInterfaceTo(err.asOutParam());
433	if (SUCCEEDED(rc))
434	rc = ::SetErrorInfo(0, err);
435
436	#else // !defined(VBOX_WITH_XPCOM)
437
438	nsCOMPtr <nsIExceptionService> es;
439	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
440	if (NS_SUCCEEDED(rc))
441	{
442	nsCOMPtr <nsIExceptionManager> em;
443	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
444	if (FAILED(rc)) break;
445
446	ComPtr<IVirtualBoxErrorInfo> curInfo;
447	if (preserve)
448	{
449	/* get the current error info if any */
450	ComPtr<nsIException> ex;
451	rc = em->GetCurrentException(ex.asOutParam());
452	if (FAILED(rc)) break;
453	rc = ex.queryInterfaceTo(curInfo.asOutParam());
454	if (FAILED(rc))
455	{
456	/* create a IVirtualBoxErrorInfo wrapper for the native
457	* nsIException object */
458	ComObjPtr<VirtualBoxErrorInfo> wrapper;
459	rc = wrapper.createObject();
460	if (SUCCEEDED(rc))
461	{
462	rc = wrapper->init(ex);
463	if (SUCCEEDED(rc))
464	curInfo = wrapper;
465	}
466	}
467	}
468	/* On failure, curInfo will stay null */
469	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
470
471	/* set the current error info and preserve the previous one if any */
472	rc = info->init(ei, curInfo);
473	if (FAILED(rc)) break;
474
475	ComPtr<nsIException> ex;
476	rc = info.queryInterfaceTo(ex.asOutParam());
477	if (SUCCEEDED(rc))
478	rc = em->SetCurrentException(ex);
479	}
480	else if (rc == NS_ERROR_UNEXPECTED)
481	{
482	/*
483	* It is possible that setError() is being called by the object
484	* after the XPCOM shutdown sequence has been initiated
485	* (for example, when XPCOM releases all instances it internally
486	* references, which can cause object's FinalConstruct() and then
487	* uninit()). In this case, do_GetService() above will return
488	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
489	* set the exception (nobody will be able to read it).
490	*/
491	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
492	rc = NS_OK;
493	}
494
495	#endif // !defined(VBOX_WITH_XPCOM)
496	}
497	while (0);
498
499	AssertComRC(rc);
500
501	return SUCCEEDED(rc) ? ei.getResultCode() : rc;
502	}
503
504	/**
505	* Converts the VBox status code a COM one and sets the error info.
506	*
507	* The VBox status code is made available to the API user via
508	* IVirtualBoxErrorInfo::resultDetail attribute.
509	*
510	* @param vrc The VBox status code.
511	* @return COM status code appropriate for @a vrc.
512	*
513	* @sa VirtualBoxBase::setError(HRESULT)
514	*/
515	HRESULT VirtualBoxBase::setErrorVrc(int vrc)
516	{
517	return setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
518	this->getClassIID(),
519	this->getComponentName(),
520	Utf8Str("%Rrc", vrc),
521	false /* aWarning */,
522	true /* aLogIt */,
523	vrc /* aResultDetail */);
524	}
525
526	/**
527	* Converts the VBox status code a COM one and sets the error info.
528	*
529	* @param vrc The VBox status code.
530	* @param pcszMsgFmt Error message format string.
531	* @param ... Argument specified in the @a pcszMsgFmt
532	* @return COM status code appropriate for @a vrc.
533	*
534	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
535	*/
536	HRESULT VirtualBoxBase::setErrorVrc(int vrc, const char *pcszMsgFmt, ...)
537	{
538	va_list va;
539	va_start(va, pcszMsgFmt);
540	HRESULT hrc = setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
541	this->getClassIID(),
542	this->getComponentName(),
543	Utf8Str(pcszMsgFmt, va),
544	false /* aWarning */,
545	true /* aLogIt */,
546	vrc /* aResultDetail */);
547	va_end(va);
548	return hrc;
549	}
550
551	/**
552	* Sets error info with both a COM status and an VBox status code.
553	*
554	* The VBox status code is made available to the API user via
555	* IVirtualBoxErrorInfo::resultDetail attribute.
556	*
557	* @param hrc The COM status code to return.
558	* @param vrc The VBox status code.
559	* @return Most likely @a hrc, see setErrorInternal.
560	*
561	* @sa VirtualBoxBase::setError(HRESULT)
562	*/
563	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc)
564	{
565	return setErrorInternal(hrc,
566	this->getClassIID(),
567	this->getComponentName(),
568	Utf8Str("%Rrc", vrc),
569	false /* aWarning */,
570	true /* aLogIt */,
571	vrc /* aResultDetail */);
572	}
573
574	/**
575	* Sets error info with a message and both a COM status and an VBox status code.
576	*
577	* The VBox status code is made available to the API user via
578	* IVirtualBoxErrorInfo::resultDetail attribute.
579	*
580	* @param hrc The COM status code to return.
581	* @param vrc The VBox status code.
582	* @param pcszMsgFmt Error message format string.
583	* @param ... Argument specified in the @a pcszMsgFmt
584	* @return Most likely @a hrc, see setErrorInternal.
585	*
586	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
587	*/
588	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc, const char *pcszMsgFmt, ...)
589	{
590	va_list va;
591	va_start(va, pcszMsgFmt);
592	hrc = setErrorInternal(hrc,
593	this->getClassIID(),
594	this->getComponentName(),
595	Utf8Str(pcszMsgFmt, va),
596	false /* aWarning */,
597	true /* aLogIt */,
598	vrc /* aResultDetail */);
599	va_end(va);
600	return hrc;
601	}
602
603	/**
604	* Like setError(), but sets the "warning" bit in the call to setErrorInternal().
605	* @param aResultCode
606	* @param pcsz
607	* @return
608	*/
609	HRESULT VirtualBoxBase::setWarning(HRESULT aResultCode, const char *pcsz, ...)
610	{
611	va_list args;
612	va_start(args, pcsz);
613	HRESULT rc = setErrorInternal(aResultCode,
614	this->getClassIID(),
615	this->getComponentName(),
616	Utf8Str(pcsz, args),
617	true /* aWarning */,
618	true /* aLogIt */);
619	va_end(args);
620	return rc;
621	}
622
623	/**
624	* Like setError(), but disables the "log" flag in the call to setErrorInternal().
625	* @param aResultCode
626	* @param pcsz
627	* @return
628	*/
629	HRESULT VirtualBoxBase::setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...)
630	{
631	va_list args;
632	va_start(args, pcsz);
633	HRESULT rc = setErrorInternal(aResultCode,
634	this->getClassIID(),
635	this->getComponentName(),
636	Utf8Str(pcsz, args),
637	false /* aWarning */,
638	false /* aLogIt */);
639	va_end(args);
640	return rc;
641	}
642
643	/**
644	* Clear the current error information.
645	*/
646	/static/
647	void VirtualBoxBase::clearError(void)
648	{
649	#if !defined(VBOX_WITH_XPCOM)
650	::SetErrorInfo(0, NULL);
651	#else
652	HRESULT rc = S_OK;
653	nsCOMPtr <nsIExceptionService> es;
654	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
655	if (NS_SUCCEEDED(rc))
656	{
657	nsCOMPtr <nsIExceptionManager> em;
658	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
659	if (SUCCEEDED(rc))
660	em->SetCurrentException(NULL);
661	}
662	#endif
663	}
664
665
666	////////////////////////////////////////////////////////////////////////////////
667	//
668	// MultiResult methods
669	//
670	////////////////////////////////////////////////////////////////////////////////
671
672	RTTLS MultiResult::sCounter = NIL_RTTLS;
673
674	/static/
675	void MultiResult::incCounter()
676	{
677	if (sCounter == NIL_RTTLS)
678	{
679	sCounter = RTTlsAlloc();
680	AssertReturnVoid(sCounter != NIL_RTTLS);
681	}
682
683	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
684	++counter;
685	RTTlsSet(sCounter, (void*)counter);
686	}
687
688	/static/
689	void MultiResult::decCounter()
690	{
691	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
692	AssertReturnVoid(counter != 0);
693	--counter;
694	RTTlsSet(sCounter, (void*)counter);
695	}
696
697	/static/
698	bool MultiResult::isMultiEnabled()
699	{
700	if (sCounter == NIL_RTTLS)
701	return false;
702
703	return ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
704	}
705

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

source: vbox/trunk/src/VBox/Main/src-all/VirtualBoxBase.cpp@ 59090

Download in other formats: