VirtualBox

source: vbox/trunk/src/VBox/Main/include/ProgressImpl.h@ 73768

Last change on this file since 73768 was 73743, checked in by vboxsync, 6 years ago

Main/Progress+Appliance+Machine: Turn IProgress::waitForAsyncProgressCompletion into an internal method. It is not needed by any client code outside the API, it's simply is too special. Also include the error propagation which it originally skipped (leding to reduntant code in the calling code). Remove a replicated version of it from the Appliance code which seems to be the half-forgotten ancestor of the method in IProgress. Adapt the users of the method to the new internal method, which made the code easier to read.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.9 KB
Line 
1/* $Id: ProgressImpl.h 73743 2018-08-17 17:56:34Z vboxsync $ */
2/** @file
3 *
4 * VirtualBox COM class implementation
5 */
6
7/*
8 * Copyright (C) 2006-2017 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#ifndef ____H_PROGRESSIMPL
20#define ____H_PROGRESSIMPL
21
22#include "ProgressWrap.h"
23#include "VirtualBoxBase.h"
24#include "EventImpl.h"
25
26#include <iprt/semaphore.h>
27
28////////////////////////////////////////////////////////////////////////////////
29
30/**
31 * Class for progress objects.
32 */
33class ATL_NO_VTABLE Progress :
34 public ProgressWrap
35{
36public:
37 DECLARE_NOT_AGGREGATABLE(Progress)
38
39 HRESULT FinalConstruct();
40 void FinalRelease();
41
42 // public initializer/uninitializer for internal purposes only
43
44 /**
45 * Simplified constructor for progress objects that have only one
46 * operation as a task.
47 * @param aParent
48 * @param aInitiator
49 * @param aDescription
50 * @param aCancelable
51 * @return
52 */
53 HRESULT init(
54#if !defined(VBOX_COM_INPROC)
55 VirtualBox *aParent,
56#endif
57 IUnknown *aInitiator,
58 Utf8Str aDescription,
59 BOOL aCancelable)
60 {
61 return init(
62#if !defined(VBOX_COM_INPROC)
63 aParent,
64#endif
65 aInitiator,
66 aDescription,
67 aCancelable,
68 1, // cOperations
69 1, // ulTotalOperationsWeight
70 aDescription, // aFirstOperationDescription
71 1); // ulFirstOperationWeight
72 }
73
74 /**
75 * Not quite so simplified constructor for progress objects that have
76 * more than one operation, but all sub-operations are weighed the same.
77 * @param aParent
78 * @param aInitiator
79 * @param aDescription
80 * @param aCancelable
81 * @param cOperations
82 * @param aFirstOperationDescription
83 * @return
84 */
85 HRESULT init(
86#if !defined(VBOX_COM_INPROC)
87 VirtualBox *aParent,
88#endif
89 IUnknown *aInitiator,
90 Utf8Str aDescription, BOOL aCancelable,
91 ULONG cOperations,
92 Utf8Str aFirstOperationDescription)
93 {
94 return init(
95#if !defined(VBOX_COM_INPROC)
96 aParent,
97#endif
98 aInitiator,
99 aDescription,
100 aCancelable,
101 cOperations, // cOperations
102 cOperations, // ulTotalOperationsWeight = cOperations
103 aFirstOperationDescription, // aFirstOperationDescription
104 1); // ulFirstOperationWeight: weigh them all the same
105 }
106
107 HRESULT init(
108#if !defined(VBOX_COM_INPROC)
109 VirtualBox *aParent,
110#endif
111 IUnknown *aInitiator,
112 Utf8Str aDescription,
113 BOOL aCancelable,
114 ULONG cOperations,
115 ULONG ulTotalOperationsWeight,
116 Utf8Str aFirstOperationDescription,
117 ULONG ulFirstOperationWeight);
118
119 HRESULT init(BOOL aCancelable,
120 ULONG aOperationCount,
121 Utf8Str aOperationDescription);
122
123 void uninit();
124
125
126 // public methods only for internal purposes
127 HRESULT i_notifyComplete(HRESULT aResultCode);
128 HRESULT i_notifyComplete(HRESULT aResultCode,
129 const GUID &aIID,
130 const char *pcszComponent,
131 const char *aText,
132 ...);
133 HRESULT i_notifyCompleteV(HRESULT aResultCode,
134 const GUID &aIID,
135 const char *pcszComponent,
136 const char *aText,
137 va_list va);
138 HRESULT i_notifyCompleteEI(HRESULT aResultCode,
139 const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
140 /**
141 * Waits until the other task is completed (including all sub-operations)
142 * and forward all changes from the other progress to this progress. This
143 * means sub-operation number, description, percent and so on.
144 *
145 * The caller is responsible for having at least the same count of
146 * sub-operations in this progress object as there are in the other
147 * progress object.
148 *
149 * If the other progress object supports cancel and this object gets any
150 * cancel request (when here enabled as well), it will be forwarded to
151 * the other progress object.
152 *
153 * Error information is automatically preserved (by transferring it to
154 * the current thread's error information). If the caller wants to set it
155 * as the completion state of this progress it needs to be done separately.
156 *
157 * @param aProgressOther Progress object from which the state is
158 * forwarded until it is signalling completion.
159 * @return COM error status, also reflecting the failed completion.
160 */
161 HRESULT i_waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther);
162
163 bool i_notifyPointOfNoReturn(void);
164 bool i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser);
165
166 static DECLCALLBACK(int) i_iprtProgressCallback(unsigned uPercentage, void *pvUser);
167 static DECLCALLBACK(int) i_vdProgressCallback(void *pvUser, unsigned uPercentage);
168
169protected:
170 DECLARE_EMPTY_CTOR_DTOR(Progress)
171
172#if !defined(VBOX_COM_INPROC)
173 /** Weak parent. */
174 VirtualBox * const mParent;
175#endif
176 const ComObjPtr<EventSource> pEventSource;
177 const ComPtr<IUnknown> mInitiator;
178
179 const Guid mId;
180 const com::Utf8Str mDescription;
181
182 uint64_t m_ullTimestamp; // progress object creation timestamp, for ETA computation
183
184 void (*m_pfnCancelCallback)(void *);
185 void *m_pvCancelUserArg;
186
187 /* The fields below are to be properly initialized by subclasses */
188
189 BOOL mCompleted;
190 BOOL mCancelable;
191 BOOL mCanceled;
192 HRESULT mResultCode;
193 ComPtr<IVirtualBoxErrorInfo> mErrorInfo;
194
195 ULONG m_cOperations; // number of operations (so that progress dialog can
196 // display something like 1/3)
197 ULONG m_ulTotalOperationsWeight; // sum of weights of all operations, given to constructor
198
199 ULONG m_ulOperationsCompletedWeight; // summed-up weight of operations that have been completed; initially 0
200
201 ULONG m_ulCurrentOperation; // operations counter, incremented with
202 // each setNextOperation()
203 com::Utf8Str m_operationDescription; // name of current operation; initially
204 // from constructor, changed with setNextOperation()
205 ULONG m_ulCurrentOperationWeight; // weight of current operation, given to setNextOperation()
206 ULONG m_ulOperationPercent; // percentage of current operation, set with setCurrentOperationProgress()
207 ULONG m_cMsTimeout; /**< Automatic timeout value. 0 means none. */
208
209private:
210 // wrapped IProgress properties
211 HRESULT getId(com::Guid &aId);
212 HRESULT getDescription(com::Utf8Str &aDescription);
213 HRESULT getInitiator(ComPtr<IUnknown> &aInitiator);
214 HRESULT getCancelable(BOOL *aCancelable);
215 HRESULT getPercent(ULONG *aPercent);
216 HRESULT getTimeRemaining(LONG *aTimeRemaining);
217 HRESULT getCompleted(BOOL *aCompleted);
218 HRESULT getCanceled(BOOL *aCanceled);
219 HRESULT getResultCode(LONG *aResultCode);
220 HRESULT getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
221 HRESULT getOperationCount(ULONG *aOperationCount);
222 HRESULT getOperation(ULONG *aOperation);
223 HRESULT getOperationDescription(com::Utf8Str &aOperationDescription);
224 HRESULT getOperationPercent(ULONG *aOperationPercent);
225 HRESULT getOperationWeight(ULONG *aOperationWeight);
226 HRESULT getTimeout(ULONG *aTimeout);
227 HRESULT setTimeout(ULONG aTimeout);
228 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
229
230 // wrapped IProgress methods
231 HRESULT setCurrentOperationProgress(ULONG aPercent);
232 HRESULT setNextOperation(const com::Utf8Str &aNextOperationDescription,
233 ULONG aNextOperationsWeight);
234 HRESULT waitForCompletion(LONG aTimeout);
235 HRESULT waitForOperationCompletion(ULONG aOperation,
236 LONG aTimeout);
237 HRESULT cancel();
238
239 // internal helper methods
240 double i_calcTotalPercent();
241 void i_checkForAutomaticTimeout(void);
242
243 RTSEMEVENTMULTI mCompletedSem;
244 ULONG mWaitersCount;
245
246private:
247 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Progress); /* Shuts up MSC warning C4625. */
248};
249
250#endif /* ____H_PROGRESSIMPL */
251
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use