ProgressImpl.cpp@ 3516

Last change on this file since 3516 was 3191, checked in by vboxsync, 18 years ago
Main: Made it build on OS/2.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.0 KB

Line
1	/** @file
2	*
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22	#if defined (VBOX_WITH_XPCOM)
23	#include <nsIServiceManager.h>
24	#include <nsIExceptionService.h>
25	#include <nsCOMPtr.h>
26	#endif // defined (VBOX_WITH_XPCOM)
27
28	#include "ProgressImpl.h"
29	#include "VirtualBoxImpl.h"
30	#include "VirtualBoxErrorInfoImpl.h"
31
32	#include "Logging.h"
33
34	#include <iprt/time.h>
35	#include <iprt/semaphore.h>
36
37	#include <VBox/err.h>
38
39	////////////////////////////////////////////////////////////////////////////////
40	// ProgressBase class
41	////////////////////////////////////////////////////////////////////////////////
42
43	// constructor / destructor
44	////////////////////////////////////////////////////////////////////////////////
45
46	/** Subclasses must call this method from their FinalConstruct() implementations */
47	HRESULT ProgressBase::FinalConstruct()
48	{
49	mCancelable = FALSE;
50	mCompleted = FALSE;
51	mCanceled = FALSE;
52	mResultCode = S_OK;
53	mOperationCount = 0;
54	mOperation = 0;
55	mOperationPercent = 0;
56
57	return S_OK;
58	}
59
60	// public initializer/uninitializer for internal purposes only
61	////////////////////////////////////////////////////////////////////////////////
62
63	/**
64	* Initializes the progress base object.
65	*
66	* Subclasses should call this or any other #init() method from their
67	* init() implementations.
68	*
69	* @param aParent
70	* Parent object (only for server-side Progress objects)
71	* @param aInitiator
72	* Initiator of the task (for server-side objects
73	* can be NULL which means initiator = parent, otherwise
74	* must not be NULL)
75	* @param aDescription
76	* Task description
77	* @param aID
78	* Address of result GUID structure (optional)
79	*
80	* @note
81	* This method doesn't do \|isReady()\| check and doesn't call
82	* \|setReady (true)\| on success!
83	* @note
84	* This method must be called from under the object's lock!
85	*/
86	HRESULT ProgressBase::protectedInit (
87	#if !defined (VBOX_COM_INPROC)
88	VirtualBox *aParent,
89	#endif
90	IUnknown *aInitiator,
91	const BSTR aDescription, GUIDPARAMOUT aId /* = NULL */)
92	{
93	#if !defined (VBOX_COM_INPROC)
94	ComAssertRet (aParent, E_POINTER);
95	#else
96	ComAssertRet (aInitiator, E_POINTER);
97	#endif
98
99	ComAssertRet (aDescription, E_INVALIDARG);
100
101	#if !defined (VBOX_COM_INPROC)
102	mParent = aParent;
103	#endif
104
105	#if !defined (VBOX_COM_INPROC)
106	// assign (and therefore addref) initiator only if it is not VirtualBox
107	// (to avoid cycling); otherwise mInitiator will remain null which means
108	// that it is the same as the parent
109	if (aInitiator && !mParent.equalsTo (aInitiator))
110	mInitiator = aInitiator;
111	#else
112	mInitiator = aInitiator;
113	#endif
114
115	mDescription = aDescription;
116
117	mId.create();
118	if (aId)
119	mId.cloneTo (aId);
120
121	#if !defined (VBOX_COM_INPROC)
122	// add to the global colleciton of progess operations
123	mParent->addProgress (this);
124	// cause #uninit() to be called automatically upon VirtualBox uninit
125	mParent->addDependentChild (this);
126	#endif
127
128	return S_OK;
129	}
130
131	/**
132	* Initializes the progress base object.
133	* This is a special initializator for progress objects that are combined
134	* within a CombinedProgress instance, so it doesn't require the parent,
135	* initiator, description and doesn't create an ID. Note that calling respective
136	* getter methods on an object initialized with this constructor will hit an
137	* assertion.
138	*
139	* Subclasses should call this or any other #init() method from their
140	* init() implementations.
141	*
142	* @note
143	* This method doesn't do \|isReady()\| check and doesn't call
144	* \|setReady (true)\| on success!
145	* @note
146	* This method must be called from under the object's lock!
147	*/
148	HRESULT ProgressBase::protectedInit()
149	{
150	return S_OK;
151	}
152
153	/**
154	* Uninitializes the instance.
155	* Subclasses should call this from their uninit() implementations.
156	* The readiness flag must be true on input and will be set to false
157	* on output.
158	*
159	* @param alock this object's autolock (with lock level = 1!)
160	*
161	* @note
162	* Using mParent member after this method returns is forbidden.
163	*/
164	void ProgressBase::protectedUninit (AutoLock &alock)
165	{
166	LogFlowMember (("ProgressBase::protectedUninit()\n"));
167
168	Assert (alock.belongsTo (this) && alock.level() == 1);
169	Assert (isReady());
170
171	/*
172	* release initiator
173	* (effective only if mInitiator has been assigned in init())
174	*/
175	mInitiator.setNull();
176
177	setReady (false);
178
179	#if !defined (VBOX_COM_INPROC)
180	if (mParent)
181	{
182	alock.leave();
183	mParent->removeDependentChild (this);
184	alock.enter();
185	}
186
187	mParent.setNull();
188	#endif
189	}
190
191	// IProgress properties
192	/////////////////////////////////////////////////////////////////////////////
193
194	STDMETHODIMP ProgressBase::COMGETTER(Id) (GUIDPARAMOUT aId)
195	{
196	if (!aId)
197	return E_POINTER;
198
199	AutoLock lock (this);
200	CHECK_READY();
201
202	ComAssertRet (!mId.isEmpty(), E_FAIL);
203
204	mId.cloneTo (aId);
205	return S_OK;
206	}
207
208	STDMETHODIMP ProgressBase::COMGETTER(Description) (BSTR *aDescription)
209	{
210	if (!aDescription)
211	return E_POINTER;
212
213	AutoLock lock (this);
214	CHECK_READY();
215
216	ComAssertRet (!mDescription.isNull(), E_FAIL);
217
218	mDescription.cloneTo (aDescription);
219	return S_OK;
220	}
221
222	STDMETHODIMP ProgressBase::COMGETTER(Initiator) (IUnknown **aInitiator)
223	{
224	if (!aInitiator)
225	return E_POINTER;
226
227	AutoLock lock(this);
228	CHECK_READY();
229
230	#if !defined (VBOX_COM_INPROC)
231	ComAssertRet (!mInitiator.isNull() \|\| !mParent.isNull(), E_FAIL);
232
233	if (mInitiator)
234	mInitiator.queryInterfaceTo (aInitiator);
235	else
236	mParent.queryInterfaceTo (aInitiator);
237	#else
238	ComAssertRet (!mInitiator.isNull(), E_FAIL);
239
240	mInitiator.queryInterfaceTo (aInitiator);
241	#endif
242
243	return S_OK;
244	}
245
246	STDMETHODIMP ProgressBase::COMGETTER(Cancelable) (BOOL *aCancelable)
247	{
248	if (!aCancelable)
249	return E_POINTER;
250
251	AutoLock lock(this);
252	CHECK_READY();
253
254	*aCancelable = mCancelable;
255	return S_OK;
256	}
257
258	STDMETHODIMP ProgressBase::COMGETTER(Percent) (LONG *aPercent)
259	{
260	if (!aPercent)
261	return E_POINTER;
262
263	AutoLock lock(this);
264	CHECK_READY();
265
266	if (mCompleted && SUCCEEDED (mResultCode))
267	*aPercent = 100;
268	else
269	{
270	// global percent = (100 / mOperationCount) * mOperation +
271	// ((100 / mOperationCount) / 100) * mOperationPercent
272	aPercent = (100 mOperation + mOperationPercent) / mOperationCount;
273	}
274
275	return S_OK;
276	}
277
278	STDMETHODIMP ProgressBase::COMGETTER(Completed) (BOOL *aCompleted)
279	{
280	if (!aCompleted)
281	return E_POINTER;
282
283	AutoLock lock(this);
284	CHECK_READY();
285
286	*aCompleted = mCompleted;
287	return S_OK;
288	}
289
290	STDMETHODIMP ProgressBase::COMGETTER(Canceled) (BOOL *aCanceled)
291	{
292	if (!aCanceled)
293	return E_POINTER;
294
295	AutoLock lock(this);
296	CHECK_READY();
297
298	*aCanceled = mCanceled;
299	return S_OK;
300	}
301
302	STDMETHODIMP ProgressBase::COMGETTER(ResultCode) (HRESULT *aResultCode)
303	{
304	if (!aResultCode)
305	return E_POINTER;
306
307	AutoLock lock(this);
308	CHECK_READY();
309
310	if (!mCompleted)
311	return setError (E_FAIL,
312	tr ("Result code is not available, operation is still in progress"));
313
314	*aResultCode = mResultCode;
315	return S_OK;
316	}
317
318	STDMETHODIMP ProgressBase::COMGETTER(ErrorInfo) (IVirtualBoxErrorInfo **aErrorInfo)
319	{
320	if (!aErrorInfo)
321	return E_POINTER;
322
323	AutoLock lock(this);
324	CHECK_READY();
325
326	if (!mCompleted)
327	return setError (E_FAIL,
328	tr ("Error info is not available, operation is still in progress"));
329
330	mErrorInfo.queryInterfaceTo (aErrorInfo);
331	return S_OK;
332	}
333
334	STDMETHODIMP ProgressBase::COMGETTER(OperationCount) (ULONG *aOperationCount)
335	{
336	if (!aOperationCount)
337	return E_POINTER;
338
339	AutoLock lock(this);
340	CHECK_READY();
341
342	*aOperationCount = mOperationCount;
343	return S_OK;
344	}
345
346	STDMETHODIMP ProgressBase::COMGETTER(Operation) (ULONG *aOperation)
347	{
348	if (!aOperation)
349	return E_POINTER;
350
351	AutoLock lock(this);
352	CHECK_READY();
353
354	*aOperation = mOperation;
355	return S_OK;
356	}
357
358	STDMETHODIMP ProgressBase::COMGETTER(OperationDescription) (BSTR *aOperationDescription)
359	{
360	if (!aOperationDescription)
361	return E_POINTER;
362
363	AutoLock lock(this);
364	CHECK_READY();
365
366	mOperationDescription.cloneTo (aOperationDescription);
367	return S_OK;
368	}
369
370	STDMETHODIMP ProgressBase::COMGETTER(OperationPercent) (LONG *aOperationPercent)
371	{
372	if (!aOperationPercent)
373	return E_POINTER;
374
375	AutoLock lock(this);
376	CHECK_READY();
377
378	if (mCompleted && SUCCEEDED (mResultCode))
379	*aOperationPercent = 100;
380	else
381	*aOperationPercent = mOperationPercent;
382	return S_OK;
383	}
384
385	////////////////////////////////////////////////////////////////////////////////
386	// Progress class
387	////////////////////////////////////////////////////////////////////////////////
388
389	HRESULT Progress::FinalConstruct()
390	{
391	HRESULT rc = ProgressBase::FinalConstruct();
392	if (FAILED (rc))
393	return rc;
394
395	mCompletedSem = NIL_RTSEMEVENTMULTI;
396	mWaitersCount = 0;
397
398	return S_OK;
399	}
400
401	void Progress::FinalRelease()
402	{
403	uninit();
404	}
405
406	// public initializer/uninitializer for internal purposes only
407	////////////////////////////////////////////////////////////////////////////////
408
409	/**
410	* Initializes the progress object.
411	*
412	* @param aParent see ProgressBase::init()
413	* @param aInitiator see ProgressBase::init()
414	* @param aDescription see ProgressBase::init()
415	* @param aCancelable Flag whether the task maybe canceled
416	* @param aOperationCount Number of operations within this task (at least 1)
417	* @param aOperationDescription Description of the first operation
418	* @param aId see ProgressBase::init()
419	*/
420	HRESULT Progress::init (
421	#if !defined (VBOX_COM_INPROC)
422	VirtualBox *aParent,
423	#endif
424	IUnknown *aInitiator,
425	const BSTR aDescription, BOOL aCancelable,
426	ULONG aOperationCount, const BSTR aOperationDescription,
427	GUIDPARAMOUT aId /* = NULL */)
428	{
429	LogFlowMember(("Progress::init(): aDescription={%ls}\n", aDescription));
430
431	ComAssertRet (aOperationDescription, E_INVALIDARG);
432	ComAssertRet (aOperationCount >= 1, E_INVALIDARG);
433
434	AutoLock lock(this);
435	ComAssertRet (!isReady(), E_UNEXPECTED);
436
437	HRESULT rc = S_OK;
438
439	do
440	{
441	rc = ProgressBase::protectedInit (
442	#if !defined (VBOX_COM_INPROC)
443	aParent,
444	#endif
445	aInitiator, aDescription, aId);
446	CheckComRCBreakRC (rc);
447
448	// set ready to let protectedUninit() be called on failure
449	setReady (true);
450
451	mCancelable = aCancelable;
452
453	mOperationCount = aOperationCount;
454	mOperation = 0; // the first operation
455	mOperationDescription = aOperationDescription;
456
457	int vrc = RTSemEventMultiCreate (&mCompletedSem);
458	ComAssertRCBreak (vrc, rc = E_FAIL);
459
460	RTSemEventMultiReset (mCompletedSem);
461	}
462	while (0);
463
464	if (FAILED (rc))
465	uninit();
466
467	return rc;
468	}
469
470	HRESULT Progress::init (BOOL aCancelable, ULONG aOperationCount,
471	const BSTR aOperationDescription)
472	{
473	LogFlowMember(("Progress::init(): <undescriptioned>\n"));
474
475	AutoLock lock(this);
476	ComAssertRet (!isReady(), E_UNEXPECTED);
477
478	HRESULT rc = S_OK;
479
480	do
481	{
482	rc = ProgressBase::protectedInit();
483	CheckComRCBreakRC (rc);
484
485	// set ready to let protectedUninit() be called on failure
486	setReady (true);
487
488	mCancelable = aCancelable;
489
490	mOperationCount = aOperationCount;
491	mOperation = 0; // the first operation
492	mOperationDescription = aOperationDescription;
493
494	int vrc = RTSemEventMultiCreate (&mCompletedSem);
495	ComAssertRCBreak (vrc, rc = E_FAIL);
496
497	RTSemEventMultiReset (mCompletedSem);
498	}
499	while (0);
500
501	if (FAILED (rc))
502	uninit();
503
504	return rc;
505	}
506
507	/**
508	* Uninitializes the instance and sets the ready flag to FALSE.
509	* Called either from FinalRelease() or by the parent when it gets destroyed.
510	*/
511	void Progress::uninit()
512	{
513	LogFlowMember (("Progress::uninit()\n"));
514
515	AutoLock alock (this);
516
517	LogFlowMember (("Progress::uninit(): isReady=%d\n", isReady()));
518
519	if (!isReady())
520	return;
521
522	// wake up all threads still waiting by occasion
523	if (mWaitersCount > 0)
524	{
525	LogFlow (("WARNING: There are still %d threads waiting for '%ls' completion!\n",
526	mWaitersCount, mDescription.raw()));
527	RTSemEventMultiSignal (mCompletedSem);
528	}
529
530	RTSemEventMultiDestroy (mCompletedSem);
531
532	ProgressBase::protectedUninit (alock);
533	}
534
535	// IProgress properties
536	/////////////////////////////////////////////////////////////////////////////
537
538	// IProgress methods
539	/////////////////////////////////////////////////////////////////////////////
540
541	/**
542	* @note
543	* XPCOM: when this method is called not on the main XPCOM thread, it
544	* it simply blocks the thread until mCompletedSem is signalled. If the
545	* thread has its own event queue (hmm, what for?) that it must run, then
546	* calling this method will definitey freese event processing.
547	*/
548	STDMETHODIMP Progress::WaitForCompletion (LONG aTimeout)
549	{
550	LogFlowMember(("Progress::WaitForCompletion: BEGIN: timeout=%d\n", aTimeout));
551
552	AutoLock lock(this);
553	CHECK_READY();
554
555	// if we're already completed, take a shortcut
556	if (!mCompleted)
557	{
558	RTTIMESPEC time;
559	RTTimeNow (&time);
560
561	int vrc = VINF_SUCCESS;
562	bool forever = aTimeout < 0;
563	int64_t timeLeft = aTimeout;
564	int64_t lastTime = RTTimeSpecGetMilli (&time);
565
566	while (!mCompleted && (forever \|\| timeLeft > 0))
567	{
568	mWaitersCount ++;
569	lock.unlock();
570	int vrc = RTSemEventMultiWait (mCompletedSem,
571	forever ? RT_INDEFINITE_WAIT
572	: (unsigned) timeLeft);
573	lock.lock();
574	mWaitersCount --;
575
576	// the progress might have been uninitialized
577	if (!isReady())
578	break;
579
580	// the last waiter resets the semaphore
581	if (mWaitersCount == 0)
582	RTSemEventMultiReset (mCompletedSem);
583
584	if (VBOX_FAILURE (vrc) && vrc != VERR_TIMEOUT)
585	break;
586
587	if (!forever)
588	{
589	RTTimeNow (&time);
590	timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
591	lastTime = RTTimeSpecGetMilli (&time);
592	}
593	}
594
595	if (VBOX_FAILURE (vrc) && vrc != VERR_TIMEOUT)
596	return setError (E_FAIL,
597	tr ("Failed to wait for the task completion (%Vrc)"), vrc);
598	}
599
600	LogFlowMember(("Progress::WaitForCompletion: END\n"));
601	return S_OK;
602	}
603
604	/**
605	* @note
606	* XPCOM: when this method is called not on the main XPCOM thread, it
607	* it simply blocks the thread until mCompletedSem is signalled. If the
608	* thread has its own event queue (hmm, what for?) that it must run, then
609	* calling this method will definitey freese event processing.
610	*/
611	STDMETHODIMP Progress::WaitForOperationCompletion (ULONG aOperation, LONG aTimeout)
612	{
613	LogFlowMember(("Progress::WaitForOperationCompletion: BEGIN: "
614	"operation=%d, timeout=%d\n", aOperation, aTimeout));
615
616	AutoLock lock(this);
617	CHECK_READY();
618
619	if (aOperation >= mOperationCount)
620	return setError (E_FAIL,
621	tr ("Operation number must be in range [0, %d]"), mOperation - 1);
622
623	// if we're already completed or if the given operation is already done,
624	// then take a shortcut
625	if (!mCompleted && aOperation >= mOperation)
626	{
627	RTTIMESPEC time;
628	RTTimeNow (&time);
629
630	int vrc = VINF_SUCCESS;
631	bool forever = aTimeout < 0;
632	int64_t timeLeft = aTimeout;
633	int64_t lastTime = RTTimeSpecGetMilli (&time);
634
635	while (!mCompleted && aOperation >= mOperation &&
636	(forever \|\| timeLeft > 0))
637	{
638	mWaitersCount ++;
639	lock.unlock();
640	int vrc = RTSemEventMultiWait (mCompletedSem,
641	forever ? RT_INDEFINITE_WAIT
642	: (unsigned) timeLeft);
643	lock.lock();
644	mWaitersCount --;
645
646	// the progress might have been uninitialized
647	if (!isReady())
648	break;
649
650	// the last waiter resets the semaphore
651	if (mWaitersCount == 0)
652	RTSemEventMultiReset (mCompletedSem);
653
654	if (VBOX_FAILURE (vrc) && vrc != VERR_TIMEOUT)
655	break;
656
657	if (!forever)
658	{
659	RTTimeNow (&time);
660	timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
661	lastTime = RTTimeSpecGetMilli (&time);
662	}
663	}
664
665	if (VBOX_FAILURE (vrc) && vrc != VERR_TIMEOUT)
666	return setError (E_FAIL,
667	tr ("Failed to wait for the operation completion (%Vrc)"), vrc);
668	}
669
670	LogFlowMember(("Progress::WaitForOperationCompletion: END\n"));
671	return S_OK;
672	}
673
674	STDMETHODIMP Progress::Cancel()
675	{
676	AutoLock lock(this);
677	CHECK_READY();
678
679	if (!mCancelable)
680	return setError (E_FAIL, tr ("Operation cannot be cancelled"));
681
682	/// @todo (dmik): implement operation cancellation!
683	// mCompleted = TRUE;
684	// mCanceled = TRUE;
685	// return S_OK;
686
687	ComAssertMsgFailed (("Not implemented!"));
688	return E_NOTIMPL;
689	}
690
691	// public methods only for internal purposes
692	/////////////////////////////////////////////////////////////////////////////
693
694	/**
695	* Updates the percentage value of the current operation.
696	*
697	* @param aPercent New percentage value of the operation in progress
698	* (in range [0, 100]).
699	*/
700	HRESULT Progress::notifyProgress (LONG aPercent)
701	{
702	AutoLock lock (this);
703	AssertReturn (isReady(), E_UNEXPECTED);
704
705	AssertReturn (!mCompleted && !mCanceled, E_FAIL);
706	AssertReturn (aPercent >= 0 && aPercent <= 100, E_INVALIDARG);
707
708	mOperationPercent = aPercent;
709	return S_OK;
710	}
711
712	/**
713	* Signals that the current operation is successfully completed
714	* and advances to the next operation. The operation percentage is reset
715	* to 0.
716	*
717	* @param aOperationDescription Description of the next operation
718	*
719	* @note
720	* The current operation must not be the last one.
721	*/
722	HRESULT Progress::advanceOperation (const BSTR aOperationDescription)
723	{
724	AssertReturn (aOperationDescription, E_INVALIDARG);
725
726	AutoLock lock (this);
727	AssertReturn (isReady(), E_UNEXPECTED);
728
729	AssertReturn (!mCompleted && !mCanceled, E_FAIL);
730	AssertReturn (mOperation + 1 < mOperationCount, E_FAIL);
731
732	mOperation ++;
733	mOperationDescription = aOperationDescription;
734	mOperationPercent = 0;
735
736	// wake up all waiting threads
737	if (mWaitersCount > 0)
738	RTSemEventMultiSignal (mCompletedSem);
739
740	return S_OK;
741	}
742
743	/**
744	* Marks the whole task as complete and sets the result code.
745	*
746	* If the result code indicates a failure (\|FAILED (@a aResultCode)\|)
747	* then this method will import the error info from the current
748	* thread and assign it to the errorInfo attribute (it will return an
749	* error if no info is available in such case).
750	*
751	* If the result code indicates a success (\|SUCCEEDED (@a aResultCode)\|)
752	* then the current operation is set to the last
753	*
754	* @param aResultCode Operation result code
755	*/
756	HRESULT Progress::notifyComplete (HRESULT aResultCode)
757	{
758	AutoLock lock (this);
759	AssertReturn (isReady(), E_FAIL);
760
761	mCompleted = TRUE;
762	mResultCode = aResultCode;
763
764	HRESULT rc = S_OK;
765
766	if (FAILED (aResultCode))
767	{
768	/* try to import error info from the current thread */
769
770	#if !defined (VBOX_WITH_XPCOM)
771	#if defined (__WIN__)
772
773	ComPtr <IErrorInfo> err;
774	rc = ::GetErrorInfo (0, err.asOutParam());
775	if (rc == S_OK && err)
776	{
777	rc = err.queryInterfaceTo (mErrorInfo.asOutParam());
778	if (SUCCEEDED (rc) && !mErrorInfo)
779	rc = E_FAIL;
780	}
781
782	#endif // !defined (__WIN__)
783	#else // !defined (VBOX_WITH_XPCOM)
784
785	nsCOMPtr <nsIExceptionService> es;
786	es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
787	if (NS_SUCCEEDED (rc))
788	{
789	nsCOMPtr <nsIExceptionManager> em;
790	rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
791	if (NS_SUCCEEDED (rc))
792	{
793	ComPtr <nsIException> ex;
794	rc = em->GetCurrentException (ex.asOutParam());
795	if (NS_SUCCEEDED (rc) && ex)
796	{
797	rc = ex.queryInterfaceTo (mErrorInfo.asOutParam());
798	if (NS_SUCCEEDED (rc) && !mErrorInfo)
799	rc = E_FAIL;
800	}
801	}
802	}
803	#endif // !defined (VBOX_WITH_XPCOM)
804
805	AssertMsg (rc == S_OK, ("Couldn't get error info (rc=%08X) while trying "
806	"to set a failed result (%08X)!\n", rc, aResultCode));
807	}
808	else
809	{
810	mOperation = mOperationCount - 1; /* last operation */
811	mOperationPercent = 100;
812	}
813
814	#if !defined VBOX_COM_INPROC
815	/* remove from the global collection of pending progress operations */
816	if (mParent)
817	mParent->removeProgress (mId);
818	#endif
819
820	/* wake up all waiting threads */
821	if (mWaitersCount > 0)
822	RTSemEventMultiSignal (mCompletedSem);
823
824	return rc;
825	}
826
827	/**
828	* Marks the operation as complete and attaches full error info.
829	* See VirtualBoxSupportErrorInfoImpl::setError(HRESULT, const GUID &, const wchar_t , const char , ...)
830	* for more info.
831	*
832	* @param aResultCode operation result (error) code, must not be S_OK
833	* @param aIID IID of the intrface that defines the error
834	* @param aComponent name of the component that generates the error
835	* @param aText error message (must not be null), an RTStrPrintf-like
836	* format string in UTF-8 encoding
837	* @param ... list of arguments for the format string
838	*/
839	HRESULT Progress::notifyComplete (HRESULT aResultCode, const GUID &aIID,
840	const Bstr &aComponent,
841	const char *aText, ...)
842	{
843	va_list args;
844	va_start (args, aText);
845	Bstr text = Utf8StrFmt (aText, args);
846	va_end (args);
847
848	return notifyCompleteBstr (aResultCode, aIID, aComponent, text);
849	}
850
851	/**
852	* Marks the operation as complete and attaches full error info.
853	* See VirtualBoxSupportErrorInfoImpl::setError(HRESULT, const GUID &, const wchar_t , const char , ...)
854	* for more info.
855	*
856	* This method is preferred iy you have a ready (translated and formatted)
857	* Bstr string, because it omits an extra conversion Utf8Str -> Bstr.
858	*
859	* @param aResultCode operation result (error) code, must not be S_OK
860	* @param aIID IID of the intrface that defines the error
861	* @param aComponent name of the component that generates the error
862	* @param aText error message (must not be null)
863	*/
864	HRESULT Progress::notifyCompleteBstr (HRESULT aResultCode, const GUID &aIID,
865	const Bstr &aComponent, const Bstr &aText)
866	{
867	AutoLock lock (this);
868	AssertReturn (isReady(), E_UNEXPECTED);
869
870	mCompleted = TRUE;
871	mResultCode = aResultCode;
872
873	AssertReturn (FAILED (aResultCode), E_FAIL);
874
875	ComObjPtr <VirtualBoxErrorInfo> errorInfo;
876	HRESULT rc = errorInfo.createObject();
877	AssertComRC (rc);
878	if (SUCCEEDED (rc))
879	{
880	errorInfo->init (aResultCode, aIID, aComponent, aText);
881	errorInfo.queryInterfaceTo (mErrorInfo.asOutParam());
882	}
883
884	#if !defined VBOX_COM_INPROC
885	/* remove from the global collection of pending progress operations */
886	if (mParent)
887	mParent->removeProgress (mId);
888	#endif
889
890	/* wake up all waiting threads */
891	if (mWaitersCount > 0)
892	RTSemEventMultiSignal (mCompletedSem);
893
894	return rc;
895	}
896
897	////////////////////////////////////////////////////////////////////////////////
898	// CombinedProgress class
899	////////////////////////////////////////////////////////////////////////////////
900
901	HRESULT CombinedProgress::FinalConstruct()
902	{
903	HRESULT rc = ProgressBase::FinalConstruct();
904	if (FAILED (rc))
905	return rc;
906
907	mProgress = 0;
908	mCompletedOperations = 0;
909
910	return S_OK;
911	}
912
913	void CombinedProgress::FinalRelease()
914	{
915	uninit();
916	}
917
918	// public initializer/uninitializer for internal purposes only
919	////////////////////////////////////////////////////////////////////////////////
920
921	/**
922	* Initializes this object based on individual combined progresses.
923	* Must be called only from #init()!
924	*
925	* @param aParent see ProgressBase::init()
926	* @param aInitiator see ProgressBase::init()
927	* @param aDescription see ProgressBase::init()
928	* @param aId see ProgressBase::init()
929	*/
930	HRESULT CombinedProgress::protectedInit (
931	#if !defined (VBOX_COM_INPROC)
932	VirtualBox *aParent,
933	#endif
934	IUnknown *aInitiator,
935	const BSTR aDescription, GUIDPARAMOUT aId)
936	{
937	LogFlowMember (("CombinedProgress::protectedInit(): "
938	"aDescription={%ls} mProgresses.size()=%d\n",
939	aDescription, mProgresses.size()));
940
941	HRESULT rc = S_OK;
942
943	do
944	{
945	rc = ProgressBase::protectedInit (
946	#if !defined (VBOX_COM_INPROC)
947	aParent,
948	#endif
949	aInitiator, aDescription, aId);
950	CheckComRCBreakRC (rc);
951
952	// set ready to let protectedUninit() be called on failure
953	setReady (true);
954
955	mProgress = 0; // the first object
956	mCompletedOperations = 0;
957
958	mCompleted = FALSE;
959	mCancelable = TRUE; // until any progress returns FALSE
960	mCanceled = FALSE;
961
962	mOperationCount = 0; // will be calculated later
963	mOperation = 0;
964	rc = mProgresses [0]->COMGETTER(OperationDescription) (
965	mOperationDescription.asOutParam());
966	CheckComRCBreakRC (rc);
967
968	for (size_t i = 0; i < mProgresses.size(); i ++)
969	{
970	if (mCancelable)
971	{
972	BOOL cancelable = FALSE;
973	rc = mProgresses [i]->COMGETTER(Cancelable) (&cancelable);
974	if (FAILED (rc))
975	return rc;
976	if (!cancelable)
977	mCancelable = FALSE;
978	}
979
980	{
981	ULONG opCount = 0;
982	rc = mProgresses [i]->COMGETTER(OperationCount) (&opCount);
983	if (FAILED (rc))
984	return rc;
985	mOperationCount += opCount;
986	}
987	}
988
989	rc = checkProgress();
990	CheckComRCBreakRC (rc);
991	}
992	while (0);
993
994	if (FAILED (rc))
995	uninit();
996
997	return rc;
998	}
999
1000	/**
1001	* Uninitializes the instance and sets the ready flag to FALSE.
1002	* Called either from FinalRelease() or by the parent when it gets destroyed.
1003	*/
1004	void CombinedProgress::uninit()
1005	{
1006	LogFlowMember (("CombinedProgress::uninit()\n"));
1007
1008	AutoLock alock (this);
1009
1010	LogFlowMember (("CombinedProgress::uninit(): isReady=%d\n", isReady()));
1011
1012	if (!isReady())
1013	return;
1014
1015	mProgress = 0;
1016	mProgresses.clear();
1017
1018	ProgressBase::protectedUninit (alock);
1019	}
1020
1021	// IProgress properties
1022	////////////////////////////////////////////////////////////////////////////////
1023
1024	STDMETHODIMP CombinedProgress::COMGETTER(Percent) (LONG *aPercent)
1025	{
1026	if (!aPercent)
1027	return E_POINTER;
1028
1029	AutoLock lock(this);
1030	CHECK_READY();
1031
1032	if (mCompleted && SUCCEEDED (mResultCode))
1033	*aPercent = 100;
1034	else
1035	{
1036	HRESULT rc = checkProgress();
1037	if (FAILED (rc))
1038	return rc;
1039
1040	// global percent = (100 / mOperationCount) * mOperation +
1041	// ((100 / mOperationCount) / 100) * mOperationPercent
1042	aPercent = (100 mOperation + mOperationPercent) / mOperationCount;
1043	}
1044
1045	return S_OK;
1046	}
1047
1048	STDMETHODIMP CombinedProgress::COMGETTER(Completed) (BOOL *aCompleted)
1049	{
1050	if (!aCompleted)
1051	return E_POINTER;
1052
1053	AutoLock lock(this);
1054	CHECK_READY();
1055
1056	HRESULT rc = checkProgress();
1057	if (FAILED (rc))
1058	return rc;
1059
1060	return ProgressBase::COMGETTER(Completed) (aCompleted);
1061	}
1062
1063	STDMETHODIMP CombinedProgress::COMGETTER(Canceled) (BOOL *aCanceled)
1064	{
1065	if (!aCanceled)
1066	return E_POINTER;
1067
1068	AutoLock lock(this);
1069	CHECK_READY();
1070
1071	HRESULT rc = checkProgress();
1072	if (FAILED (rc))
1073	return rc;
1074
1075	return ProgressBase::COMGETTER(Canceled) (aCanceled);
1076	}
1077
1078	STDMETHODIMP CombinedProgress::COMGETTER(ResultCode) (HRESULT *aResultCode)
1079	{
1080	if (!aResultCode)
1081	return E_POINTER;
1082
1083	AutoLock lock(this);
1084	CHECK_READY();
1085
1086	HRESULT rc = checkProgress();
1087	if (FAILED (rc))
1088	return rc;
1089
1090	return ProgressBase::COMGETTER(ResultCode) (aResultCode);
1091	}
1092
1093	STDMETHODIMP CombinedProgress::COMGETTER(ErrorInfo) (IVirtualBoxErrorInfo **aErrorInfo)
1094	{
1095	if (!aErrorInfo)
1096	return E_POINTER;
1097
1098	AutoLock lock(this);
1099	CHECK_READY();
1100
1101	HRESULT rc = checkProgress();
1102	if (FAILED (rc))
1103	return rc;
1104
1105	return ProgressBase::COMGETTER(ErrorInfo) (aErrorInfo);
1106	}
1107
1108	STDMETHODIMP CombinedProgress::COMGETTER(Operation) (ULONG *aOperation)
1109	{
1110	if (!aOperation)
1111	return E_POINTER;
1112
1113	AutoLock lock(this);
1114	CHECK_READY();
1115
1116	HRESULT rc = checkProgress();
1117	if (FAILED (rc))
1118	return rc;
1119
1120	return ProgressBase::COMGETTER(Operation) (aOperation);
1121	}
1122
1123	STDMETHODIMP CombinedProgress::COMGETTER(OperationDescription) (BSTR *aOperationDescription)
1124	{
1125	if (!aOperationDescription)
1126	return E_POINTER;
1127
1128	AutoLock lock(this);
1129	CHECK_READY();
1130
1131	HRESULT rc = checkProgress();
1132	if (FAILED (rc))
1133	return rc;
1134
1135	return ProgressBase::COMGETTER(OperationDescription) (aOperationDescription);
1136	}
1137
1138	STDMETHODIMP CombinedProgress::COMGETTER(OperationPercent) (LONG *aOperationPercent)
1139	{
1140	if (!aOperationPercent)
1141	return E_POINTER;
1142
1143	AutoLock lock(this);
1144	CHECK_READY();
1145
1146	HRESULT rc = checkProgress();
1147	if (FAILED (rc))
1148	return rc;
1149
1150	return ProgressBase::COMGETTER(OperationPercent) (aOperationPercent);
1151	}
1152
1153	// IProgress methods
1154	/////////////////////////////////////////////////////////////////////////////
1155
1156	/**
1157	* @note
1158	* XPCOM: when this method is called not on the main XPCOM thread, it
1159	* it simply blocks the thread until mCompletedSem is signalled. If the
1160	* thread has its own event queue (hmm, what for?) that it must run, then
1161	* calling this method will definitey freese event processing.
1162	*/
1163	STDMETHODIMP CombinedProgress::WaitForCompletion (LONG aTimeout)
1164	{
1165	LogFlowMember (("CombinedProgress::WaitForCompletion: BEGIN: timeout=%d\n",
1166	aTimeout));
1167
1168	AutoLock lock (this);
1169	CHECK_READY();
1170
1171	// if we're already completed, take a shortcut
1172	if (!mCompleted)
1173	{
1174	RTTIMESPEC time;
1175	RTTimeNow (&time);
1176
1177	HRESULT rc = S_OK;
1178	bool forever = aTimeout < 0;
1179	int64_t timeLeft = aTimeout;
1180	int64_t lastTime = RTTimeSpecGetMilli (&time);
1181
1182	while (!mCompleted && (forever \|\| timeLeft > 0))
1183	{
1184	lock.unlock();
1185	rc = mProgresses.back()->WaitForCompletion (
1186	forever ? -1 : (LONG) timeLeft);
1187	lock.lock();
1188
1189	// the progress might have been uninitialized
1190	if (!isReady())
1191	break;
1192
1193	if (SUCCEEDED (rc))
1194	rc = checkProgress();
1195
1196	if (FAILED (rc))
1197	break;
1198
1199	if (!forever)
1200	{
1201	RTTimeNow (&time);
1202	timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
1203	lastTime = RTTimeSpecGetMilli (&time);
1204	}
1205	}
1206
1207	if (FAILED (rc))
1208	return rc;
1209	}
1210
1211	LogFlowMember(("CombinedProgress::WaitForCompletion: END\n"));
1212	return S_OK;
1213	}
1214
1215	/**
1216	* @note
1217	* XPCOM: when this method is called not on the main XPCOM thread, it
1218	* it simply blocks the thread until mCompletedSem is signalled. If the
1219	* thread has its own event queue (hmm, what for?) that it must run, then
1220	* calling this method will definitey freese event processing.
1221	*/
1222	STDMETHODIMP CombinedProgress::WaitForOperationCompletion (ULONG aOperation, LONG aTimeout)
1223	{
1224	LogFlowMember(("CombinedProgress::WaitForOperationCompletion: BEGIN: "
1225	"operation=%d, timeout=%d\n", aOperation, aTimeout));
1226
1227	AutoLock lock(this);
1228	CHECK_READY();
1229
1230	if (aOperation >= mOperationCount)
1231	return setError (E_FAIL,
1232	tr ("Operation number must be in range [0, %d]"), mOperation - 1);
1233
1234	// if we're already completed or if the given operation is already done,
1235	// then take a shortcut
1236	if (!mCompleted && aOperation >= mOperation)
1237	{
1238	HRESULT rc = S_OK;
1239
1240	// find the right progress object to wait for
1241	size_t progress = mProgress;
1242	ULONG operation = 0, completedOps = mCompletedOperations;
1243	do
1244	{
1245	ULONG opCount = 0;
1246	rc = mProgresses [progress]->COMGETTER(OperationCount) (&opCount);
1247	if (FAILED (rc))
1248	return rc;
1249
1250	if (completedOps + opCount > aOperation)
1251	{
1252	// found the right progress object
1253	operation = aOperation - completedOps;
1254	break;
1255	}
1256
1257	completedOps += opCount;
1258	progress ++;
1259	ComAssertRet (progress < mProgresses.size(), E_FAIL);
1260	}
1261	while (1);
1262
1263	LogFlowMember (("CombinedProgress::WaitForOperationCompletion(): "
1264	"will wait for mProgresses [%d] (%d)\n",
1265	progress, operation));
1266
1267	RTTIMESPEC time;
1268	RTTimeNow (&time);
1269
1270	bool forever = aTimeout < 0;
1271	int64_t timeLeft = aTimeout;
1272	int64_t lastTime = RTTimeSpecGetMilli (&time);
1273
1274	while (!mCompleted && aOperation >= mOperation &&
1275	(forever \|\| timeLeft > 0))
1276	{
1277	lock.unlock();
1278	// wait for the appropriate progress operation completion
1279	rc = mProgresses [progress]-> WaitForOperationCompletion (
1280	operation, forever ? -1 : (LONG) timeLeft);
1281	lock.lock();
1282
1283	// the progress might have been uninitialized
1284	if (!isReady())
1285	break;
1286
1287	if (SUCCEEDED (rc))
1288	rc = checkProgress();
1289
1290	if (FAILED (rc))
1291	break;
1292
1293	if (!forever)
1294	{
1295	RTTimeNow (&time);
1296	timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
1297	lastTime = RTTimeSpecGetMilli (&time);
1298	}
1299	}
1300
1301	if (FAILED (rc))
1302	return rc;
1303	}
1304
1305	LogFlowMember(("CombinedProgress::WaitForOperationCompletion: END\n"));
1306	return S_OK;
1307	}
1308
1309	STDMETHODIMP CombinedProgress::Cancel()
1310	{
1311	AutoLock lock(this);
1312	CHECK_READY();
1313
1314	if (!mCancelable)
1315	return setError (E_FAIL, tr ("Operation cannot be cancelled"));
1316
1317	/// @todo (dmik): implement operation cancellation!
1318	// mCompleted = TRUE;
1319	// mCanceled = TRUE;
1320	// return S_OK;
1321
1322	return setError (E_NOTIMPL, ("Not implemented!"));
1323	}
1324
1325	// private methods
1326	////////////////////////////////////////////////////////////////////////////////
1327
1328	/**
1329	* Fetches the properties of the current progress object and, if it is
1330	* successfully completed, advances to the next uncompleted or unsucessfully
1331	* completed object in the vector of combined progress objects.
1332	*
1333	* @note Must be called from under the object's lock!
1334	*/
1335	HRESULT CombinedProgress::checkProgress()
1336	{
1337	// do nothing if we're already marked ourselves as completed
1338	if (mCompleted)
1339	return S_OK;
1340
1341	ComAssertRet (mProgress < mProgresses.size(), E_FAIL);
1342
1343	ComPtr <IProgress> progress = mProgresses [mProgress];
1344	ComAssertRet (!progress.isNull(), E_FAIL);
1345
1346	HRESULT rc = S_OK;
1347	BOOL completed = FALSE;
1348
1349	do
1350	{
1351	rc = progress->COMGETTER(Completed) (&completed);
1352	if (FAILED (rc))
1353	return rc;
1354
1355	if (completed)
1356	{
1357	rc = progress->COMGETTER(Canceled) (&mCanceled);
1358	if (FAILED (rc))
1359	return rc;
1360
1361	rc = progress->COMGETTER(ResultCode) (&mResultCode);
1362	if (FAILED (rc))
1363	return rc;
1364
1365	if (FAILED (mResultCode))
1366	{
1367	rc = progress->COMGETTER(ErrorInfo) (mErrorInfo.asOutParam());
1368	if (FAILED (rc))
1369	return rc;
1370	}
1371
1372	if (FAILED (mResultCode) \|\| mCanceled)
1373	{
1374	mCompleted = TRUE;
1375	}
1376	else
1377	{
1378	ULONG opCount = 0;
1379	rc = progress->COMGETTER(OperationCount) (&opCount);
1380	if (FAILED (rc))
1381	return rc;
1382
1383	mCompletedOperations += opCount;
1384	mProgress ++;
1385
1386	if (mProgress < mProgresses.size())
1387	progress = mProgresses [mProgress];
1388	else
1389	mCompleted = TRUE;
1390	}
1391	}
1392	}
1393	while (completed && !mCompleted);
1394
1395	rc = progress->COMGETTER(OperationPercent) (&mOperationPercent);
1396	if (SUCCEEDED (rc))
1397	{
1398	ULONG operation = 0;
1399	rc = progress->COMGETTER(Operation) (&operation);
1400	if (SUCCEEDED (rc) && mCompletedOperations + operation > mOperation)
1401	{
1402	mOperation = mCompletedOperations + operation;
1403	rc = progress->COMGETTER(OperationDescription) (
1404	mOperationDescription.asOutParam());
1405	}
1406	}
1407
1408	return rc;
1409	}
1410

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

source: vbox/trunk/src/VBox/Main/ProgressImpl.cpp@ 3516

Download in other formats: