Changeset 74804 in vbox for trunk/src/VBox/Main/src-all

Timestamp:

Oct 12, 2018 3:09:44 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

125752

Message:

Main/Progress: Split into safe public interface and a private one which is used purely by API implementation code (for updating). Needed quite a few minor adjustments elsewhere.

Location:

trunk/src/VBox/Main/src-all

Files:

• ExtPackManagerImpl.cpp (modified) (4 diffs)
• ProgressImpl.cpp (modified) (7 diffs)

trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp

@@ -1810 +1810 @@
     AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
 
-    return pProgress->SetCurrentOperationProgress(uPercent);
+    ComPtr<IInternalProgressControl> pProgressControl(pProgress);
+    AssertReturn(!!pProgressControl, E_INVALIDARG);
+    return pProgressControl->SetCurrentOperationProgress(uPercent);
 }
 
@@ -1828 +1830 @@
     AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
 
-    return pProgress->SetNextOperation(Bstr(pcszNextOperationDescription).raw(), uNextOperationWeight);
+    ComPtr<IInternalProgressControl> pProgressControl(pProgress);
+    AssertReturn(!!pProgressControl, E_INVALIDARG);
+    return pProgressControl->SetNextOperation(Bstr(pcszNextOperationDescription).raw(), uNextOperationWeight);
 }
 
 /*static*/ DECLCALLBACK(uint32_t)
 ExtPack::i_hlpWaitOtherProgress(PCVBOXEXTPACKHLP pHlp, VBOXEXTPACK_IF_CS(IProgress) *pProgress,
-                                VBOXEXTPACK_IF_CS(IProgress) *pProgressOther)
+                                VBOXEXTPACK_IF_CS(IProgress) *pProgressOther, uint32_t cTimeoutMS)
 {
     /*
@@ -1844 +1848 @@
     AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
 
-    Progress *pProgressInt = static_cast<Progress *>(pProgress);
-    return pProgressInt->i_waitForOtherProgressCompletion(pProgressOther);
+    ComPtr<IInternalProgressControl> pProgressControl(pProgress);
+    AssertReturn(!!pProgressControl, E_INVALIDARG);
+    return pProgressControl->WaitForOtherProgressCompletion(pProgressOther, cTimeoutMS);
 }
 
@@ -1860 +1865 @@
     AssertReturn(pHlp->u32Version == VBOXEXTPACKHLP_VERSION, (uint32_t)E_INVALIDARG);
 
-    Progress *pProgressInt = static_cast<Progress *>(pProgress);
-    return pProgressInt->i_notifyComplete(uResultCode);
+    ComPtr<IInternalProgressControl> pProgressControl(pProgress);
+    AssertReturn(!!pProgressControl, E_INVALIDARG);
+
+    ComPtr<IVirtualBoxErrorInfo> errorInfo;
+    if (FAILED((HRESULT)uResultCode))
+    {
+        ErrorInfoKeeper eik;
+        eik.getVirtualBoxErrorInfo(errorInfo);
+    }
+    return pProgressControl->NotifyComplete(uResultCode, errorInfo);
 }
 

trunk/src/VBox/Main/src-all/ProgressImpl.cpp

@@ -370 +370 @@
     }
 
-    return i_notifyCompleteEI(aResultCode, errorInfo);
+    return notifyComplete(aResultCode, errorInfo);
 }
 
@@ -414 +414 @@
     errorInfo->init(aResultCode, aIID, pcszComponent, text);
 
-    return i_notifyCompleteEI(aResultCode, errorInfo);
-}
-
-/**
- * Marks the operation as complete and attaches full error info.
- *
- * This is where the actual work is done, the related methods all end up here.
- *
- * @param aResultCode   Operation result (error) code, must not be S_OK.
- * @param aErrorInfo            List of arguments for the format string.
- */
-HRESULT Progress::i_notifyCompleteEI(HRESULT aResultCode, const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
-{
-    LogThisFunc(("aResultCode=%d\n", aResultCode));
-    /* on failure we expect error info, on success there must be none */
-    AssertMsg(FAILED(aResultCode) ^ aErrorInfo.isNull(),
-              ("No error info but trying to set a failed result (%08X)!\n",
-               aResultCode));
-
+    return notifyComplete(aResultCode, errorInfo);
+}
+
+/**
+ * Sets the cancelation callback, checking for cancelation first.
+ *
+ * @returns Success indicator.
+ * @retval  true on success.
+ * @retval  false if the progress object has already been canceled or is in an
+ *          invalid state
+ *
+ * @param   pfnCallback     The function to be called upon cancelation.
+ * @param   pvUser          The callback argument.
+ */
+bool Progress::i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser)
+{
     AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+    AssertComRCReturn(autoCaller.rc(), false);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    AssertReturn(mCompleted == FALSE, E_FAIL);
-
-    if (mCanceled && SUCCEEDED(aResultCode))
-        aResultCode = E_FAIL;
-
-    mCompleted = TRUE;
-    mResultCode = aResultCode;
-    if (SUCCEEDED(aResultCode))
-    {
-        m_ulCurrentOperation = m_cOperations - 1; /* last operation */
-        m_ulOperationPercent = 100;
-    }
-    mErrorInfo = aErrorInfo;
-
+    i_checkForAutomaticTimeout();
+    if (mCanceled)
+        return false;
+
+    m_pvCancelUserArg   = pvUser;
+    m_pfnCancelCallback = pfnCallback;
+    return true;
+}
+
+/**
+ * @callback_method_impl{FNRTPROGRESS,
+ *      Works the progress of the current operation.}
+ */
+/*static*/ DECLCALLBACK(int) Progress::i_iprtProgressCallback(unsigned uPercentage, void *pvUser)
+{
+    Progress *pThis = (Progress *)pvUser;
+
+    /*
+     * Same as setCurrentOperationProgress, except we don't fail on mCompleted.
+     */
+    AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
+    int vrc = VINF_SUCCESS;
+    if (!pThis->mCompleted)
+    {
+        pThis->i_checkForAutomaticTimeout();
+        if (!pThis->mCanceled)
+        {
+            if (uPercentage > pThis->m_ulOperationPercent)
+                pThis->setCurrentOperationProgress(uPercentage);
+        }
+        else
+        {
+            Assert(pThis->mCancelable);
+            vrc = VERR_CANCELLED;
+        }
+    }
+    /* else ignored */
+    return vrc;
+}
+
+/**
+ * @callback_method_impl{FNVDPROGRESS,
+ *      Progress::i_iprtProgressCallback with parameters switched around.}
+ */
+/*static*/ DECLCALLBACK(int) Progress::i_vdProgressCallback(void *pvUser, unsigned uPercentage)
+{
+    return i_iprtProgressCallback(uPercentage, pvUser);
+}
+
+
+// IProgress properties
+/////////////////////////////////////////////////////////////////////////////
+
+HRESULT Progress::getId(com::Guid &aId)
+{
+    /* mId is constant during life time, no need to lock */
+    aId = mId;
+
+    return S_OK;
+}
+
+HRESULT Progress::getDescription(com::Utf8Str &aDescription)
+{
+    /* mDescription is constant during life time, no need to lock */
+    aDescription = mDescription;
+
+    return S_OK;
+}
+HRESULT Progress::getInitiator(ComPtr<IUnknown> &aInitiator)
+{
+    /* mInitiator/mParent are constant during life time, no need to lock */
 #if !defined(VBOX_COM_INPROC)
-    /* remove from the global collection of pending progress operations */
-    if (mParent)
-        mParent->i_removeProgress(mId.ref());
+    if (mInitiator)
+        mInitiator.queryInterfaceTo(aInitiator.asOutParam());
+    else
+    {
+        ComObjPtr<VirtualBox> pVirtualBox(mParent);
+        pVirtualBox.queryInterfaceTo(aInitiator.asOutParam());
+    }
+#else
+    mInitiator.queryInterfaceTo(aInitiator.asOutParam());
 #endif
 
-    /* wake up all waiting threads */
-    if (mWaitersCount > 0)
-        RTSemEventMultiSignal(mCompletedSem);
-
-    fireProgressTaskCompletedEvent(pEventSource, mId.toUtf16().raw());
-
-    return S_OK;
-}
-
-HRESULT Progress::i_waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther)
+    return S_OK;
+}
+
+HRESULT Progress::getCancelable(BOOL *aCancelable)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aCancelable = mCancelable;
+
+    return S_OK;
+}
+
+HRESULT Progress::getPercent(ULONG *aPercent)
+{
+    /* i_checkForAutomaticTimeout requires a write lock. */
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mCompleted && SUCCEEDED(mResultCode))
+        *aPercent = 100;
+    else
+    {
+        ULONG ulPercent = (ULONG)i_calcTotalPercent();
+        // do not report 100% until we're really really done with everything
+        // as the Qt GUI dismisses progress dialogs in that case
+        if (    ulPercent == 100
+             && (    m_ulOperationPercent < 100
+                  || (m_ulCurrentOperation < m_cOperations -1)
+                )
+           )
+            *aPercent = 99;
+        else
+            *aPercent = ulPercent;
+    }
+
+    i_checkForAutomaticTimeout();
+
+    return S_OK;
+}
+
+HRESULT Progress::getTimeRemaining(LONG *aTimeRemaining)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mCompleted)
+        *aTimeRemaining = 0;
+    else
+    {
+        double dPercentDone = i_calcTotalPercent();
+        if (dPercentDone < 1)
+            *aTimeRemaining = -1;       // unreliable, or avoid division by 0 below
+        else
+        {
+            uint64_t ullTimeNow = RTTimeMilliTS();
+            uint64_t ullTimeElapsed = ullTimeNow - m_ullTimestamp;
+            uint64_t ullTimeTotal = (uint64_t)((double)ullTimeElapsed * 100 / dPercentDone);
+            uint64_t ullTimeRemaining = ullTimeTotal - ullTimeElapsed;
+
+//          LogFunc(("dPercentDone = %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
+//                   (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
+
+            *aTimeRemaining = (LONG)(ullTimeRemaining / 1000);
+        }
+    }
+
+    return S_OK;
+}
+
+HRESULT Progress::getCompleted(BOOL *aCompleted)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aCompleted = mCompleted;
+
+    return S_OK;
+}
+
+HRESULT Progress::getCanceled(BOOL *aCanceled)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aCanceled = mCanceled;
+
+    return S_OK;
+}
+
+HRESULT Progress::getResultCode(LONG *aResultCode)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (!mCompleted)
+        return setError(E_FAIL, tr("Result code is not available, operation is still in progress"));
+
+    *aResultCode = mResultCode;
+
+    return S_OK;
+}
+
+HRESULT Progress::getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (!mCompleted)
+        return setError(E_FAIL, tr("Error info is not available, operation is still in progress"));
+
+    mErrorInfo.queryInterfaceTo(aErrorInfo.asOutParam());
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationCount(ULONG *aOperationCount)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aOperationCount = m_cOperations;
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperation(ULONG *aOperation)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aOperation = m_ulCurrentOperation;
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationDescription(com::Utf8Str &aOperationDescription)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    aOperationDescription = m_operationDescription;
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationPercent(ULONG *aOperationPercent)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mCompleted && SUCCEEDED(mResultCode))
+        *aOperationPercent = 100;
+    else
+        *aOperationPercent = m_ulOperationPercent;
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationWeight(ULONG *aOperationWeight)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aOperationWeight = m_ulCurrentOperationWeight;
+
+    return S_OK;
+}
+
+HRESULT Progress::getTimeout(ULONG *aTimeout)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aTimeout = m_cMsTimeout;
+
+    return S_OK;
+}
+
+HRESULT Progress::setTimeout(ULONG aTimeout)
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (!mCancelable)
+        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
+    m_cMsTimeout = aTimeout;
+
+    return S_OK;
+}
+
+HRESULT Progress::getEventSource(ComPtr<IEventSource> &aEventSource)
+{
+    /* event source is const, no need to lock */
+    pEventSource.queryInterfaceTo(aEventSource.asOutParam());
+    return S_OK;
+}
+
+
+// IProgress methods
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @note XPCOM: when this method is not called on the main XPCOM thread, it
+ *       simply blocks the thread until mCompletedSem is signalled. If the
+ *       thread has its own event queue (hmm, what for?) that it must run, then
+ *       calling this method will definitely freeze event processing.
+ */
+HRESULT Progress::waitForCompletion(LONG aTimeout)
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* if we're already completed, take a shortcut */
+    if (!mCompleted)
+    {
+        int vrc = VINF_SUCCESS;
+        bool fForever = aTimeout < 0;
+        int64_t timeLeft = aTimeout;
+        int64_t lastTime = RTTimeMilliTS();
+
+        while (!mCompleted && (fForever || timeLeft > 0))
+        {
+            mWaitersCount++;
+            alock.release();
+            vrc = RTSemEventMultiWait(mCompletedSem,
+                                      fForever ? RT_INDEFINITE_WAIT : (RTMSINTERVAL)timeLeft);
+            alock.acquire();
+            mWaitersCount--;
+
+            /* the last waiter resets the semaphore */
+            if (mWaitersCount == 0)
+                RTSemEventMultiReset(mCompletedSem);
+
+            if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
+                break;
+
+            if (!fForever)
+            {
+                int64_t now = RTTimeMilliTS();
+                timeLeft -= now - lastTime;
+                lastTime = now;
+            }
+        }
+
+        if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
+            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to wait for the task completion (%Rrc)"), vrc);
+    }
+
+    LogFlowThisFuncLeave();
+
+    return S_OK;
+}
+
+/**
+ * @note XPCOM: when this method is not called on the main XPCOM thread, it
+ *       simply blocks the thread until mCompletedSem is signalled. If the
+ *       thread has its own event queue (hmm, what for?) that it must run, then
+ *       calling this method will definitely freeze event processing.
+ */
+HRESULT Progress::waitForOperationCompletion(ULONG aOperation, LONG aTimeout)
+
+{
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("aOperation=%d, aTimeout=%d\n", aOperation, aTimeout));
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    CheckComArgExpr(aOperation, aOperation < m_cOperations);
+
+    /* if we're already completed or if the given operation is already done,
+     * then take a shortcut */
+    if (    !mCompleted
+         && aOperation >= m_ulCurrentOperation)
+    {
+        int vrc = VINF_SUCCESS;
+        bool fForever = aTimeout < 0;
+        int64_t timeLeft = aTimeout;
+        int64_t lastTime = RTTimeMilliTS();
+
+        while (    !mCompleted && aOperation >= m_ulCurrentOperation
+                && (fForever || timeLeft > 0))
+        {
+            mWaitersCount ++;
+            alock.release();
+            vrc = RTSemEventMultiWait(mCompletedSem,
+                                      fForever ? RT_INDEFINITE_WAIT : (unsigned) timeLeft);
+            alock.acquire();
+            mWaitersCount--;
+
+            /* the last waiter resets the semaphore */
+            if (mWaitersCount == 0)
+                RTSemEventMultiReset(mCompletedSem);
+
+            if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
+                break;
+
+            if (!fForever)
+            {
+                int64_t now = RTTimeMilliTS();
+                timeLeft -= now - lastTime;
+                lastTime = now;
+            }
+        }
+
+        if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
+            return setErrorBoth(E_FAIL, vrc, tr("Failed to wait for the operation completion (%Rrc)"), vrc);
+    }
+
+    LogFlowThisFuncLeave();
+
+    return S_OK;
+}
+
+HRESULT Progress::cancel()
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (!mCancelable)
+        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
+
+    if (!mCanceled)
+    {
+        LogThisFunc(("Canceling\n"));
+        mCanceled = TRUE;
+        if (m_pfnCancelCallback)
+            m_pfnCancelCallback(m_pvCancelUserArg);
+
+    }
+    else
+        LogThisFunc(("Already canceled\n"));
+
+    return S_OK;
+}
+
+
+// IInternalProgressControl methods
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Updates the percentage value of the current operation.
+ *
+ * @param aPercent  New percentage value of the operation in progress
+ *                  (in range [0, 100]).
+ */
+HRESULT Progress::setCurrentOperationProgress(ULONG aPercent)
+{
+    AssertMsgReturn(aPercent <= 100, ("%u\n", aPercent), E_INVALIDARG);
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    i_checkForAutomaticTimeout();
+    if (mCancelable && mCanceled)
+        AssertReturn(!mCompleted, E_FAIL);
+    AssertReturn(!mCompleted && !mCanceled, E_FAIL);
+
+    if (m_ulOperationPercent != aPercent)
+    {
+        m_ulOperationPercent = aPercent;
+        ULONG actualPercent = 0;
+        getPercent(&actualPercent);
+        fireProgressPercentageChangedEvent(pEventSource, mId.toUtf16().raw(), actualPercent);
+    }
+
+    return S_OK;
+}
+
+HRESULT Progress::waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther,
+                                                 ULONG aTimeoutMS)
 {
     LogFlowThisFuncEnter();
@@ -483 +890 @@
     rc = aProgressOther->COMGETTER(Cancelable)(&fCancelable);
     if (FAILED(rc)) return rc;
+
+    uint64_t u64StopTime = UINT64_MAX;
+    if (aTimeoutMS > 0)
+        u64StopTime = RTTimeMilliTS() + aTimeoutMS;
     /* Loop as long as the sync process isn't completed. */
     while (SUCCEEDED(aProgressOther->COMGETTER(Completed(&fCompleted))))
@@ -541 +952 @@
             break;
 
-        /* Make sure the loop is not too tight */
-        rc = aProgressOther->WaitForCompletion(100);
-        if (FAILED(rc)) return rc;
+        if (aTimeoutMS != 0)
+        {
+            /* Make sure the loop is not too tight */
+            uint64_t u64Now = RTTimeMilliTS();
+            uint64_t u64RemainingMS = u64StopTime - u64Now;
+            if (u64RemainingMS < 10)
+                u64RemainingMS = 10;
+            else if (u64RemainingMS > 200)
+                u64RemainingMS = 200;
+            rc = aProgressOther->WaitForCompletion((LONG)u64RemainingMS);
+            if (FAILED(rc)) return rc;
+
+            if (RTTimeMilliTS() >= u64StopTime)
+                return VBOX_E_TIMEOUT;
+        }
+        else
+        {
+            /* Make sure the loop is not too tight */
+            rc = aProgressOther->WaitForCompletion(200);
+            if (FAILED(rc)) return rc;
+        }
     }
 
@@ -562 +991 @@
 
 /**
+ * Signals that the current operation is successfully completed and advances to
+ * the next operation. The operation percentage is reset to 0.
+ *
+ * @param aNextOperationDescription  Description of the next operation.
+ * @param aNextOperationsWeight     Weight of the next operation.
+ *
+ * @note The current operation must not be the last one.
+ */
+HRESULT Progress::setNextOperation(const com::Utf8Str &aNextOperationDescription, ULONG aNextOperationsWeight)
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mCanceled)
+        return E_FAIL;
+    AssertReturn(!mCompleted, E_FAIL);
+    AssertReturn(m_ulCurrentOperation + 1 < m_cOperations, E_FAIL);
+
+    ++m_ulCurrentOperation;
+    m_ulOperationsCompletedWeight += m_ulCurrentOperationWeight;
+
+    m_operationDescription = aNextOperationDescription;
+    m_ulCurrentOperationWeight = aNextOperationsWeight;
+    m_ulOperationPercent = 0;
+
+    LogThisFunc(("%s: aNextOperationsWeight = %d; m_ulCurrentOperation is now %d, m_ulOperationsCompletedWeight is now %d\n",
+                 m_operationDescription.c_str(), aNextOperationsWeight, m_ulCurrentOperation, m_ulOperationsCompletedWeight));
+
+    /* wake up all waiting threads */
+    if (mWaitersCount > 0)
+        RTSemEventMultiSignal(mCompletedSem);
+
+    ULONG actualPercent = 0;
+    getPercent(&actualPercent);
+    fireProgressPercentageChangedEvent(pEventSource, mId.toUtf16().raw(), actualPercent);
+
+    return S_OK;
+}
+
+/**
  * Notify the progress object that we're almost at the point of no return.
  *
@@ -570 +1038 @@
  * user believe it was rolled back.
  *
- * @returns Success indicator.
- * @retval  true on success.
- * @retval  false if the progress object has already been canceled or is in an
+ * @returns COM error status.
+ * @retval  S_OK on success.
+ * @retval  E_FAIL if the progress object has already been canceled or is in an
  *          invalid state
  */
-bool Progress::i_notifyPointOfNoReturn(void)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), false);
-
+HRESULT Progress::notifyPointOfNoReturn(void)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     if (mCanceled)
     {
-        LogThisFunc(("returns false\n"));
-        return false;
+        LogThisFunc(("returns failure\n"));
+        return E_FAIL;
     }
 
     mCancelable = FALSE;
-    LogThisFunc(("returns true\n"));
-    return true;
-}
-
-/**
- * Sets the cancelation callback, checking for cancelation first.
- *
- * @returns Success indicator.
- * @retval  true on success.
- * @retval  false if the progress object has already been canceled or is in an
- *          invalid state
- *
- * @param   pfnCallback     The function to be called upon cancelation.
- * @param   pvUser          The callback argument.
- */
-bool Progress::i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), false);
+    LogThisFunc(("returns success\n"));
+    return S_OK;
+}
+
+/**
+ * Marks the operation as complete and attaches full error info.
+ *
+ * This is where the actual work is done, the related methods all end up here.
+ *
+ * @param aResultCode   Operation result (error) code, must not be S_OK.
+ * @param aErrorInfo            List of arguments for the format string.
+ */
+HRESULT Progress::notifyComplete(LONG aResultCode, const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
+{
+    LogThisFunc(("aResultCode=%d\n", aResultCode));
+    /* on failure we expect error info, on success there must be none */
+    AssertMsg(FAILED(aResultCode) ^ aErrorInfo.isNull(),
+              ("No error info but trying to set a failed result (%08X)!\n",
+               aResultCode));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    i_checkForAutomaticTimeout();
-    if (mCanceled)
-        return false;
-
-    m_pvCancelUserArg   = pvUser;
-    m_pfnCancelCallback = pfnCallback;
-    return true;
-}
-
-/**
- * @callback_method_impl{FNRTPROGRESS,
- *      Works the progress of the current operation.}
- */
-/*static*/ DECLCALLBACK(int) Progress::i_iprtProgressCallback(unsigned uPercentage, void *pvUser)
-{
-    Progress *pThis = (Progress *)pvUser;
-
-    /*
-     * Same as setCurrentOperationProgress, except we don't fail on mCompleted.
-     */
-    AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
-    int vrc = VINF_SUCCESS;
-    if (!pThis->mCompleted)
-    {
-        pThis->i_checkForAutomaticTimeout();
-        if (!pThis->mCanceled)
-        {
-            if (uPercentage > pThis->m_ulOperationPercent)
-                pThis->setCurrentOperationProgress(uPercentage);
-        }
-        else
-        {
-            Assert(pThis->mCancelable);
-            vrc = VERR_CANCELLED;
-        }
-    }
-    /* else ignored */
-    return vrc;
-}
-
-/**
- * @callback_method_impl{FNVDPROGRESS,
- *      Progress::i_iprtProgressCallback with parameters switched around.}
- */
-/*static*/ DECLCALLBACK(int) Progress::i_vdProgressCallback(void *pvUser, unsigned uPercentage)
-{
-    return i_iprtProgressCallback(uPercentage, pvUser);
-}
-
-// IProgress properties
-/////////////////////////////////////////////////////////////////////////////
-
-HRESULT Progress::getId(com::Guid &aId)
-{
-    /* mId is constant during life time, no need to lock */
-    aId = mId;
-
-    return S_OK;
-}
-
-HRESULT Progress::getDescription(com::Utf8Str &aDescription)
-{
-    /* mDescription is constant during life time, no need to lock */
-    aDescription = mDescription;
-
-    return S_OK;
-}
-HRESULT Progress::getInitiator(ComPtr<IUnknown> &aInitiator)
-{
-    /* mInitiator/mParent are constant during life time, no need to lock */
+    AssertReturn(mCompleted == FALSE, E_FAIL);
+
+    if (mCanceled && SUCCEEDED(aResultCode))
+        aResultCode = E_FAIL;
+
+    mCompleted = TRUE;
+    mResultCode = aResultCode;
+    if (SUCCEEDED(aResultCode))
+    {
+        m_ulCurrentOperation = m_cOperations - 1; /* last operation */
+        m_ulOperationPercent = 100;
+    }
+    mErrorInfo = aErrorInfo;
+
 #if !defined(VBOX_COM_INPROC)
-    if (mInitiator)
-        mInitiator.queryInterfaceTo(aInitiator.asOutParam());
-    else
-    {
-        ComObjPtr<VirtualBox> pVirtualBox(mParent);
-        pVirtualBox.queryInterfaceTo(aInitiator.asOutParam());
-    }
-#else
-    mInitiator.queryInterfaceTo(aInitiator.asOutParam());
+    /* remove from the global collection of pending progress operations */
+    if (mParent)
+        mParent->i_removeProgress(mId.ref());
 #endif
-
-    return S_OK;
-}
-
-HRESULT Progress::getCancelable(BOOL *aCancelable)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aCancelable = mCancelable;
-
-    return S_OK;
-}
-
-HRESULT Progress::getPercent(ULONG *aPercent)
-{
-    /* i_checkForAutomaticTimeout requires a write lock. */
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mCompleted && SUCCEEDED(mResultCode))
-        *aPercent = 100;
-    else
-    {
-        ULONG ulPercent = (ULONG)i_calcTotalPercent();
-        // do not report 100% until we're really really done with everything
-        // as the Qt GUI dismisses progress dialogs in that case
-        if (    ulPercent == 100
-             && (    m_ulOperationPercent < 100
-                  || (m_ulCurrentOperation < m_cOperations -1)
-                )
-           )
-            *aPercent = 99;
-        else
-            *aPercent = ulPercent;
-    }
-
-    i_checkForAutomaticTimeout();
-
-    return S_OK;
-}
-
-HRESULT Progress::getTimeRemaining(LONG *aTimeRemaining)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mCompleted)
-        *aTimeRemaining = 0;
-    else
-    {
-        double dPercentDone = i_calcTotalPercent();
-        if (dPercentDone < 1)
-            *aTimeRemaining = -1;       // unreliable, or avoid division by 0 below
-        else
-        {
-            uint64_t ullTimeNow = RTTimeMilliTS();
-            uint64_t ullTimeElapsed = ullTimeNow - m_ullTimestamp;
-            uint64_t ullTimeTotal = (uint64_t)((double)ullTimeElapsed * 100 / dPercentDone);
-            uint64_t ullTimeRemaining = ullTimeTotal - ullTimeElapsed;
-
-//          LogFunc(("dPercentDone = %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
-//                   (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
-
-            *aTimeRemaining = (LONG)(ullTimeRemaining / 1000);
-        }
-    }
-
-    return S_OK;
-}
-
-HRESULT Progress::getCompleted(BOOL *aCompleted)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aCompleted = mCompleted;
-
-    return S_OK;
-}
-
-HRESULT Progress::getCanceled(BOOL *aCanceled)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aCanceled = mCanceled;
-
-    return S_OK;
-}
-
-HRESULT Progress::getResultCode(LONG *aResultCode)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mCompleted)
-        return setError(E_FAIL, tr("Result code is not available, operation is still in progress"));
-
-    *aResultCode = mResultCode;
-
-    return S_OK;
-}
-
-HRESULT Progress::getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mCompleted)
-        return setError(E_FAIL, tr("Error info is not available, operation is still in progress"));
-
-    mErrorInfo.queryInterfaceTo(aErrorInfo.asOutParam());
-
-    return S_OK;
-}
-
-HRESULT Progress::getOperationCount(ULONG *aOperationCount)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aOperationCount = m_cOperations;
-
-    return S_OK;
-}
-
-HRESULT Progress::getOperation(ULONG *aOperation)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aOperation = m_ulCurrentOperation;
-
-    return S_OK;
-}
-
-HRESULT Progress::getOperationDescription(com::Utf8Str &aOperationDescription)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    aOperationDescription = m_operationDescription;
-
-    return S_OK;
-}
-
-HRESULT Progress::getOperationPercent(ULONG *aOperationPercent)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mCompleted && SUCCEEDED(mResultCode))
-        *aOperationPercent = 100;
-    else
-        *aOperationPercent = m_ulOperationPercent;
-
-    return S_OK;
-}
-
-HRESULT Progress::getOperationWeight(ULONG *aOperationWeight)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aOperationWeight = m_ulCurrentOperationWeight;
-
-    return S_OK;
-}
-
-HRESULT Progress::getTimeout(ULONG *aTimeout)
-{
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aTimeout = m_cMsTimeout;
-
-    return S_OK;
-}
-
-HRESULT Progress::setTimeout(ULONG aTimeout)
-{
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mCancelable)
-        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
-    m_cMsTimeout = aTimeout;
-
-    return S_OK;
-}
-
-
-// IProgress methods
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- * Updates the percentage value of the current operation.
- *
- * @param aPercent  New percentage value of the operation in progress
- *                  (in range [0, 100]).
- */
-HRESULT Progress::setCurrentOperationProgress(ULONG aPercent)
-{
-    AssertMsgReturn(aPercent <= 100, ("%u\n", aPercent), E_INVALIDARG);
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    i_checkForAutomaticTimeout();
-    if (mCancelable && mCanceled)
-        AssertReturn(!mCompleted, E_FAIL);
-    AssertReturn(!mCompleted && !mCanceled, E_FAIL);
-
-    if (m_ulOperationPercent != aPercent)
-    {
-        m_ulOperationPercent = aPercent;
-        ULONG actualPercent = 0;
-        getPercent(&actualPercent);
-        fireProgressPercentageChangedEvent(pEventSource, mId.toUtf16().raw(), actualPercent);
-    }
-
-    return S_OK;
-}
-
-/**
- * Signals that the current operation is successfully completed and advances to
- * the next operation. The operation percentage is reset to 0.
- *
- * @param aNextOperationDescription  Description of the next operation.
- * @param aNextOperationsWeight     Weight of the next operation.
- *
- * @note The current operation must not be the last one.
- */
-HRESULT Progress::setNextOperation(const com::Utf8Str &aNextOperationDescription, ULONG aNextOperationsWeight)
-{
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mCanceled)
-        return E_FAIL;
-    AssertReturn(!mCompleted, E_FAIL);
-    AssertReturn(m_ulCurrentOperation + 1 < m_cOperations, E_FAIL);
-
-    ++m_ulCurrentOperation;
-    m_ulOperationsCompletedWeight += m_ulCurrentOperationWeight;
-
-    m_operationDescription = aNextOperationDescription;
-    m_ulCurrentOperationWeight = aNextOperationsWeight;
-    m_ulOperationPercent = 0;
-
-    LogThisFunc(("%s: aNextOperationsWeight = %d; m_ulCurrentOperation is now %d, m_ulOperationsCompletedWeight is now %d\n",
-                 m_operationDescription.c_str(), aNextOperationsWeight, m_ulCurrentOperation, m_ulOperationsCompletedWeight));
 
     /* wake up all waiting threads */
@@ -934 +1100 @@
         RTSemEventMultiSignal(mCompletedSem);
 
-    ULONG actualPercent = 0;
-    getPercent(&actualPercent);
-    fireProgressPercentageChangedEvent(pEventSource, mId.toUtf16().raw(), actualPercent);
-
-    return S_OK;
-}
-
-/**
- * @note XPCOM: when this method is not called on the main XPCOM thread, it
- *       simply blocks the thread until mCompletedSem is signalled. If the
- *       thread has its own event queue (hmm, what for?) that it must run, then
- *       calling this method will definitely freeze event processing.
- */
-HRESULT Progress::waitForCompletion(LONG aTimeout)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* if we're already completed, take a shortcut */
-    if (!mCompleted)
-    {
-        int vrc = VINF_SUCCESS;
-        bool fForever = aTimeout < 0;
-        int64_t timeLeft = aTimeout;
-        int64_t lastTime = RTTimeMilliTS();
-
-        while (!mCompleted && (fForever || timeLeft > 0))
-        {
-            mWaitersCount++;
-            alock.release();
-            vrc = RTSemEventMultiWait(mCompletedSem,
-                                      fForever ? RT_INDEFINITE_WAIT : (RTMSINTERVAL)timeLeft);
-            alock.acquire();
-            mWaitersCount--;
-
-            /* the last waiter resets the semaphore */
-            if (mWaitersCount == 0)
-                RTSemEventMultiReset(mCompletedSem);
-
-            if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-                break;
-
-            if (!fForever)
-            {
-                int64_t now = RTTimeMilliTS();
-                timeLeft -= now - lastTime;
-                lastTime = now;
-            }
-        }
-
-        if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-            return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to wait for the task completion (%Rrc)"), vrc);
-    }
-
-    LogFlowThisFuncLeave();
-
-    return S_OK;
-}
-
-/**
- * @note XPCOM: when this method is not called on the main XPCOM thread, it
- *       simply blocks the thread until mCompletedSem is signalled. If the
- *       thread has its own event queue (hmm, what for?) that it must run, then
- *       calling this method will definitely freeze event processing.
- */
-HRESULT Progress::waitForOperationCompletion(ULONG aOperation, LONG aTimeout)
-
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aOperation=%d, aTimeout=%d\n", aOperation, aTimeout));
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CheckComArgExpr(aOperation, aOperation < m_cOperations);
-
-    /* if we're already completed or if the given operation is already done,
-     * then take a shortcut */
-    if (    !mCompleted
-         && aOperation >= m_ulCurrentOperation)
-    {
-        int vrc = VINF_SUCCESS;
-        bool fForever = aTimeout < 0;
-        int64_t timeLeft = aTimeout;
-        int64_t lastTime = RTTimeMilliTS();
-
-        while (    !mCompleted && aOperation >= m_ulCurrentOperation
-                && (fForever || timeLeft > 0))
-        {
-            mWaitersCount ++;
-            alock.release();
-            vrc = RTSemEventMultiWait(mCompletedSem,
-                                      fForever ? RT_INDEFINITE_WAIT : (unsigned) timeLeft);
-            alock.acquire();
-            mWaitersCount--;
-
-            /* the last waiter resets the semaphore */
-            if (mWaitersCount == 0)
-                RTSemEventMultiReset(mCompletedSem);
-
-            if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-                break;
-
-            if (!fForever)
-            {
-                int64_t now = RTTimeMilliTS();
-                timeLeft -= now - lastTime;
-                lastTime = now;
-            }
-        }
-
-        if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
-            return setErrorBoth(E_FAIL, vrc, tr("Failed to wait for the operation completion (%Rrc)"), vrc);
-    }
-
-    LogFlowThisFuncLeave();
-
-    return S_OK;
-}
-
-HRESULT Progress::cancel()
-{
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mCancelable)
-        return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
-
-    if (!mCanceled)
-    {
-        LogThisFunc(("Canceling\n"));
-        mCanceled = TRUE;
-        if (m_pfnCancelCallback)
-            m_pfnCancelCallback(m_pvCancelUserArg);
-
-    }
-    else
-        LogThisFunc(("Already canceled\n"));
-
-    return S_OK;
-}
-
-HRESULT Progress::getEventSource(ComPtr<IEventSource> &aEventSource)
-{
-    /* event source is const, no need to lock */
-    pEventSource.queryInterfaceTo(aEventSource.asOutParam());
-    return S_OK;
-}
+    fireProgressTaskCompletedEvent(pEventSource, mId.toUtf16().raw());
+
+    return S_OK;
+}
+
 
 // private internal helpers