ProgressProxyImpl.cpp@ 44529

Last change on this file since 44529 was 44529, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.1 KB

Line
1	/* $Id: ProgressProxyImpl.cpp 44529 2013-02-04 15:54:15Z vboxsync $ */
2	/** @file
3	* IProgress implementation for Machine::openRemoteSession in VBoxSVC.
4	*/
5
6	/*
7	* Copyright (C) 2010-2011 Oracle Corporation
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 (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include <iprt/types.h>
19
20	#if defined (VBOX_WITH_XPCOM)
21	#include <nsIServiceManager.h>
22	#include <nsIExceptionService.h>
23	#include <nsCOMPtr.h>
24	#endif /* defined (VBOX_WITH_XPCOM) */
25
26	#include "ProgressProxyImpl.h"
27
28	#include "VirtualBoxImpl.h"
29	#include "VirtualBoxErrorInfoImpl.h"
30
31	#include "Logging.h"
32
33	#include <iprt/time.h>
34	#include <iprt/semaphore.h>
35
36	#include <VBox/err.h>
37
38	////////////////////////////////////////////////////////////////////////////////
39	// ProgressProxy class
40	////////////////////////////////////////////////////////////////////////////////
41
42	// constructor / destructor / uninitializer
43	////////////////////////////////////////////////////////////////////////////////
44
45
46	HRESULT ProgressProxy::FinalConstruct()
47	{
48	mfMultiOperation = false;
49	muOtherProgressStartWeight = 0;
50	muOtherProgressWeight = 0;
51	muOtherProgressStartOperation = 0;
52
53	HRESULT rc = Progress::FinalConstruct();
54	return rc;
55	}
56
57	/**
58	* Initialize it as a one operation Progress object.
59	*
60	* This is used by SessionMachine::OnSessionEnd.
61	*/
62	HRESULT ProgressProxy::init(
63	#if !defined (VBOX_COM_INPROC)
64	VirtualBox *pParent,
65	#endif
66	IUnknown *pInitiator,
67	CBSTR bstrDescription,
68	BOOL fCancelable)
69	{
70	mfMultiOperation = false;
71	muOtherProgressStartWeight = 1;
72	muOtherProgressWeight = 1;
73	muOtherProgressStartOperation = 1;
74
75	return Progress::init(
76	#if !defined (VBOX_COM_INPROC)
77	pParent,
78	#endif
79	pInitiator,
80	bstrDescription,
81	fCancelable,
82	1 /* cOperations */,
83	1 /* ulTotalOperationsWeight */,
84	bstrDescription /* bstrFirstOperationDescription */,
85	1 /* ulFirstOperationWeight */,
86	NULL /* pId */);
87	}
88
89	/**
90	* Initialize for proxying one other progress object.
91	*
92	* This is tailored explicitly for the openRemoteSession code, so we start out
93	* with one operation where we don't have any remote object (powerUp). Then a
94	* remote object is added and stays with us till the end.
95	*
96	* The user must do normal completion notification or risk leave the threads
97	* waiting forever!
98	*/
99	HRESULT ProgressProxy::init(
100	#if !defined (VBOX_COM_INPROC)
101	VirtualBox *pParent,
102	#endif
103	IUnknown *pInitiator,
104	CBSTR bstrDescription,
105	BOOL fCancelable,
106	ULONG uTotalOperationsWeight,
107	CBSTR bstrFirstOperationDescription,
108	ULONG uFirstOperationWeight,
109	ULONG cOtherProgressObjectOperations)
110	{
111	mfMultiOperation = false;
112	muOtherProgressStartWeight = uFirstOperationWeight;
113	muOtherProgressWeight = uTotalOperationsWeight - uFirstOperationWeight;
114	muOtherProgressStartOperation = 1;
115
116	return Progress::init(
117	#if !defined (VBOX_COM_INPROC)
118	pParent,
119	#endif
120	pInitiator,
121	bstrDescription,
122	fCancelable,
123	1 + cOtherProgressObjectOperations /* cOperations */,
124	uTotalOperationsWeight,
125	bstrFirstOperationDescription,
126	uFirstOperationWeight,
127	NULL);
128	}
129
130	void ProgressProxy::FinalRelease()
131	{
132	uninit();
133	mfMultiOperation = false;
134	muOtherProgressStartWeight = 0;
135	muOtherProgressWeight = 0;
136	muOtherProgressStartOperation = 0;
137
138	BaseFinalRelease();
139	}
140
141	void ProgressProxy::uninit()
142	{
143	LogFlowThisFunc(("\n"));
144
145	mptrOtherProgress.setNull();
146	Progress::uninit();
147	}
148
149	// Public methods
150	////////////////////////////////////////////////////////////////////////////////
151
152	/** Just a wrapper so we can automatically do the handover before setting
153	* the result locally. */
154	HRESULT ProgressProxy::notifyComplete(HRESULT aResultCode)
155	{
156	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
157	clearOtherProgressObjectInternal(true /* fEarly */);
158	HRESULT hrc = S_OK;
159	if (!mCompleted)
160	hrc = Progress::notifyComplete(aResultCode);
161	return hrc;
162	}
163
164	/** Just a wrapper so we can automatically do the handover before setting
165	* the result locally. */
166	HRESULT ProgressProxy::notifyComplete(HRESULT aResultCode,
167	const GUID &aIID,
168	const char *pcszComponent,
169	const char *aText,
170	...)
171	{
172	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
173	clearOtherProgressObjectInternal(true /* fEarly */);
174
175	HRESULT hrc = S_OK;
176	if (!mCompleted)
177	{
178	va_list va;
179	va_start(va, aText);
180	hrc = Progress::notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
181	va_end(va);
182	}
183	return hrc;
184	}
185
186	/**
187	* Sets the other progress object unless the operation has been completed /
188	* canceled already.
189	*
190	* @returns false if failed/canceled, true if not.
191	* @param pOtherProgress The other progress object. Must not be NULL.
192	*/
193	bool ProgressProxy::setOtherProgressObject(IProgress *pOtherProgress)
194	{
195	LogFlowThisFunc(("setOtherProgressObject: %p\n", pOtherProgress));
196	ComPtr<IProgress> ptrOtherProgress = pOtherProgress;
197
198	/*
199	* Query information from the other progress object before we grab the
200	* lock.
201	*/
202	ULONG cOperations;
203	HRESULT hrc = pOtherProgress->COMGETTER(OperationCount)(&cOperations);
204	if (FAILED(hrc))
205	cOperations = 1;
206
207	Bstr bstrOperationDescription;
208	hrc = pOtherProgress->COMGETTER(Description)(bstrOperationDescription.asOutParam());
209	if (FAILED(hrc))
210	bstrOperationDescription = "oops";
211
212
213	/*
214	* Take the lock and check for cancelation, cancel the other object if
215	* we've been canceled already.
216	*/
217	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
218
219	BOOL fCompletedOrCanceled = mCompleted \|\| mCanceled;
220	if (!fCompletedOrCanceled)
221	{
222	/*
223	* Advance to the next object and operation. If the other object has
224	* more operations than anticipated, adjust our internal count.
225	*/
226	mptrOtherProgress = ptrOtherProgress;
227	mfMultiOperation = cOperations > 1;
228
229	muOtherProgressStartWeight = m_ulOperationsCompletedWeight + m_ulCurrentOperationWeight;
230	muOtherProgressWeight = m_ulTotalOperationsWeight - muOtherProgressStartWeight;
231	Progress::SetNextOperation(bstrOperationDescription.raw(), muOtherProgressWeight);
232
233	muOtherProgressStartOperation = m_ulCurrentOperation;
234	m_cOperations = cOperations + m_ulCurrentOperation;
235
236	/*
237	* Check for cancelation and completion.
238	*/
239	BOOL f;
240	hrc = ptrOtherProgress->COMGETTER(Completed)(&f);
241	fCompletedOrCanceled = FAILED(hrc) \|\| f;
242
243	if (!fCompletedOrCanceled)
244	{
245	hrc = ptrOtherProgress->COMGETTER(Canceled)(&f);
246	fCompletedOrCanceled = SUCCEEDED(hrc) && f;
247	}
248
249	if (fCompletedOrCanceled)
250	{
251	LogFlowThisFunc(("Other object completed or canceled, clearing...\n"));
252	clearOtherProgressObjectInternal(false /fEarly/);
253	}
254	else
255	{
256	/*
257	* Finally, mirror the cancelable property.
258	* Note! Note necessary if we do passthru!
259	*/
260	if (mCancelable)
261	{
262	hrc = ptrOtherProgress->COMGETTER(Cancelable)(&f);
263	if (SUCCEEDED(hrc) && !f)
264	{
265	LogFlowThisFunc(("The other progress object is not cancelable\n"));
266	mCancelable = FALSE;
267	}
268	}
269	}
270	}
271	else
272	{
273	LogFlowThisFunc(("mCompleted=%RTbool mCanceled=%RTbool - Canceling the other progress object!\n",
274	mCompleted, mCanceled));
275	hrc = ptrOtherProgress->Cancel();
276	LogFlowThisFunc(("Cancel -> %Rhrc", hrc));
277	}
278
279	LogFlowThisFunc(("Returns %RTbool\n", !fCompletedOrCanceled));
280	return !fCompletedOrCanceled;
281	}
282
283	// Internal methods.
284	////////////////////////////////////////////////////////////////////////////////
285
286
287	/**
288	* Clear the other progress object reference, first copying over its state.
289	*
290	* This is used internally when completion is signalled one way or another.
291	*
292	* @param fEarly Early clearing or not.
293	*/
294	void ProgressProxy::clearOtherProgressObjectInternal(bool fEarly)
295	{
296	if (!mptrOtherProgress.isNull())
297	{
298	ComPtr<IProgress> ptrOtherProgress = mptrOtherProgress;
299	mptrOtherProgress.setNull();
300	copyProgressInfo(ptrOtherProgress, fEarly);
301	}
302	}
303
304	/**
305	* Called to copy over the progress information from @a pOtherProgress.
306	*
307	* @param pOtherProgress The source of the information.
308	* @param fEarly Early copy.
309	*
310	* @note The caller owns the write lock and as cleared mptrOtherProgress
311	* already (or we might recurse forever)!
312	*/
313	void ProgressProxy::copyProgressInfo(IProgress *pOtherProgress, bool fEarly)
314	{
315	HRESULT hrc;
316	LogFlowThisFunc(("\n"));
317
318	NOREF(fEarly);
319
320	/*
321	* No point in doing this if the progress object was canceled already.
322	*/
323	if (!mCanceled)
324	{
325	/* Detect if the other progress object was canceled. */
326	BOOL fCanceled;
327	hrc = pOtherProgress->COMGETTER(Canceled)(&fCanceled);
328	if (FAILED(hrc))
329	fCanceled = FALSE;
330	if (fCanceled)
331	{
332	LogFlowThisFunc(("Canceled\n"));
333	mCanceled = TRUE;
334	if (m_pfnCancelCallback)
335	m_pfnCancelCallback(m_pvCancelUserArg);
336	}
337	else
338	{
339	/* Has it completed? */
340	BOOL fCompleted;
341	hrc = pOtherProgress->COMGETTER(Completed)(&fCompleted);
342	if (FAILED(hrc))
343	fCompleted = TRUE;
344	Assert(fCompleted \|\| fEarly);
345	if (fCompleted)
346	{
347	/* Check the result. */
348	LONG hrcResult;
349	hrc = pOtherProgress->COMGETTER(ResultCode)(&hrcResult);
350	if (FAILED(hrc))
351	hrcResult = hrc;
352	if (SUCCEEDED((HRESULT)hrcResult))
353	LogFlowThisFunc(("Succeeded\n"));
354	else
355	{
356	/* Get the error information. */
357	ComPtr<IVirtualBoxErrorInfo> ptrErrorInfo;
358	hrc = pOtherProgress->COMGETTER(ErrorInfo)(ptrErrorInfo.asOutParam());
359	if (SUCCEEDED(hrc) && !ptrErrorInfo.isNull())
360	{
361	Bstr bstrIID;
362	hrc = ptrErrorInfo->COMGETTER(InterfaceID)(bstrIID.asOutParam()); AssertComRC(hrc);
363	if (FAILED(hrc))
364	bstrIID.setNull();
365
366	Bstr bstrComponent;
367	hrc = ptrErrorInfo->COMGETTER(Component)(bstrComponent.asOutParam()); AssertComRC(hrc);
368	if (FAILED(hrc))
369	bstrComponent = "failed";
370
371	Bstr bstrText;
372	hrc = ptrErrorInfo->COMGETTER(Text)(bstrText.asOutParam()); AssertComRC(hrc);
373	if (FAILED(hrc))
374	bstrText = "<failed>";
375
376	Utf8Str strText(bstrText);
377	LogFlowThisFunc(("Got ErrorInfo(%s); hrcResult=%Rhrc\n", strText.c_str(), hrcResult));
378	Progress::notifyComplete((HRESULT)hrcResult,
379	Guid(bstrIID).ref(),
380	Utf8Str(bstrComponent).c_str(),
381	"%s", strText.c_str());
382	}
383	else
384	{
385	LogFlowThisFunc(("ErrorInfo failed with hrc=%Rhrc; hrcResult=%Rhrc\n", hrc, hrcResult));
386	Progress::notifyComplete((HRESULT)hrcResult,
387	COM_IIDOF(IProgress),
388	"ProgressProxy",
389	tr("No error info"));
390	}
391	}
392	}
393	else
394	LogFlowThisFunc(("Not completed\n"));
395	}
396	}
397	else
398	LogFlowThisFunc(("Already canceled\n"));
399
400	/*
401	* Did cancelable state change (point of no return)?
402	*/
403	if (mCancelable && !mCompleted && !mCanceled)
404	{
405	BOOL fCancelable;
406	hrc = pOtherProgress->COMGETTER(Cancelable)(&fCancelable); AssertComRC(hrc);
407	if (SUCCEEDED(hrc) && !fCancelable)
408	{
409	LogFlowThisFunc(("point-of-no-return reached\n"));
410	mCancelable = FALSE;
411	}
412	}
413	}
414
415
416	// IProgress properties
417	////////////////////////////////////////////////////////////////////////////////
418
419	STDMETHODIMP ProgressProxy::COMGETTER(Cancelable)(BOOL *aCancelable)
420	{
421	CheckComArgOutPointerValid(aCancelable);
422
423	AutoCaller autoCaller(this);
424	HRESULT hrc = autoCaller.rc();
425	if (SUCCEEDED(hrc))
426	{
427	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
428
429	/* ASSUME: The cancelable property can only change to FALSE. */
430	if (!mCancelable \|\| mptrOtherProgress.isNull())
431	*aCancelable = mCancelable;
432	else
433	{
434	hrc = mptrOtherProgress->COMGETTER(Cancelable)(aCancelable);
435	if (SUCCEEDED(hrc) && !*aCancelable)
436	{
437	LogFlowThisFunc(("point-of-no-return reached\n"));
438	mCancelable = FALSE;
439	}
440	}
441	}
442	return hrc;
443	}
444
445	STDMETHODIMP ProgressProxy::COMGETTER(Percent)(ULONG *aPercent)
446	{
447	CheckComArgOutPointerValid(aPercent);
448
449	AutoCaller autoCaller(this);
450	HRESULT hrc = autoCaller.rc();
451	if (SUCCEEDED(hrc))
452	{
453	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
454
455	if (mptrOtherProgress.isNull())
456	hrc = Progress::COMGETTER(Percent)(aPercent);
457	else
458	{
459	/*
460	* Get the overall percent of the other object and adjust it with
461	* the weighting given to the period before proxying started.
462	*/
463	ULONG uPct;
464	hrc = mptrOtherProgress->COMGETTER(Percent)(&uPct);
465	if (SUCCEEDED(hrc))
466	{
467	double rdPercent = ((double)uPct / 100 * muOtherProgressWeight + muOtherProgressStartWeight)
468	/ m_ulTotalOperationsWeight * 100;
469	aPercent = RT_MIN((ULONG)rdPercent, 99); / mptrOtherProgress is cleared when its completed, so we can never return 100%. */
470	}
471	}
472	}
473	return hrc;
474	}
475
476	STDMETHODIMP ProgressProxy::COMGETTER(TimeRemaining)(LONG *aTimeRemaining)
477	{
478	CheckComArgOutPointerValid(aTimeRemaining);
479
480	AutoCaller autoCaller(this);
481	HRESULT hrc = autoCaller.rc();
482	if (SUCCEEDED(hrc))
483	{
484	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
485
486	if (mptrOtherProgress.isNull())
487	hrc = Progress::COMGETTER(TimeRemaining)(aTimeRemaining);
488	else
489	hrc = mptrOtherProgress->COMGETTER(TimeRemaining)(aTimeRemaining);
490	}
491	return hrc;
492	}
493
494	STDMETHODIMP ProgressProxy::COMGETTER(Completed)(BOOL *aCompleted)
495	{
496	/* Not proxied since we EXPECT a normal completion notification call. */
497	return Progress::COMGETTER(Completed)(aCompleted);
498	}
499
500	STDMETHODIMP ProgressProxy::COMGETTER(Canceled)(BOOL *aCanceled)
501	{
502	CheckComArgOutPointerValid(aCanceled);
503
504	AutoCaller autoCaller(this);
505	HRESULT hrc = autoCaller.rc();
506	if (SUCCEEDED(hrc))
507	{
508	/* Check the local data first, then the other object. */
509	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
510	hrc = Progress::COMGETTER(Canceled)(aCanceled);
511	if ( SUCCEEDED(hrc)
512	&& !*aCanceled
513	&& !mptrOtherProgress.isNull()
514	&& mCancelable)
515	{
516	hrc = mptrOtherProgress->COMGETTER(Canceled)(aCanceled);
517	if (SUCCEEDED(hrc) && *aCanceled)
518	/* This will not complete the object, only mark it as canceled. */
519	clearOtherProgressObjectInternal(false /fEarly/);
520	}
521	}
522	return hrc;
523	}
524
525	STDMETHODIMP ProgressProxy::COMGETTER(ResultCode)(LONG *aResultCode)
526	{
527	/* Not proxied since we EXPECT a normal completion notification call. */
528	return Progress::COMGETTER(ResultCode)(aResultCode);
529	}
530
531	STDMETHODIMP ProgressProxy::COMGETTER(ErrorInfo)(IVirtualBoxErrorInfo **aErrorInfo)
532	{
533	/* Not proxied since we EXPECT a normal completion notification call. */
534	return Progress::COMGETTER(ErrorInfo)(aErrorInfo);
535	}
536
537	STDMETHODIMP ProgressProxy::COMGETTER(Operation)(ULONG *aOperation)
538	{
539	CheckComArgOutPointerValid(aOperation);
540
541	AutoCaller autoCaller(this);
542	HRESULT hrc = autoCaller.rc();
543	if (SUCCEEDED(hrc))
544	{
545	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
546	if (mptrOtherProgress.isNull())
547	hrc = Progress::COMGETTER(Operation)(aOperation);
548	else
549	{
550	ULONG uCurOtherOperation;
551	hrc = mptrOtherProgress->COMGETTER(Operation)(&uCurOtherOperation);
552	if (SUCCEEDED(hrc))
553	*aOperation = uCurOtherOperation + muOtherProgressStartOperation;
554	}
555	}
556	return hrc;
557	}
558
559	STDMETHODIMP ProgressProxy::COMGETTER(OperationDescription)(BSTR *aOperationDescription)
560	{
561	CheckComArgOutPointerValid(aOperationDescription);
562
563	AutoCaller autoCaller(this);
564	HRESULT hrc = autoCaller.rc();
565	if (SUCCEEDED(hrc))
566	{
567	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
568	if (mptrOtherProgress.isNull() \|\| !mfMultiOperation)
569	hrc = Progress::COMGETTER(OperationDescription)(aOperationDescription);
570	else
571	hrc = mptrOtherProgress->COMGETTER(OperationDescription)(aOperationDescription);
572	}
573	return hrc;
574	}
575
576	STDMETHODIMP ProgressProxy::COMGETTER(OperationPercent)(ULONG *aOperationPercent)
577	{
578	CheckComArgOutPointerValid(aOperationPercent);
579
580	AutoCaller autoCaller(this);
581	HRESULT hrc = autoCaller.rc();
582	if (SUCCEEDED(hrc))
583	{
584	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
585	if (mptrOtherProgress.isNull() \|\| !mfMultiOperation)
586	hrc = Progress::COMGETTER(OperationPercent)(aOperationPercent);
587	else
588	hrc = mptrOtherProgress->COMGETTER(OperationPercent)(aOperationPercent);
589	}
590	return hrc;
591	}
592
593	STDMETHODIMP ProgressProxy::COMSETTER(Timeout)(ULONG aTimeout)
594	{
595	/* Not currently supported. */
596	NOREF(aTimeout);
597	AssertFailed();
598	return E_NOTIMPL;
599	}
600
601	STDMETHODIMP ProgressProxy::COMGETTER(Timeout)(ULONG *aTimeout)
602	{
603	/* Not currently supported. */
604	CheckComArgOutPointerValid(aTimeout);
605
606	AssertFailed();
607	return E_NOTIMPL;
608	}
609
610	// IProgress methods
611	/////////////////////////////////////////////////////////////////////////////
612
613	STDMETHODIMP ProgressProxy::WaitForCompletion(LONG aTimeout)
614	{
615	HRESULT hrc;
616	LogFlowThisFuncEnter();
617	LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
618
619	/* No need to wait on the proxied object for these since we'll get the
620	normal completion notifications. */
621	hrc = Progress::WaitForCompletion(aTimeout);
622
623	LogFlowThisFuncLeave();
624	return hrc;
625	}
626
627	STDMETHODIMP ProgressProxy::WaitForOperationCompletion(ULONG aOperation, LONG aTimeout)
628	{
629	LogFlowThisFuncEnter();
630	LogFlowThisFunc(("aOperation=%d aTimeout=%d\n", aOperation, aTimeout));
631
632	AutoCaller autoCaller(this);
633	HRESULT hrc = autoCaller.rc();
634	if (SUCCEEDED(hrc))
635	{
636	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
637
638	CheckComArgExpr(aOperation, aOperation < m_cOperations);
639
640	/*
641	* Check if we can wait locally.
642	*/
643	if ( aOperation + 1 == m_cOperations /* final operation */
644	\|\| mptrOtherProgress.isNull())
645	{
646	/* ASSUMES that Progress::WaitForOperationCompletion is using
647	AutoWriteLock::leave() as it saves us from duplicating the code! */
648	hrc = Progress::WaitForOperationCompletion(aOperation, aTimeout);
649	}
650	else
651	{
652	LogFlowThisFunc(("calling the other object...\n"));
653	ComPtr<IProgress> ptrOtherProgress = mptrOtherProgress;
654	alock.release();
655
656	hrc = ptrOtherProgress->WaitForOperationCompletion(aOperation, aTimeout);
657	}
658	}
659
660	LogFlowThisFuncLeave();
661	return hrc;
662	}
663
664	STDMETHODIMP ProgressProxy::Cancel()
665	{
666	LogFlowThisFunc(("\n"));
667	AutoCaller autoCaller(this);
668	HRESULT hrc = autoCaller.rc();
669	if (SUCCEEDED(hrc))
670	{
671	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
672	if (mptrOtherProgress.isNull() \|\| !mCancelable)
673	hrc = Progress::Cancel();
674	else
675	{
676	hrc = mptrOtherProgress->Cancel();
677	if (SUCCEEDED(hrc))
678	clearOtherProgressObjectInternal(false /fEarly/);
679	}
680	}
681
682	LogFlowThisFunc(("returns %Rhrc\n", hrc));
683	return hrc;
684	}
685
686	STDMETHODIMP ProgressProxy::SetCurrentOperationProgress(ULONG aPercent)
687	{
688	/* Not supported - why do we actually expose this? */
689	NOREF(aPercent);
690	return E_NOTIMPL;
691	}
692
693	STDMETHODIMP ProgressProxy::SetNextOperation(IN_BSTR bstrNextOperationDescription, ULONG ulNextOperationsWeight)
694	{
695	/* Not supported - why do we actually expose this? */
696	NOREF(bstrNextOperationDescription);
697	NOREF(ulNextOperationsWeight);
698	return E_NOTIMPL;
699	}
700
701	/* vi: set tabstop=4 shiftwidth=4 expandtab: */
702

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

source: vbox/trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp@ 44529

Download in other formats: