Changeset 50874 in vbox for trunk/src

Timestamp:

Mar 25, 2014 6:29:02 PM (11 years ago)

Author:

vboxsync

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

92972

Message:

6813 src-all/ProgressImp.cpp + some formatting/line length sorting

Location:

trunk/src/VBox/Main

Files:

• Makefile.kmk (modified) (3 diffs)
• include/GuestFileImpl.h (modified) (1 diff)
• include/GuestProcessImpl.h (modified) (2 diffs)
• include/GuestSessionImpl.h (modified) (3 diffs)
• include/ProgressImpl.h (modified) (14 diffs)
• src-all/ExtPackManagerImpl.cpp (modified) (9 diffs)
• src-all/ProgressImpl.cpp (modified) (48 diffs)
• src-client/ConsoleImpl.cpp (modified) (10 diffs)
• src-client/ConsoleImplTeleporter.cpp (modified) (8 diffs)
• src-client/GuestDnDImpl.cpp (modified) (8 diffs)
• src-client/GuestProcessImpl.cpp (modified) (4 diffs)
• src-client/GuestSessionImpl.cpp (modified) (17 diffs)
• src-client/GuestSessionImplTasks.cpp (modified) (2 diffs)
• src-client/xpcom/module.cpp (modified) (1 diff)
• src-server/ApplianceImpl.cpp (modified) (8 diffs)
• src-server/MachineImpl.cpp (modified) (7 diffs)
• src-server/MachineImplCloneVM.cpp (modified) (22 diffs)
• src-server/MediumImpl.cpp (modified) (1 diff)
• src-server/ProgressProxyImpl.cpp (modified) (4 diffs)
• src-server/SnapshotImpl.cpp (modified) (7 diffs)
• src-server/VFSExplorerImpl.cpp (modified) (8 diffs)
• src-server/VirtualBoxImpl.cpp (modified) (1 diff)
• src-server/generic/NetIf-generic.cpp (modified) (7 diffs)
• src-server/xpcom/server.cpp (modified) (1 diff)

trunk/src/VBox/Main/Makefile.kmk

@@ -729 +729 @@
  VBoxC_SOURCES += \
         src-client/AudioSnifferInterface.cpp
-endif 
+endif
 VBoxC_SOURCES.win = \
         src-client/win/dllmain.cpp \
@@ -841 +841 @@
 LIBRARIES += VBoxCOM
 VBoxCOM_TEMPLATE        = VBoxMainLib
-VBoxCOM_INTERMEDIATES   = $(VBOX_MAIN_PREREQS)
+VBoxCOM_INTERMEDIATES   = $(VBOX_MAIN_PREREQS) \
+                          $(VBOX_MAIN_APIWRAPPER_GEN_HDRS)
 VBoxCOM_SOURCES         = \
         glue/com.cpp \
@@ -851 +852 @@
         glue/ErrorInfo.cpp \
         glue/errorprint.cpp
-VBoxCOM_INCS          += \
+VBoxCOM_INCS          += $(VBOX_MAIN_APIWRAPPER_INCS) \
         include
 ifeq ($(KBUILD_TARGET),win)

trunk/src/VBox/Main/include/GuestFileImpl.h

@@ -62 +62 @@
     int             i_openFile(uint32_t uTimeoutMS, int *pGuestRc);
     int             i_readData(uint32_t uSize, uint32_t uTimeoutMS, void* pvData, uint32_t cbData, uint32_t* pcbRead);
-    int             i_readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS, void* pvData, size_t cbData, size_t* pcbRead);
+    int             i_readDataAt(uint64_t uOffset, uint32_t uSize, uint32_t uTimeoutMS,
+                                 void* pvData, size_t cbData, size_t* pcbRead);
     int             i_seekAt(int64_t iOffset, GUEST_FILE_SEEKTYPE eSeekType, uint32_t uTimeoutMS, uint64_t *puOffset);
     static HRESULT  i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc);

trunk/src/VBox/Main/include/GuestProcessImpl.h

@@ -52 +52 @@
     static Utf8Str i_guestErrorToString(int guestRc);
     int i_onRemove(void);
-    int i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc);
+    int i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS, void *pvData,
+                   size_t cbData, uint32_t *pcbRead, int *pGuestRc);
     static HRESULT i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
     int i_startProcess(uint32_t uTimeoutMS, int *pGuestRc);
     int i_startProcessAsync(void);
     int i_terminateProcess(uint32_t uTimeoutMS, int *pGuestRc);
-    static ProcessWaitResult_T i_waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus, ProcessStatus_T newStatus, uint32_t uProcFlags, uint32_t uProtocol);
+    static ProcessWaitResult_T i_waitFlagsToResultEx(uint32_t fWaitFlags, ProcessStatus_T oldStatus,
+                                                     ProcessStatus_T newStatus, uint32_t uProcFlags,
+                                                     uint32_t uProtocol);
     ProcessWaitResult_T i_waitFlagsToResult(uint32_t fWaitFlags);
     int i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, ProcessWaitResult_T &waitResult, int *pGuestRc);
-    int i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed);
-    int i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS, void* pvData, size_t cbData, uint32_t *pcbRead);
-    int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS, ProcessStatus_T *pProcessStatus, int *pGuestRc);
-    static bool i_waitResultImpliesEx(ProcessWaitResult_T waitResult, ProcessStatus_T procStatus, uint32_t uProcFlags, uint32_t uProtocol);
-    int i_writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc);
+    int i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
+                             ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed);
+    int i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
+                        void* pvData, size_t cbData, uint32_t *pcbRead);
+    int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
+                              ProcessStatus_T *pProcessStatus, int *pGuestRc);
+    static bool i_waitResultImpliesEx(ProcessWaitResult_T waitResult, ProcessStatus_T procStatus,
+                                      uint32_t uProcFlags, uint32_t uProtocol);
+    int i_writeData(uint32_t uHandle, uint32_t uFlags, void *pvData, size_t cbData,
+                    uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc);
     /** @}  */
 
@@ -182 +190 @@
     static int i_run(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, int *pGuestRc);
 
-    static int i_runEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo, GuestCtrlStreamObjects *pStrmOutObjects,
-                       uint32_t cStrmOutObjects, int *pGuestRc);
+    static int i_runEx(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo,
+                       GuestCtrlStreamObjects *pStrmOutObjects, uint32_t cStrmOutObjects, int *pGuestRc);
 
     int i_terminatedOk(LONG *pExitCode);

trunk/src/VBox/Main/include/GuestSessionImpl.h

@@ -395 +395 @@
     int                     i_directoryRemoveInternal(const Utf8Str &strPath, uint32_t uFlags, int *pGuestRc);
     int                     i_directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc);
-    int                     i_objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory, Utf8Str &strName, int *pGuestRc);
-    int                     i_directoryOpenInternal(const GuestDirectoryOpenInfo &openInfo, ComObjPtr<GuestDirectory> &pDirectory, int *pGuestRc);
+    int                     i_objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory,
+                                                       Utf8Str &strName, int *pGuestRc);
+    int                     i_directoryOpenInternal(const GuestDirectoryOpenInfo &openInfo,
+                                                    ComObjPtr<GuestDirectory> &pDirectory, int *pGuestRc);
     int                     i_directoryQueryInfoInternal(const Utf8Str &strPath, GuestFsObjData &objData, int *pGuestRc);
     int                     i_dispatchToDirectory(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
@@ -425 +427 @@
     Guest                  *i_getParent(void) { return mParent; }
     uint32_t                i_getProtocolVersion(void) { return mData.mProtocolVersion; }
-    int                     i_pathRenameInternal(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags, int *pGuestRc);
+    int                     i_pathRenameInternal(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags,
+                                                 int *pGuestRc);
     int                     i_processRemoveFromList(GuestProcess *pProcess);
     int                     i_processCreateExInteral(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProgress);
@@ -434 +437 @@
     int                     i_setSessionStatus(GuestSessionStatus_T sessionStatus, int sessionRc);
     int                     i_signalWaiters(GuestSessionWaitResult_T enmWaitResult, int rc /*= VINF_SUCCESS */);
-    int                     i_startTaskAsync(const Utf8Str &strTaskDesc, GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress);
+    int                     i_startTaskAsync(const Utf8Str &strTaskDesc, GuestSessionTask *pTask,
+                                             ComObjPtr<Progress> &pProgress);
     int                     i_queryInfo(void);
     int                     i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *pGuestRc);
-    int                     i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS, GuestSessionStatus_T *pSessionStatus, int *pGuestRc);
+    int                     i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
+                                                  GuestSessionStatus_T *pSessionStatus, int *pGuestRc);
     /** @}  */
 

trunk/src/VBox/Main/include/ProgressImpl.h

@@ -20 +20 @@
 #define ____H_PROGRESSIMPL
 
+#include "ProgressWrap.h"
 #include "VirtualBoxBase.h"
 
@@ -30 +31 @@
  */
 class ATL_NO_VTABLE Progress :
-    public VirtualBoxBase,
-    VBOX_SCRIPTABLE_IMPL(IProgress)
+    public ProgressWrap
 {
 protected:
@@ -37 +37 @@
     DECLARE_EMPTY_CTOR_DTOR (Progress)
 
-
-    void checkForAutomaticTimeout(void);
+    void i_checkForAutomaticTimeout(void);
 
 #if !defined (VBOX_COM_INPROC)
@@ -48 +47 @@
 
     const Guid mId;
-    const Bstr mDescription;
+    const com::Utf8Str mDescription;
 
     uint64_t m_ullTimestamp;                        // progress object creation timestamp, for ETA computation
@@ -63 +62 @@
     ComPtr<IVirtualBoxErrorInfo> mErrorInfo;
 
-    ULONG m_cOperations;                            // number of operations (so that progress dialog can display something like 1/3)
+    ULONG m_cOperations;                            // number of operations (so that progress dialog can
+                                                    // display something like 1/3)
     ULONG m_ulTotalOperationsWeight;                // sum of weights of all operations, given to constructor
 
     ULONG m_ulOperationsCompletedWeight;            // summed-up weight of operations that have been completed; initially 0
 
-    ULONG m_ulCurrentOperation;                     // operations counter, incremented with each setNextOperation()
-    Bstr m_bstrOperationDescription;                // name of current operation; initially from constructor, changed with setNextOperation()
+    ULONG m_ulCurrentOperation;                     // operations counter, incremented with
+                                                    // each setNextOperation()
+    com::Utf8Str m_operationDescription;            // name of current operation; initially
+                                                    // from constructor, changed with setNextOperation()
     ULONG m_ulCurrentOperationWeight;               // weight of current operation, given to setNextOperation()
     ULONG m_ulOperationPercent;                     // percentage of current operation, set with setCurrentOperationProgress()
@@ -75 +77 @@
 
 public:
-    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Progress, IProgress)
-
     DECLARE_NOT_AGGREGATABLE (Progress)
-
-    DECLARE_PROTECT_FINAL_CONSTRUCT()
-
-    BEGIN_COM_MAP (Progress)
-        VBOX_DEFAULT_INTERFACE_ENTRIES (IProgress)
-    END_COM_MAP()
 
     HRESULT FinalConstruct();
@@ -105 +99 @@
 #endif
                   IUnknown *aInitiator,
-                  CBSTR aDescription,
+                  Utf8Str aDescription,
                   BOOL aCancelable,
                   OUT_GUID aId = NULL)
@@ -118 +112 @@
             1,      // cOperations
             1,      // ulTotalOperationsWeight
-            aDescription, // bstrFirstOperationDescription
+            aDescription, // aFirstOperationDescription
             1,      // ulFirstOperationWeight
             aId);
@@ -140 +134 @@
 #endif
                   IUnknown *aInitiator,
-                  CBSTR aDescription, BOOL aCancelable,
+                  Utf8Str aDescription, BOOL aCancelable,
                   ULONG cOperations,
-                  CBSTR bstrFirstOperationDescription,
+                  Utf8Str aFirstOperationDescription,
                   OUT_GUID aId = NULL)
     {
@@ -154 +148 @@
             cOperations,      // cOperations
             cOperations,      // ulTotalOperationsWeight = cOperations
-            bstrFirstOperationDescription, // bstrFirstOperationDescription
+            aFirstOperationDescription, // aFirstOperationDescription
             1,      // ulFirstOperationWeight: weigh them all the same
             aId);
@@ -164 +158 @@
 #endif
                   IUnknown *aInitiator,
-                  CBSTR aDescription,
+                  Utf8Str aDescription,
                   BOOL aCancelable,
                   ULONG cOperations,
                   ULONG ulTotalOperationsWeight,
-                  CBSTR bstrFirstOperationDescription,
+                  Utf8Str aFirstOperationDescription,
                   ULONG ulFirstOperationWeight,
                   OUT_GUID aId = NULL);
@@ -174 +168 @@
     HRESULT init(BOOL aCancelable,
                  ULONG aOperationCount,
-                 CBSTR aOperationDescription);
+                 Utf8Str aOperationDescription);
 
 //   initializer/uninitializer for internal purposes only
@@ -182 +176 @@
 #endif
                IUnknown *aInitiator,
-               CBSTR aDescription, OUT_GUID aId = NULL);
+               Utf8Str aDescription, OUT_GUID aId = NULL);
     HRESULT init(AutoInitSpan &aAutoInitSpan);
     void init(AutoUninitSpan &aAutoUninitSpan);
@@ -188 +182 @@
     void uninit(AutoUninitSpan &aAutoUninitSpan);
 
-    // IProgress methods
-    STDMETHOD(WaitForCompletion)(LONG aTimeout);
-    STDMETHOD(WaitForOperationCompletion)(ULONG aOperation, LONG aTimeout);
-    STDMETHOD(WaitForAsyncProgressCompletion)(IProgress *pProgressAsync);
-    STDMETHOD(Cancel)();
-
-    STDMETHOD(SetCurrentOperationProgress)(ULONG aPercent);
-    STDMETHOD(SetNextOperation)(IN_BSTR bstrNextOperationDescription, ULONG ulNextOperationsWeight);
 
     // public methods only for internal purposes
-
-    HRESULT setResultCode(HRESULT aResultCode);
-
-    HRESULT notifyComplete(HRESULT aResultCode);
-    HRESULT notifyComplete(HRESULT aResultCode,
-                           const GUID &aIID,
-                           const char *pcszComponent,
-                           const char *aText,
-                           ...);
-    HRESULT notifyCompleteV(HRESULT aResultCode,
-                            const GUID &aIID,
-                            const char *pcszComponent,
-                            const char *aText,
-                            va_list va);
-    bool notifyPointOfNoReturn(void);
-
-    // IProgress properties
-    STDMETHOD(COMGETTER(Id)) (BSTR *aId);
-    STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
-    STDMETHOD(COMGETTER(Initiator)) (IUnknown **aInitiator);
-
-    // IProgress properties
-    STDMETHOD(COMGETTER(Cancelable)) (BOOL *aCancelable);
-    STDMETHOD(COMGETTER(Percent)) (ULONG *aPercent);
-    STDMETHOD(COMGETTER(TimeRemaining)) (LONG *aTimeRemaining);
-    STDMETHOD(COMGETTER(Completed)) (BOOL *aCompleted);
-    STDMETHOD(COMGETTER(Canceled)) (BOOL *aCanceled);
-    STDMETHOD(COMGETTER(ResultCode)) (LONG *aResultCode);
-    STDMETHOD(COMGETTER(ErrorInfo)) (IVirtualBoxErrorInfo **aErrorInfo);
-    STDMETHOD(COMGETTER(OperationCount)) (ULONG *aOperationCount);
-    STDMETHOD(COMGETTER(Operation)) (ULONG *aOperation);
-    STDMETHOD(COMGETTER(OperationDescription)) (BSTR *aOperationDescription);
-    STDMETHOD(COMGETTER(OperationPercent)) (ULONG *aOperationPercent);
-    STDMETHOD(COMGETTER(OperationWeight)) (ULONG *aOperationWeight);
-    STDMETHOD(COMSETTER(Timeout)) (ULONG aTimeout);
-    STDMETHOD(COMGETTER(Timeout)) (ULONG *aTimeout);
+    HRESULT i_setResultCode(HRESULT aResultCode);
+
+    HRESULT i_notifyComplete(HRESULT aResultCode);
+    HRESULT i_notifyComplete(HRESULT aResultCode,
+                             const GUID &aIID,
+                             const char *pcszComponent,
+                             const char *aText,
+                             ...);
+    HRESULT i_notifyCompleteV(HRESULT aResultCode,
+                              const GUID &aIID,
+                              const char *pcszComponent,
+                              const char *aText,
+                              va_list va);
+    bool i_notifyPointOfNoReturn(void);
 
     // public methods only for internal purposes
-
-    bool setCancelCallback(void (*pfnCallback)(void *), void *pvUser);
-
+    bool i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser);
 
     // unsafe inline public methods for internal purposes only (ensure there is
     // a caller and a read lock before calling them!)
-    BOOL getCompleted() const { return mCompleted; }
-    HRESULT getResultCode() const { return mResultCode; }
-    double calcTotalPercent();
+    BOOL i_getCompleted() const { return mCompleted; }
+    HRESULT i_getResultCode() const { return mResultCode; }
+    double i_calcTotalPercent();
 
 private:
+
+    // Wrapped IProgress Data
+    HRESULT getId(com::Guid &aId);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT getInitiator(ComPtr<IUnknown> &aInitiator);
+    HRESULT getCancelable(BOOL *aCancelable);
+    HRESULT getPercent(ULONG *aPercent);
+    HRESULT getTimeRemaining(LONG *aTimeRemaining);
+    HRESULT getCompleted(BOOL *aCompleted);
+    HRESULT getCanceled(BOOL *aCanceled);
+    HRESULT getResultCode(LONG *aResultCode);
+    HRESULT getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo);
+    HRESULT getOperationCount(ULONG *aOperationCount);
+    HRESULT getOperation(ULONG *aOperation);
+    HRESULT getOperationDescription(com::Utf8Str &aOperationDescription);
+    HRESULT getOperationPercent(ULONG *aOperationPercent);
+    HRESULT getOperationWeight(ULONG *aOperationWeight);
+    HRESULT getTimeout(ULONG *aTimeout);
+    HRESULT setTimeout(ULONG aTimeout);
+    HRESULT setCurrentOperationProgress(ULONG aPercent);
+    HRESULT setNextOperation(const com::Utf8Str &aNextOperationDescription,
+                             ULONG aNextOperationsWeight);
+
+    // Wrapped Iprogress methods
+    HRESULT waitForCompletion(LONG aTimeout);
+    HRESULT waitForOperationCompletion(ULONG aOperation,
+                                       LONG aTimeout);
+    HRESULT waitForAsyncProgressCompletion(const ComPtr<IProgress> &aPProgressAsync);
+    HRESULT cancel();
+
 
     RTSEMEVENTMULTI mCompletedSem;

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

@@ -234 +234 @@
  * @param   a_pVirtualBox   Pointer to the VirtualBox object.
  */
-HRESULT ExtPackFile::initWithFile(const char *a_pszFile, const char *a_pszDigest, ExtPackManager *a_pExtPackMgr, VirtualBox *a_pVirtualBox)
+HRESULT ExtPackFile::initWithFile(const char *a_pszFile, const char *a_pszDigest, ExtPackManager *a_pExtPackMgr,
+                                  VirtualBox *a_pVirtualBox)
 {
     AutoInitSpan autoInitSpan(this);
@@ -313 +314 @@
      *        dropped. */
     if (!strSavedName.equalsIgnoreCase(m->Desc.strName))
-        return initFailed(tr("Extension pack name mismatch between the downloaded file and the XML inside it (xml='%s' file='%s')"),
-                          m->Desc.strName.c_str(), strSavedName.c_str());
+    {
+        Utf8Str str;
+        str = "Extension pack name mismatch between the downloaded file";
+        str += "and the XML inside it (xml='%s' file='%s')";
+        return initFailed(tr(str.c_str()), m->Desc.strName.c_str(), strSavedName.c_str());
+    }
 
     m->fUsable = true;
@@ -530 +535 @@
                     strPreferredLocale.c_str(), strPreferredLanguage.c_str(), strFormat.c_str());
     else if (strPreferredLocale.isNotEmpty())
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",  strPreferredLocale.c_str(), strFormat.c_str());
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",
+                    strPreferredLocale.c_str(), strFormat.c_str());
     else if (strPreferredLanguage.isNotEmpty())
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s", strPreferredLocale.c_str(), strFormat.c_str());
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s",
+                    strPreferredLocale.c_str(), strFormat.c_str());
     else
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",     strFormat.c_str());
-
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",
+                    strFormat.c_str());
     /*
      * Lock the extension pack. We need a write lock here as there must not be
@@ -1254 +1261 @@
     {
         if (RTFS_IS_SYMLINK(m->ObjInfoExtPack.Attr.fMode))
-            m->strWhyUnusable.printf(tr("'%s' is a symbolic link, this is not allowed"), m->strExtPackPath.c_str(), vrc);
+            m->strWhyUnusable.printf(tr("'%s' is a symbolic link, this is not allowed"),
+                                     m->strExtPackPath.c_str(), vrc);
         else if (RTFS_IS_FILE(m->ObjInfoExtPack.Attr.fMode))
-            m->strWhyUnusable.printf(tr("'%s' is a symbolic file, not a directory"), m->strExtPackPath.c_str(), vrc);
+            m->strWhyUnusable.printf(tr("'%s' is a symbolic file, not a directory"),
+                                     m->strExtPackPath.c_str(), vrc);
         else
-            m->strWhyUnusable.printf(tr("'%s' is not a directory (fMode=%#x)"), m->strExtPackPath.c_str(), m->ObjInfoExtPack.Attr.fMode);
+            m->strWhyUnusable.printf(tr("'%s' is not a directory (fMode=%#x)"),
+                                     m->strExtPackPath.c_str(), m->ObjInfoExtPack.Attr.fMode);
         return;
     }
@@ -1813 +1823 @@
                     strPreferredLocale.c_str(), strPreferredLanguage.c_str(), strFormat.c_str());
     else if (strPreferredLocale.isNotEmpty())
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",  strPreferredLocale.c_str(), strFormat.c_str());
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-%s.%s",
+                    strPreferredLocale.c_str(), strFormat.c_str());
     else if (strPreferredLanguage.isNotEmpty())
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s", strPreferredLocale.c_str(), strFormat.c_str());
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX "-_%s.%s",
+                    strPreferredLocale.c_str(), strFormat.c_str());
     else
-        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",     strFormat.c_str());
+        RTStrPrintf(szName, sizeof(szName), VBOX_EXTPACK_LICENSE_NAME_PREFIX ".%s",
+                    strFormat.c_str());
 
     /*
@@ -2662 +2675 @@
     PEXTPACKINSTALLJOB pJob = (PEXTPACKINSTALLJOB)pvJob;
     HRESULT hrc = pJob->ptrExtPackMgr->doInstall(pJob->ptrExtPackFile, pJob->fReplace, &pJob->strDisplayInfo);
-    pJob->ptrProgress->notifyComplete(hrc);
+    pJob->ptrProgress->i_notifyComplete(hrc);
     delete pJob;
 
@@ -2793 +2806 @@
     PEXTPACKUNINSTALLJOB pJob = (PEXTPACKUNINSTALLJOB)pvJob;
     HRESULT hrc = pJob->ptrExtPackMgr->doUninstall(&pJob->strName, pJob->fForcedRemoval, &pJob->strDisplayInfo);
-    pJob->ptrProgress->notifyComplete(hrc);
+    pJob->ptrProgress->i_notifyComplete(hrc);
     delete pJob;
 
@@ -3094 +3107 @@
             hrc = pExtPack->getVrdpLibraryName(a_pstrVrdeLibrary);
         else
-            hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"), a_pstrExtPack->c_str());
+            hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No extension pack by the name '%s' was found"),
+                           a_pstrExtPack->c_str());
     }
 
@@ -3109 +3123 @@
  * @param   a_pstrVrdeLibrary   Where to return the path.
  */
-HRESULT ExtPackManager::getLibraryPathForExtPack(const char *a_pszModuleName, Utf8Str const *a_pstrExtPack, Utf8Str *a_pstrLibrary)
+HRESULT ExtPackManager::getLibraryPathForExtPack(const char *a_pszModuleName, Utf8Str const *a_pstrExtPack,
+                                                 Utf8Str *a_pstrLibrary)
 {
     AutoCaller autoCaller(this);

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

@@ -58 +58 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP Progress::COMGETTER(Id)(BSTR *aId)
-{
-    CheckComArgOutPointerValid(aId);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getId(com::Guid &aId)
+{
     /* mId is constant during life time, no need to lock */
-    mId.toUtf16().cloneTo(aId);
-
-    return S_OK;
-}
-
-STDMETHODIMP Progress::COMGETTER(Description)(BSTR *aDescription)
-{
-    CheckComArgOutPointerValid(aDescription);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    aId = mId;
+
+    return S_OK;
+}
+
+HRESULT Progress::getDescription(com::Utf8Str &aDescription)
+{
     /* mDescription is constant during life time, no need to lock */
-    mDescription.cloneTo(aDescription);
-
-    return S_OK;
-}
-
-STDMETHODIMP Progress::COMGETTER(Initiator)(IUnknown **aInitiator)
-{
-    CheckComArgOutPointerValid(aInitiator);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    aDescription = mDescription;
+
+    return S_OK;
+}
+HRESULT Progress::getInitiator(ComPtr<IUnknown> &aInitiator)
+{
 
     /* mInitiator/mParent are constant during life time, no need to lock */
@@ -95 +80 @@
 #if !defined(VBOX_COM_INPROC)
     if (mInitiator)
-        mInitiator.queryInterfaceTo(aInitiator);
+        mInitiator.queryInterfaceTo(aInitiator.asOutParam());
     else
     {
         ComObjPtr<VirtualBox> pVirtualBox(mParent);
-        pVirtualBox.queryInterfaceTo(aInitiator);
+        pVirtualBox.queryInterfaceTo(aInitiator.asOutParam());
     }
 #else
-    mInitiator.queryInterfaceTo(aInitiator);
+    mInitiator.queryInterfaceTo(aInitiator.asOutParam());
 #endif
 
@@ -108 +93 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(Cancelable)(BOOL *aCancelable)
-{
-    CheckComArgOutPointerValid(aCancelable);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT Progress::getCancelable(BOOL *aCancelable)
+{
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -131 +112 @@
  * @return fractional percentage as a double value.
  */
-double Progress::calcTotalPercent()
+double Progress::i_calcTotalPercent()
 {
     // avoid division by zero
@@ -137 +118 @@
         return 0;
 
-    double dPercent = (    (double)m_ulOperationsCompletedWeight                                              // weight of operations that have been completed
-                         + ((double)m_ulOperationPercent * (double)m_ulCurrentOperationWeight / (double)100)  // plus partial weight of the current operation
+    double dPercent = (    (double)m_ulOperationsCompletedWeight  // weight of operations that have been completed
+                         + ((double)m_ulOperationPercent *
+                            (double)m_ulCurrentOperationWeight / (double)100)  // plus partial weight of the current operation
                       ) * (double)100 / (double)m_ulTotalOperationsWeight;
 
@@ -149 +131 @@
  * The caller should hold the object write lock.
  */
-void Progress::checkForAutomaticTimeout(void)
+void Progress::i_checkForAutomaticTimeout(void)
 {
     if (   m_cMsTimeout
@@ -159 +141 @@
 }
 
-
-STDMETHODIMP Progress::COMGETTER(TimeRemaining)(LONG *aTimeRemaining)
-{
-    CheckComArgOutPointerValid(aTimeRemaining);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getTimeRemaining(LONG *aTimeRemaining)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -173 +149 @@
     else
     {
-        double dPercentDone = calcTotalPercent();
+        double dPercentDone = i_calcTotalPercent();
         if (dPercentDone < 1)
             *aTimeRemaining = -1;       // unreliable, or avoid division by 0 below
@@ -183 +159 @@
             uint64_t ullTimeRemaining = ullTimeTotal - ullTimeElapsed;
 
-//             Log(("Progress::GetTimeRemaining: dPercentDone %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
-//                         (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
+//          Log(("Progress::GetTimeRemaining: dPercentDone %RI32, ullTimeNow =
+//          %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
+//          (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
 
             *aTimeRemaining = (LONG)(ullTimeRemaining / 1000);
@@ -193 +170 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(Percent)(ULONG *aPercent)
-{
-    CheckComArgOutPointerValid(aPercent);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    checkForAutomaticTimeout();
+HRESULT Progress::getPercent(ULONG *aPercent)
+{
+    i_checkForAutomaticTimeout();
 
     /* checkForAutomaticTimeout requires a write lock. */
@@ -209 +181 @@
     else
     {
-        ULONG ulPercent = (ULONG)calcTotalPercent();
+        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
@@ -221 +193 @@
     }
 
-    checkForAutomaticTimeout();
-
-    return S_OK;
-}
-
-STDMETHODIMP Progress::COMGETTER(Completed)(BOOL *aCompleted)
-{
-    CheckComArgOutPointerValid(aCompleted);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    i_checkForAutomaticTimeout();
+
+    return S_OK;
+}
+
+HRESULT Progress::getCompleted(BOOL *aCompleted)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -240 +207 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(Canceled)(BOOL *aCanceled)
-{
-    CheckComArgOutPointerValid(aCanceled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getCanceled(BOOL *aCanceled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -254 +216 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(ResultCode)(LONG *aResultCode)
-{
-    CheckComArgOutPointerValid(aResultCode);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getResultCode(LONG *aResultCode)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -272 +229 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(ErrorInfo)(IVirtualBoxErrorInfo **aErrorInfo)
-{
-    CheckComArgOutPointerValid(aErrorInfo);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -285 +237 @@
                         tr("Error info is not available, operation is still in progress"));
 
-    mErrorInfo.queryInterfaceTo(aErrorInfo);
-
-    return S_OK;
-}
-
-STDMETHODIMP Progress::COMGETTER(OperationCount)(ULONG *aOperationCount)
-{
-    CheckComArgOutPointerValid(aOperationCount);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    mErrorInfo.queryInterfaceTo(aErrorInfo.asOutParam());
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationCount(ULONG *aOperationCount)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -304 +251 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(Operation)(ULONG *aOperation)
-{
-    CheckComArgOutPointerValid(aOperation);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getOperation(ULONG *aOperation)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -318 +260 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(OperationDescription)(BSTR *aOperationDescription)
-{
-    CheckComArgOutPointerValid(aOperationDescription);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT Progress::getOperationDescription(com::Utf8Str &aOperationDescription)
+{
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m_bstrOperationDescription.cloneTo(aOperationDescription);
-
-    return S_OK;
-}
-
-STDMETHODIMP Progress::COMGETTER(OperationPercent)(ULONG *aOperationPercent)
-{
-    CheckComArgOutPointerValid(aOperationPercent);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    aOperationDescription = m_operationDescription;
+
+    return S_OK;
+}
+
+HRESULT Progress::getOperationPercent(ULONG *aOperationPercent)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -349 +282 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(OperationWeight)(ULONG *aOperationWeight)
-{
-    CheckComArgOutPointerValid(aOperationWeight);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getOperationWeight(ULONG *aOperationWeight)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -363 +291 @@
 }
 
-STDMETHODIMP Progress::COMSETTER(Timeout)(ULONG aTimeout)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::setTimeout(ULONG aTimeout)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -379 +304 @@
 }
 
-STDMETHODIMP Progress::COMGETTER(Timeout)(ULONG *aTimeout)
-{
-    CheckComArgOutPointerValid(aTimeout);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::getTimeout(ULONG *aTimeout)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -406 +326 @@
  * @param   pvUser          The callback argument.
  */
-bool Progress::setCancelCallback(void (*pfnCallback)(void *), void *pvUser)
+bool Progress::i_setCancelCallback(void (*pfnCallback)(void *), void *pvUser)
 {
     AutoCaller autoCaller(this);
@@ -413 +333 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    checkForAutomaticTimeout();
+    i_checkForAutomaticTimeout();
     if (mCanceled)
         return false;
@@ -516 +436 @@
 #endif
                        IUnknown *aInitiator,
-                       CBSTR aDescription,
+                       Utf8Str aDescription,
                        BOOL aCancelable,
                        ULONG cOperations,
                        ULONG ulTotalOperationsWeight,
-                       CBSTR bstrFirstOperationDescription,
+                       Utf8Str aFirstOperationDescription,
                        ULONG ulFirstOperationWeight,
                        OUT_GUID aId /* = NULL */)
 {
-    LogFlowThisFunc(("aDescription=\"%ls\", cOperations=%d, ulTotalOperationsWeight=%d, bstrFirstOperationDescription=\"%ls\", ulFirstOperationWeight=%d\n",
-                     aDescription,
+    Utf8Str str = "aDescription=\"%s\", cOperations=%d, ulTotalOperationsWeight=%d, ";
+    LogFlowThisFunc((str.c_str(),
+                     aDescription.c_str(),
                      cOperations,
                      ulTotalOperationsWeight,
-                     bstrFirstOperationDescription,
+                     aFirstOperationDescription.c_str(),
                      ulFirstOperationWeight));
 
-    AssertReturn(bstrFirstOperationDescription, E_INVALIDARG);
     AssertReturn(ulTotalOperationsWeight >= 1, E_INVALIDARG);
 
@@ -552 +472 @@
 #endif
 
-    AssertReturn(aDescription, E_INVALIDARG);
-
 #if !defined(VBOX_COM_INPROC)
     /* share parent weakly */
@@ -597 +515 @@
     m_ulOperationsCompletedWeight = 0;
     m_ulCurrentOperation = 0;
-    m_bstrOperationDescription = bstrFirstOperationDescription;
+    m_operationDescription = aFirstOperationDescription;
     m_ulCurrentOperationWeight = ulFirstOperationWeight;
     m_ulOperationPercent = 0;
@@ -630 +548 @@
 HRESULT Progress::init(BOOL aCancelable,
                        ULONG aOperationCount,
-                       CBSTR aOperationDescription)
-{
-    LogFlowThisFunc(("aOperationDescription=\"%ls\"\n", aOperationDescription));
+                       Utf8Str aOperationDescription)
+{
+    LogFlowThisFunc(("aOperationDescription=\"%s\"\n", aOperationDescription.c_str()));
 
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -652 +570 @@
     m_ulOperationsCompletedWeight = 0;
     m_ulCurrentOperation = 0;
-    m_bstrOperationDescription = aOperationDescription;
+    m_operationDescription = aOperationDescription;
     m_ulCurrentOperationWeight = 1;
     m_ulOperationPercent = 0;
@@ -686 +604 @@
     if (mWaitersCount > 0)
     {
-        LogFlow(("WARNING: There are still %d threads waiting for '%ls' completion!\n",
-                 mWaitersCount, mDescription.raw()));
+        LogFlow(("WARNING: There are still %d threads waiting for '%s' completion!\n",
+                 mWaitersCount, mDescription.c_str()));
         RTSemEventMultiSignal(mCompletedSem);
     }
@@ -722 +640 @@
  *       calling this method will definitely freeze event processing.
  */
-STDMETHODIMP Progress::WaitForCompletion(LONG aTimeout)
+HRESULT Progress::waitForCompletion(LONG aTimeout)
 {
     LogFlowThisFuncEnter();
     LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -781 +696 @@
  *       calling this method will definitely freeze event processing.
  */
-STDMETHODIMP Progress::WaitForOperationCompletion(ULONG aOperation, LONG aTimeout)
+HRESULT Progress::waitForOperationCompletion(ULONG aOperation, LONG aTimeout)
+
 {
     LogFlowThisFuncEnter();
     LogFlowThisFunc(("aOperation=%d, aTimeout=%d\n", aOperation, aTimeout));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -839 +752 @@
 }
 
-STDMETHODIMP Progress::WaitForAsyncProgressCompletion(IProgress *pProgressAsync)
+HRESULT Progress::waitForAsyncProgressCompletion(const ComPtr<IProgress> &aPProgressAsync)
 {
     LogFlowThisFuncEnter();
-
-    CheckComArgNotNull(pProgressAsync);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     /* Note: we don't lock here, cause we just using public methods. */
@@ -858 +766 @@
     ULONG cOp            = 0;
     /* Is the async process cancelable? */
-    rc = pProgressAsync->COMGETTER(Cancelable)(&fCancelable);
+    rc = aPProgressAsync->COMGETTER(Cancelable)(&fCancelable);
     if (FAILED(rc)) return rc;
     /* Loop as long as the sync process isn't completed. */
-    while (SUCCEEDED(pProgressAsync->COMGETTER(Completed(&fCompleted))))
+    while (SUCCEEDED(aPProgressAsync->COMGETTER(Completed(&fCompleted))))
     {
         /* We can forward any cancel request to the async process only when
@@ -871 +779 @@
             if (fCanceled)
             {
-                rc = pProgressAsync->Cancel();
+                rc = aPProgressAsync->Cancel();
                 if (FAILED(rc)) return rc;
             }
@@ -888 +796 @@
             for (;;)
             {
-                rc = pProgressAsync->COMGETTER(Operation(&curOp));
+                rc = aPProgressAsync->COMGETTER(Operation(&curOp));
                 if (FAILED(rc)) return rc;
                 if (cOp != curOp)
@@ -894 +802 @@
                     Bstr bstr;
                     ULONG currentWeight;
-                    rc = pProgressAsync->COMGETTER(OperationDescription(bstr.asOutParam()));
+                    rc = aPProgressAsync->COMGETTER(OperationDescription(bstr.asOutParam()));
                     if (FAILED(rc)) return rc;
-                    rc = pProgressAsync->COMGETTER(OperationWeight(&currentWeight));
+                    rc = aPProgressAsync->COMGETTER(OperationWeight(&currentWeight));
                     if (FAILED(rc)) return rc;
                     rc = SetNextOperation(bstr.raw(), currentWeight);
@@ -906 +814 @@
             }
 
-            rc = pProgressAsync->COMGETTER(OperationPercent(&currentPercent));
+            rc = aPProgressAsync->COMGETTER(OperationPercent(&currentPercent));
             if (FAILED(rc)) return rc;
             if (currentPercent != prevPercent)
@@ -919 +827 @@
 
         /* Make sure the loop is not too tight */
-        rc = pProgressAsync->WaitForCompletion(100);
+        rc = aPProgressAsync->WaitForCompletion(100);
         if (FAILED(rc)) return rc;
     }
@@ -928 +836 @@
 }
 
-STDMETHODIMP Progress::Cancel()
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Progress::cancel()
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -959 +864 @@
  *                  (in range [0, 100]).
  */
-STDMETHODIMP Progress::SetCurrentOperationProgress(ULONG aPercent)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+HRESULT Progress::setCurrentOperationProgress(ULONG aPercent)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     AssertMsgReturn(aPercent <= 100, ("%u\n", aPercent), E_INVALIDARG);
 
-    checkForAutomaticTimeout();
+    i_checkForAutomaticTimeout();
     if (mCancelable && mCanceled)
     {
@@ -989 +891 @@
  * @note The current operation must not be the last one.
  */
-STDMETHODIMP Progress::SetNextOperation(IN_BSTR bstrNextOperationDescription, ULONG ulNextOperationsWeight)
-{
-    AssertReturn(bstrNextOperationDescription, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+HRESULT Progress::setNextOperation(const com::Utf8Str &aNextOperationDescription, ULONG aNextOperationsWeight)
+
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1006 +904 @@
     m_ulOperationsCompletedWeight += m_ulCurrentOperationWeight;
 
-    m_bstrOperationDescription = bstrNextOperationDescription;
-    m_ulCurrentOperationWeight = ulNextOperationsWeight;
+    m_operationDescription = aNextOperationDescription;
+    m_ulCurrentOperationWeight = aNextOperationsWeight;
     m_ulOperationPercent = 0;
 
-    Log(("Progress::setNextOperation(%ls): ulNextOperationsWeight = %d; m_ulCurrentOperation is now %d, m_ulOperationsCompletedWeight is now %d\n",
-         m_bstrOperationDescription.raw(), ulNextOperationsWeight, m_ulCurrentOperation, m_ulOperationsCompletedWeight));
+    Utf8Str str;
+    str = "Progress::setNextOperation(%s): ulNextOperationsWeight = %d; m_ulCurrentOperation is now %d,";
+    str += "m_ulOperationsCompletedWeight is now %d\n";
+    Log((str.c_str(), m_operationDescription.c_str(), aNextOperationsWeight, m_ulCurrentOperation,
+         m_ulOperationsCompletedWeight));
 
     /* wake up all waiting threads */
@@ -1031 +932 @@
  * @param aResultCode
  */
-HRESULT Progress::setResultCode(HRESULT aResultCode)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+HRESULT Progress::i_setResultCode(HRESULT aResultCode)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1102 +1000 @@
  * @param aResultCode   Operation result code.
  */
-HRESULT Progress::notifyComplete(HRESULT aResultCode)
+HRESULT Progress::i_notifyComplete(HRESULT aResultCode)
 {
     AutoCaller autoCaller(this);
@@ -1116 +1014 @@
         aResultCode = E_FAIL;
 
-    HRESULT rc = setResultCode(aResultCode);
+    HRESULT rc = i_setResultCode(aResultCode);
 
     mCompleted = TRUE;
@@ -1142 +1040 @@
  * Wrapper around Progress:notifyCompleteV.
  */
-HRESULT Progress::notifyComplete(HRESULT aResultCode,
-                                 const GUID &aIID,
-                                 const char *pcszComponent,
-                                 const char *aText,
-                                 ...)
+HRESULT Progress::i_notifyComplete(HRESULT aResultCode,
+                                   const GUID &aIID,
+                                   const char *pcszComponent,
+                                   const char *aText,
+                                   ...)
 {
     va_list va;
     va_start(va, aText);
-    HRESULT hrc = notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
+    HRESULT hrc = i_notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
     va_end(va);
     return hrc;
@@ -1168 +1066 @@
  * @param va            List of arguments for the format string.
  */
-HRESULT Progress::notifyCompleteV(HRESULT aResultCode,
-                                  const GUID &aIID,
-                                  const char *pcszComponent,
-                                  const char *aText,
-                                  va_list va)
+HRESULT Progress::i_notifyCompleteV(HRESULT aResultCode,
+                                    const GUID &aIID,
+                                    const char *pcszComponent,
+                                    const char *aText,
+                                    va_list va)
 {
     Utf8Str text(aText, va);
@@ -1227 +1125 @@
  *          invalid state
  */
-bool Progress::notifyPointOfNoReturn(void)
+bool Progress::i_notifyPointOfNoReturn(void)
 {
     AutoCaller autoCaller(this);

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -3534 +3534 @@
 // private methods
 /////////////////////////////////////////////////////////////////////////////
-    
+
 /**
  * Suspend the VM before we do any medium or network attachment change.
@@ -6908 +6908 @@
         /* The progress object will fetch the current error info */
         if (!pPowerupProgress.isNull())
-            pPowerupProgress->notifyComplete(rc);
+            pPowerupProgress->i_notifyComplete(rc);
 
         /* Save the error info across the IPC below. Can't be done before the
@@ -9176 +9176 @@
                             rc = pMachine->COMGETTER(FaultTolerancePassword)(bstrPassword.asOutParam());
                     }
-                    if (task->mProgress->setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
+                    if (task->mProgress->i_setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
                     {
                         if (SUCCEEDED(rc))
@@ -9198 +9198 @@
                             AssertLogRelRC(vrc);
                         }
-                        task->mProgress->setCancelCallback(NULL, NULL);
+                        task->mProgress->i_setCancelCallback(NULL, NULL);
                     }
                     else
@@ -9316 +9316 @@
     {
         /* Notify the progress object of the success */
-        task->mProgress->notifyComplete(S_OK);
+        task->mProgress->i_notifyComplete(S_OK);
     }
     else
     {
         /* The progress object will fetch the current error info */
-        task->mProgress->notifyComplete(rc);
+        task->mProgress->i_notifyComplete(rc);
         LogRel(("Power up failed (vrc=%Rrc, rc=%Rhrc (%#08X))\n", vrc, rc, rc));
     }
@@ -9518 +9518 @@
                 Utf8Str strSavedStateFile(pTask->bstrSavedStateFile);
 
-                pTask->mProgress->setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
+                pTask->mProgress->i_setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
 
                 alock.release();
@@ -9534 +9534 @@
                                          strSavedStateFile.c_str(), vrc);
 
-                pTask->mProgress->setCancelCallback(NULL, NULL);
+                pTask->mProgress->i_setCancelCallback(NULL, NULL);
             }
             else
                 LogRel(("Console: skipped saving state as part of online snapshot\n"));
 
-            if (!pTask->mProgress->notifyPointOfNoReturn())
+            if (!pTask->mProgress->i_notifyPointOfNoReturn())
                 throw setErrorStatic(E_FAIL, tr("Canceled"));
             that->mptrCancelableProgress.setNull();
@@ -9638 +9638 @@
 
     if (FAILED(rc)) /* Must come before calling setMachineState. */
-        pTask->mProgress->notifyComplete(rc);
+        pTask->mProgress->i_notifyComplete(rc);
 
     /*
@@ -9669 +9669 @@
                 {
                     rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
-                    pTask->mProgress->notifyComplete(rc);
+                    pTask->mProgress->i_notifyComplete(rc);
                     if (that->mMachineState == MachineState_Saving)
                         that->setMachineStateLocally(MachineState_Paused);
@@ -9746 +9746 @@
 
     if (SUCCEEDED(rc)) /* The failure cases are handled above. */
-        pTask->mProgress->notifyComplete(rc);
+        pTask->mProgress->i_notifyComplete(rc);
 
     delete pTask;

trunk/src/VBox/Main/src-client/ConsoleImplTeleporter.cpp

@@ -712 +712 @@
      * We're at the point of no return.
      */
-    if (!pState->mptrProgress->notifyPointOfNoReturn())
+    if (!pState->mptrProgress->i_notifyPointOfNoReturn())
     {
         teleporterSrcSubmitCommand(pState, "cancel", false /*fWaitForAck*/);
@@ -784 +784 @@
        complete things here on failure instead of right before cleanup. */
     if (FAILED(hrc))
-        pState->mptrProgress->notifyComplete(hrc);
+        pState->mptrProgress->i_notifyComplete(hrc);
 
     /* We can no longer be canceled (success), or it doesn't matter any longer (failure). */
-    pState->mptrProgress->setCancelCallback(NULL, NULL);
+    pState->mptrProgress->i_setCancelCallback(NULL, NULL);
 
     /*
@@ -819 +819 @@
         pState->mptrConsole->mVMIsAlreadyPoweringOff = false;
 
-        pState->mptrProgress->notifyComplete(hrc);
+        pState->mptrProgress->i_notifyComplete(hrc);
     }
     else
@@ -991 +991 @@
 
     void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
-    ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser);
+    ptrProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser);
 
     int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
@@ -1011 +1011 @@
     else
     {
-        ptrProgress->setCancelCallback(NULL, NULL);
+        ptrProgress->i_setCancelCallback(NULL, NULL);
         delete pState;
         hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
@@ -1115 +1115 @@
 
             void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState));
-            if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser))
+            if (pProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser))
             {
                 LogRel(("Teleporter: Waiting for incoming VM...\n"));
@@ -1122 +1122 @@
                 {
                     vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
-                    pProgress->setCancelCallback(NULL, NULL);
+                    pProgress->i_setCancelCallback(NULL, NULL);
 
                     if (vrc == VERR_TCP_SERVER_STOP)
@@ -1410 +1410 @@
              *       make it possible to recover from some VMR3Resume failures.
              */
-            if (   pState->mptrProgress->notifyPointOfNoReturn()
+            if (   pState->mptrProgress->i_notifyPointOfNoReturn()
                 && pState->mfLockedMedia)
             {

trunk/src/VBox/Main/src-client/GuestDnDImpl.cpp

@@ -395 +395 @@
         m_pvData = NULL;
     }
-    m_cbData = 0;    
+    m_cbData = 0;
     m_cbDataCurrent = 0;
     m_cbDataTotal = 0;
@@ -435 +435 @@
             if (uState == DragAndDropSvc::DND_PROGRESS_ERROR)
             {
-                hr = m_progress->notifyComplete(VBOX_E_IPRT_ERROR,
-                                                COM_IIDOF(IGuest),
-                                                m_parent->getComponentName(),
-                                                DnDGuestResponse::errorToString(m_parent, rcOp).c_str());
+                hr = m_progress->i_notifyComplete(VBOX_E_IPRT_ERROR,
+                                                  COM_IIDOF(IGuest),
+                                                  m_parent->getComponentName(),
+                                                  DnDGuestResponse::errorToString(m_parent, rcOp).c_str());
                 reset();
             }
@@ -455 +455 @@
                 if (   uState      == DragAndDropSvc::DND_PROGRESS_COMPLETE
                     || uPercentage >= 100)
-                    hr = m_progress->notifyComplete(S_OK);
+                    hr = m_progress->i_notifyComplete(S_OK);
             }
         }
@@ -518 +518 @@
 }
 
-int DnDGuestResponse::writeToFile(const char *pszPath, size_t cbPath, 
+int DnDGuestResponse::writeToFile(const char *pszPath, size_t cbPath,
                                   void *pvData, size_t cbData, uint32_t fMode)
 {
@@ -525 +525 @@
      *        keeps those file pointers around, or extend the
      *        actual protocol for explicit open calls.
-     *  
+     *
      *        For now we only keep one file open at a time, so if
      *        a client does alternating writes to different files
@@ -532 +532 @@
     int rc;
     if (   m_hFile == NIL_RTFILE
-        || m_strFile != pszPath) 
+        || m_strFile != pszPath)
     {
         char *pszFile = RTPathJoinA(m_strDropDir.c_str(), pszPath);
@@ -540 +540 @@
             /** @todo Respect fMode!  */
             rc = RTFileOpen(&hFile, pszFile,
-                              RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE 
+                              RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE
                             | RTFILE_O_WRITE | RTFILE_O_APPEND);
             if (RT_SUCCESS(rc))
             {
-                LogFlowFunc(("Opening \"%s\" (fMode=0x%x) for writing ...\n", 
+                LogFlowFunc(("Opening \"%s\" (fMode=0x%x) for writing ...\n",
                              pszFile, fMode));
 
@@ -955 +955 @@
         *pResultAction = d->toMainAction(pResp->defAction());
 
-        LogFlowFunc(("resFormat=%s, resAction=%RU32\n", 
+        LogFlowFunc(("resFormat=%s, resAction=%RU32\n",
                      pResp->format().c_str(), pResp->defAction()));
 

trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp

@@ -487 +487 @@
         if (RT_UNLIKELY(mData.mPID != uPID))
         {
-            LogFlowFunc(("Stale guest process (PID=%RU32) sent data to a newly started process (pProcesS=%p, PID=%RU32, status=%RU32)\n",
-                         uPID, this, mData.mPID, mData.mStatus));
+            Utf8Str str;
+            str  = "Stale guest process (PID=%RU32) sent data to newly started";
+            str += " process (pProcesS=%p, PID=%RU32, status=%RU32)\n";
+            LogFlowFunc((str.c_str(), uPID, this, mData.mPID, mData.mStatus));
             rc = VERR_NOT_FOUND;
         }
@@ -1378 +1380 @@
     {
         waitResult = ProcessWaitResult_Error;
-        AssertMsg(RT_FAILURE(mData.mLastError), ("No error rc (%Rrc) set when guest process indicated an error\n", mData.mLastError));
+        Utf8Str str;
+        str  = "No error rc (%Rrc) set when guest process indicated an error\n";
+        AssertMsg(RT_FAILURE(mData.mLastError), (str.c_str(), mData.mLastError));
         if (pGuestRc)
             *pGuestRc = mData.mLastError; /* Return last set error. */
@@ -1662 +1666 @@
                               void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc)
 {
-    LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n",
-                     mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
+    Utf8Str str;
+    str = "uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n";
+    LogFlowThisFunc((str.c_str(), mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
     /* All is optional. There can be 0 byte writes. */
 
@@ -1877 +1882 @@
 }
 
-HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
-
+HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
+                                   ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL

trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

@@ -2156 +2156 @@
     if (   mData.mProtocolVersion < 2
         && s_gctrlLegacyWarning++ < 3) /** @todo Find a bit nicer text. */
-        LogRel((tr("Warning: Guest Additions are older (%ld.%ld) than host capabilities for guest control, please upgrade them. Using protocol version %ld now\n"),
-                uVBoxMajor, uVBoxMinor, mData.mProtocolVersion));
-
+    {
+        Utf8Str str;
+        str = "Warning: Guest Additions are older (%ld.%ld) than host";
+        str += " capabilities for guest control, please upgrade them. Using protocol version %ld now\n";
+        LogRel((tr(str.c_str()), uVBoxMajor, uVBoxMinor, mData.mProtocolVersion));
+    }
     return VINF_SUCCESS;
 }
@@ -2413 +2416 @@
 }
 
-HRESULT GuestSession::copyFrom(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
+HRESULT GuestSession::copyFrom(const com::Utf8Str &aSource, const com::Utf8Str &aDest,
+                               const std::vector<CopyFileFlag_T> &aFlags,
+                               ComPtr<IProgress> &aProgress)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2442 +2447 @@
         SessionTaskCopyFrom *pTask = new SessionTaskCopyFrom(this /* GuestSession */,
                                                              aSource, aDest, fFlags);
-        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(), aDest.c_str()),
-                                pTask, pProgress);
+        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(),
+                                  aDest.c_str()), pTask, pProgress);
         if (RT_SUCCESS(rc))
             /* Return progress to the caller. */
@@ -2460 +2465 @@
 }
 
-HRESULT GuestSession::copyTo(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
+HRESULT GuestSession::copyTo(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags,
+                             ComPtr<IProgress> &aProgress)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2490 +2496 @@
                                                          aSource, aDest, fFlags);
         AssertPtrReturn(pTask, E_OUTOFMEMORY);
-        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(), aDest.c_str()),
-                                pTask, pProgress);
+        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(),
+                                  aDest.c_str()), pTask, pProgress);
         if (RT_SUCCESS(rc))
         {
@@ -2563 +2569 @@
 }
 
-HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure, com::Utf8Str &aDirectory)
+HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath,
+                                          BOOL aSecure, com::Utf8Str &aDirectory)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2635 +2642 @@
 }
 
-HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter, const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
+HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter,
+                                    const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2793 +2801 @@
 }
 
-HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
+HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
+                                               ComPtr<IProgress> &aProgress)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -2820 +2829 @@
      *       the progress object right now. */
      /** @todo Implement progress reporting on guest directory deletion! */
-    hr = pProgress->notifyComplete(S_OK);
+    hr = pProgress->i_notifyComplete(S_OK);
     if (FAILED(hr))
         return hr;
@@ -2988 +2997 @@
 }
 
-HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure, ComPtr<IGuestFile> &aFile)
+HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure,
+                                     ComPtr<IGuestFile> &aFile)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3073 +3083 @@
 }
 
-HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition, ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
+HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition,
+                               ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3087 +3098 @@
 }
 
-HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition, const com::Utf8Str &aSharingMode, ULONG aCreationMode, LONG64 aOffset, ComPtr<IGuestFile> &aFile)
+HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition,
+                                 const com::Utf8Str &aSharingMode, ULONG aCreationMode, LONG64 aOffset,
+                                 ComPtr<IGuestFile> &aFile)
 
 {
@@ -3240 +3253 @@
 }
 
-HRESULT GuestSession::fileRename(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<PathRenameFlag_T> &aFlags)
+HRESULT GuestSession::fileRename(const com::Utf8Str &aSource, const com::Utf8Str &aDest,
+                                 const std::vector<PathRenameFlag_T> &aFlags)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3298 +3312 @@
 }
 
-HRESULT GuestSession::processCreate(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments, const std::vector<com::Utf8Str> &aEnvironment, const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
+HRESULT GuestSession::processCreate(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments,
+                                    const std::vector<com::Utf8Str> &aEnvironment,
+                                    const std::vector<ProcessCreateFlag_T> &aFlags,
+                                    ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3307 +3324 @@
     std::vector<LONG> affinityIgnored;
 
-    return processCreateEx(aCommand, aArguments, aEnvironment, aFlags, aTimeoutMS, ProcessPriority_Default, affinityIgnored, aGuestProcess);
-#endif /* VBOX_WITH_GUEST_CONTROL */
-}
-
-HRESULT GuestSession::processCreateEx(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments, const std::vector<com::Utf8Str> &aEnvironment, const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS, ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity, ComPtr<IGuestProcess> &aGuestProcess)
+    return processCreateEx(aCommand, aArguments, aEnvironment, aFlags, aTimeoutMS, ProcessPriority_Default,
+                           affinityIgnored, aGuestProcess);
+#endif /* VBOX_WITH_GUEST_CONTROL */
+}
+
+HRESULT GuestSession::processCreateEx(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments,
+                                      const std::vector<com::Utf8Str> &aEnvironment,
+                                      const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS,
+                                      ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity,
+                                      ComPtr<IGuestProcess> &aGuestProcess)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3450 +3472 @@
 }
 
-HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags, com::Utf8Str &aTarget)
+HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags,
+                                  com::Utf8Str &aTarget)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL
@@ -3527 +3550 @@
 }
 
-HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
+HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS,
+                                   GuestSessionWaitResult_T *aReason)
 {
 #ifndef VBOX_WITH_GUEST_CONTROL

trunk/src/VBox/Main/src-client/GuestSessionImplTasks.cpp

@@ -128 +128 @@
         && !fCompleted)
     {
-        HRESULT hr = mProgress->notifyComplete(S_OK);
+        HRESULT hr = mProgress->i_notifyComplete(S_OK);
         if (FAILED(hr))
             return VERR_COM_UNEXPECTED; /** @todo Find a better rc. */
@@ -151 +151 @@
         && !fCompleted)
     {
-        HRESULT hr2 = mProgress->notifyComplete(hr,
-                                                COM_IIDOF(IGuestSession),
-                                                GuestSession::getStaticComponentName(),
-                                                strMsg.c_str());
+        HRESULT hr2 = mProgress->i_notifyComplete(hr,
+                                                  COM_IIDOF(IGuestSession),
+                                                  GuestSession::getStaticComponentName(),
+                                                  strMsg.c_str());
         if (FAILED(hr2))
             return hr2;

trunk/src/VBox/Main/src-client/xpcom/module.cpp

@@ -74 +74 @@
 NS_DECL_CLASSINFO(MachineDebugger)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MachineDebugger, IMachineDebugger)
-NS_DECL_CLASSINFO(Progress)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
 NS_DECL_CLASSINFO(RemoteUSBDevice)
 NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RemoteUSBDevice, IHostUSBDevice, IUSBDevice)

trunk/src/VBox/Main/src-server/ApplianceImpl.cpp

@@ -140 +140 @@
     { ovf::CIMOSType_CIMOS_FreeBSD_64,                           VBOXOSTYPE_FreeBSD_x64 },
     { ovf::CIMOSType_CIMOS_MACOS,                                VBOXOSTYPE_MacOS },
-    { ovf::CIMOSType_CIMOS_MACOS,                                VBOXOSTYPE_MacOS_x64 },            // there is no CIM 64-bit type for this
+    { ovf::CIMOSType_CIMOS_MACOS,                                VBOXOSTYPE_MacOS_x64 }, // there is no CIM 64-bit type for this
     { ovf::CIMOSType_CIMOS_MACOS,                                VBOXOSTYPE_MacOS106 },
     { ovf::CIMOSType_CIMOS_MACOS,                                VBOXOSTYPE_MacOS106_x64 },
@@ -189 +189 @@
 //     { ovf::CIMOSType_CIMOS_VMwareESXi = 104,                                                 // we can't run ESX in a VM
     { ovf::CIMOSType_CIMOS_Windows7,                             VBOXOSTYPE_Win7 },
-    { ovf::CIMOSType_CIMOS_Windows7,                             VBOXOSTYPE_Win7_x64 },         // there is no CIM 64-bit type for this
+    { ovf::CIMOSType_CIMOS_Windows7,                             VBOXOSTYPE_Win7_x64 },         // there is no
+                                                                                                // CIM 64-bit type for this
     { ovf::CIMOSType_CIMOS_CentOS,                               VBOXOSTYPE_RedHat },
     { ovf::CIMOSType_CIMOS_CentOS_64,                            VBOXOSTYPE_RedHat_x64 },
@@ -815 +816 @@
     /** @todo: Maybe too cost-intensive; try to find a lighter way */
     while (    RTPathExists(tmpName)
-            || mVirtualBox->OpenMedium(Bstr(tmpName).raw(), DeviceType_HardDisk, AccessMode_ReadWrite, FALSE /* fForceNewUuid */,  &harddisk) != VBOX_E_OBJECT_NOT_FOUND
-          )
+            || mVirtualBox->OpenMedium(Bstr(tmpName).raw(), DeviceType_HardDisk, AccessMode_ReadWrite,
+                                       FALSE /* fForceNewUuid */,  &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
     {
         RTStrFree(tmpName);
@@ -888 +889 @@
                 ++cOperations;          // another one for creating the manifest
 
-                m->ulWeightForManifestOperation = (ULONG)((double)m->ulTotalDisksMB * .1 / 100);    // use .5% of the progress for the manifest
+                m->ulWeightForManifestOperation = (ULONG)((double)m->ulTotalDisksMB * .1 / 100);    // use .5% of the
+                                                                                                    // progress for the manifest
                 ulTotalOperationsWeight += m->ulWeightForManifestOperation;
             }
@@ -916 +918 @@
             if (m->ulTotalDisksMB)
             {
-                m->ulWeightForXmlOperation = (ULONG)((double)m->ulTotalDisksMB * 1  / 100);    // use 1% of the progress for OVF file upload (we didn't know the size at this point)
+                m->ulWeightForXmlOperation = (ULONG)((double)m->ulTotalDisksMB * 1  / 100);    // use 1% of the progress
+                                                                                               // for OVF file upload
+                                                                                               // (we didn't know the
+                                                                                               // size at this point)
                 ulTotalOperationsWeight = m->ulTotalDisksMB + m->ulWeightForXmlOperation;
             }
@@ -925 +930 @@
                 m->ulWeightForXmlOperation = 1;
             }
-            ULONG ulOVFCreationWeight = (ULONG)((double)ulTotalOperationsWeight * 50.0 / 100.0); /* Use 50% for the creation of the OVF & the disks */
+            ULONG ulOVFCreationWeight = (ULONG)((double)ulTotalOperationsWeight * 50.0 / 100.0); /* Use 50% for the
+                                                                                                    creation of the OVF
+                                                                                                    & the disks */
             ulTotalOperationsWeight += ulOVFCreationWeight;
             break;
@@ -931 +938 @@
     }
 
-    Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightForXmlOperation = %d\n",
-         m->ulTotalDisksMB, m->cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightForXmlOperation));
+    Utf8Str str;
+    str = "Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d,";
+    str +=  "ulTotalOperationsWeight = %d, m->ulWeightForXmlOperation = %d\n";
+    Log((str.c_str(), m->ulTotalDisksMB, m->cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightForXmlOperation));
 
     rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
@@ -1172 +1181 @@
 
     if (!task->pProgress.isNull())
-        task->pProgress->notifyComplete(taskrc);
+        task->pProgress->i_notifyComplete(taskrc);
 
     LogFlowFuncLeave();

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -5662 +5662 @@
 
     HRESULT rc = pTask->pMachine->deleteTaskWorker(*pTask);
-    pTask->pProgress->notifyComplete(rc);
+    pTask->pProgress->i_notifyComplete(rc);
 
     delete pTask;
@@ -8394 +8394 @@
         if (!mData->mSession.mProgress.isNull())
         {
-            mData->mSession.mProgress->notifyComplete(rc);
+            mData->mSession.mProgress->i_notifyComplete(rc);
             mData->mSession.mProgress.setNull();
         }
@@ -13122 +13122 @@
     {
         if (aReason == Uninit::Normal)
-            mData->mSession.mProgress->notifyComplete(S_OK);
+            mData->mSession.mProgress->i_notifyComplete(S_OK);
         else
-            mData->mSession.mProgress->notifyComplete(E_FAIL,
-                                                      COM_IIDOF(ISession),
-                                                      getComponentName(),
-                                                      tr("The VM session was aborted"));
+            mData->mSession.mProgress->i_notifyComplete(E_FAIL,
+                                                       COM_IIDOF(ISession),
+                                                       getComponentName(),
+                                                       tr("The VM session was aborted"));
         mData->mSession.mProgress.setNull();
     }
@@ -13312 +13312 @@
     if (mData->mSession.mProgress)
     {
-        mData->mSession.mProgress->notifyComplete((HRESULT)iResult);
+        mData->mSession.mProgress->i_notifyComplete((HRESULT)iResult);
         mData->mSession.mProgress.setNull();
     }
@@ -13396 +13396 @@
     Assert(mConsoleTaskData.mProgress);
     if (SUCCEEDED(iResult))
-        mConsoleTaskData.mProgress->notifyComplete(S_OK);
+        mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
     else
     {
         Utf8Str strErrMsg(aErrMsg);
         if (strErrMsg.length())
-            mConsoleTaskData.mProgress->notifyComplete(iResult,
-                                                       COM_IIDOF(ISession),
-                                                       getComponentName(),
-                                                       strErrMsg.c_str());
+            mConsoleTaskData.mProgress->i_notifyComplete(iResult,
+                                                         COM_IIDOF(ISession),
+                                                         getComponentName(),
+                                                         strErrMsg.c_str());
         else
-            mConsoleTaskData.mProgress->notifyComplete(iResult);
+            mConsoleTaskData.mProgress->i_notifyComplete(iResult);
     }
 
@@ -13601 +13601 @@
             /* finalize the progress, someone might wait if a frontend
              * closes the session before powering on the VM. */
-            mData->mSession.mProgress->notifyComplete(E_FAIL,
-                                                      COM_IIDOF(ISession),
-                                                      getComponentName(),
-                                                      tr("The VM session was closed before any attempt to power it on"));
+            mData->mSession.mProgress->i_notifyComplete(E_FAIL,
+                                                        COM_IIDOF(ISession),
+                                                        getComponentName(),
+                                                        tr("The VM session was closed before any attempt to power it on"));
             mData->mSession.mProgress.setNull();
         }
@@ -14644 +14644 @@
     Assert(mConsoleTaskData.mProgress);
     if (SUCCEEDED(aRc))
-        mConsoleTaskData.mProgress->notifyComplete(S_OK);
+        mConsoleTaskData.mProgress->i_notifyComplete(S_OK);
     else
     {
         if (aErrMsg.length())
-            mConsoleTaskData.mProgress->notifyComplete(aRc,
-                                                       COM_IIDOF(ISession),
-                                                       getComponentName(),
-                                                       aErrMsg.c_str());
+            mConsoleTaskData.mProgress->i_notifyComplete(aRc,
+                                                         COM_IIDOF(ISession),
+                                                         getComponentName(),
+                                                         aErrMsg.c_str());
         else
-            mConsoleTaskData.mProgress->notifyComplete(aRc);
+            mConsoleTaskData.mProgress->i_notifyComplete(aRc);
     }
 

trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp

@@ -62 +62 @@
 struct MachineCloneVMPrivate
 {
-    MachineCloneVMPrivate(MachineCloneVM *a_q, ComObjPtr<Machine> &a_pSrcMachine, ComObjPtr<Machine> &a_pTrgMachine, CloneMode_T a_mode, const RTCList<CloneOptions_T> &opts)
+    MachineCloneVMPrivate(MachineCloneVM *a_q, ComObjPtr<Machine> &a_pSrcMachine, ComObjPtr<Machine> &a_pTrgMachine,
+                          CloneMode_T a_mode, const RTCList<CloneOptions_T> &opts)
       : q_ptr(a_q)
       , p(a_pSrcMachine)
@@ -90 +91 @@
         HRESULT rc = pTask->q_ptr->run();
 
-        pTask->pProgress->notifyComplete(rc);
+        pTask->pProgress->i_notifyComplete(rc);
 
         pTask->q_ptr->destroy();
@@ -104 +105 @@
     inline HRESULT addSaveState(const ComObjPtr<Machine> &machine, ULONG &uCount, ULONG &uTotalWeight);
     inline HRESULT queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const;
-    HRESULT queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
-    HRESULT queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
-    HRESULT queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
+    HRESULT queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList,
+                                       bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
+    HRESULT queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList,
+                                                bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight);
+    HRESULT queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount,
+                                    ULONG &uTotalWeight);
 
     /* MachineCloneVM::run helper: */
@@ -115 +119 @@
     void updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
     void updateStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
-    HRESULT createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent, const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia, ComObjPtr<Medium> *ppDiff) const;
+    HRESULT createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent,
+                                     const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia,
+                                     ComObjPtr<Medium> *ppDiff) const;
     static int copyStateFileProgress(unsigned uPercentage, void *pvUser);
 
@@ -134 +140 @@
 };
 
-HRESULT MachineCloneVMPrivate::createMachineList(const ComPtr<ISnapshot> &pSnapshot, RTCList< ComObjPtr<Machine> > &machineList) const
-{
+HRESULT MachineCloneVMPrivate::createMachineList(const ComPtr<ISnapshot> &pSnapshot,
+                                                 RTCList< ComObjPtr<Machine> > &machineList) const
+ {
     HRESULT rc = S_OK;
     Bstr name;
@@ -158 +165 @@
 }
 
-void MachineCloneVMPrivate::updateProgressStats(MEDIUMTASKCHAIN &mtc, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight) const
+void MachineCloneVMPrivate::updateProgressStats(MEDIUMTASKCHAIN &mtc, bool fAttachLinked,
+                                                ULONG &uCount, ULONG &uTotalWeight) const
 {
     if (fAttachLinked)
@@ -205 +213 @@
         int vrc = RTFileQuerySize(sst.strSaveStateFile.c_str(), &cbSize);
         if (RT_FAILURE(vrc))
-            return p->setError(VBOX_E_IPRT_ERROR, p->tr("Could not query file size of '%s' (%Rrc)"), sst.strSaveStateFile.c_str(), vrc);
+            return p->setError(VBOX_E_IPRT_ERROR, p->tr("Could not query file size of '%s' (%Rrc)"),
+                               sst.strSaveStateFile.c_str(), vrc);
         /* same rule as above: count both the data which needs to
          * be read and written */
@@ -228 +237 @@
 }
 
-HRESULT MachineCloneVMPrivate::queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
+HRESULT MachineCloneVMPrivate::queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList,
+                                                          bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
 {
     /* This mode is pretty straightforward. We didn't need to know about any
@@ -306 +316 @@
 }
 
-HRESULT MachineCloneVMPrivate::queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
+HRESULT MachineCloneVMPrivate::queryMediasForMachineAndChildStates(const RTCList<ComObjPtr<Machine> > &machineList,
+                                                                   bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
 {
     /* This is basically a three step approach. First select all medias
@@ -468 +479 @@
 }
 
-HRESULT MachineCloneVMPrivate::queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
+HRESULT MachineCloneVMPrivate::queryMediasForAllStates(const RTCList<ComObjPtr<Machine> > &machineList,
+                                                       bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight)
 {
     /* In this case we create a exact copy of the original VM. This means just
@@ -597 +609 @@
 }
 
-void MachineCloneVMPrivate::updateStorageLists(settings::StorageControllersList &sc, const Bstr &bstrOldId, const Bstr &bstrNewId) const
+void MachineCloneVMPrivate::updateStorageLists(settings::StorageControllersList &sc,
+                                               const Bstr &bstrOldId, const Bstr &bstrNewId) const
 {
     settings::StorageControllersList::iterator it3;
@@ -619 +632 @@
 }
 
-void MachineCloneVMPrivate::updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const
+void MachineCloneVMPrivate::updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId,
+                                                       const Bstr &bstrNewId) const
 {
     settings::SnapshotsList::iterator it;
@@ -644 +658 @@
 }
 
-HRESULT MachineCloneVMPrivate::createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent, const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia, ComObjPtr<Medium> *ppDiff) const
+HRESULT MachineCloneVMPrivate::createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent,
+                                                        const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia,
+                                                        ComObjPtr<Medium> *ppDiff) const
 {
     HRESULT rc = S_OK;
@@ -716 +732 @@
 /////////////////////////////////////////////////////////////////////////////
 
-MachineCloneVM::MachineCloneVM(ComObjPtr<Machine> pSrcMachine, ComObjPtr<Machine> pTrgMachine, CloneMode_T mode, const RTCList<CloneOptions_T> &opts)
-    : d_ptr(new MachineCloneVMPrivate(this, pSrcMachine, pTrgMachine, mode, opts))
+MachineCloneVM::MachineCloneVM(ComObjPtr<Machine> pSrcMachine, ComObjPtr<Machine> pTrgMachine, CloneMode_T mode,
+                               const RTCList<CloneOptions_T> &opts) :
+                               d_ptr(new MachineCloneVMPrivate(this, pSrcMachine, pTrgMachine, mode, opts))
 {
 }
@@ -881 +898 @@
         switch (d->mode)
         {
-            case CloneMode_MachineState:          d->queryMediasForMachineState(machineList, fAttachLinked, uCount, uTotalWeight); break;
-            case CloneMode_MachineAndChildStates: d->queryMediasForMachineAndChildStates(machineList, fAttachLinked, uCount, uTotalWeight); break;
-            case CloneMode_AllStates:             d->queryMediasForAllStates(machineList, fAttachLinked, uCount, uTotalWeight); break;
+            case CloneMode_MachineState:          d->queryMediasForMachineState(machineList, fAttachLinked,
+                                                                                uCount, uTotalWeight);
+                                                  break;
+            case CloneMode_MachineAndChildStates: d->queryMediasForMachineAndChildStates(machineList, fAttachLinked,
+                                                                                         uCount, uTotalWeight);
+                                                  break;
+            case CloneMode_AllStates:             d->queryMediasForAllStates(machineList, fAttachLinked, uCount,
+                                                                             uTotalWeight);
+                                                  break;
         }
 
@@ -1013 +1036 @@
         if (FAILED(rc)) throw rc;
         /* The absolute name of the snapshot folder. */
-        strTrgSnapshotFolder = Utf8StrFmt("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER, trgMCF.machineUserData.strSnapshotFolder.c_str());
+        strTrgSnapshotFolder = Utf8StrFmt("%s%c%s", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
+                                                    trgMCF.machineUserData.strSnapshotFolder.c_str());
 
         /* Should we rename the disk names. */
@@ -1041 +1065 @@
                 if (FAILED(rc)) throw rc;
 
-                rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Cloning Disk '%ls' ..."), bstrSrcName.raw()).raw(), mt.uWeight);
+                rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Cloning Disk '%ls' ..."), bstrSrcName.raw()).raw(),
+                                                    mt.uWeight);
                 if (FAILED(rc)) throw rc;
 
@@ -1142 +1167 @@
                              * template: "new name-disk1.vdi". */
                             if (strSrcTest == strOldVMName)
-                                strNewName = Utf8StrFmt("%s%s", trgMCF.machineUserData.strName.c_str(), RTPathSuffix(Utf8Str(bstrSrcName).c_str()));
+                                strNewName = Utf8StrFmt("%s%s", trgMCF.machineUserData.strName.c_str(),
+                                                                RTPathSuffix(Utf8Str(bstrSrcName).c_str()));
                             else if (   strSrcTest.startsWith("{")
                                      && strSrcTest.endsWith("}"))
@@ -1150 +1176 @@
                                 Guid temp_guid(strSrcTest);
                                 if (temp_guid.isValid() && !temp_guid.isZero())
-                                    strNewName = Utf8StrFmt("%s%s", newId.toStringCurly().c_str(), RTPathSuffix(strNewName.c_str()));
+                                    strNewName = Utf8StrFmt("%s%s", newId.toStringCurly().c_str(),
+                                                                    RTPathSuffix(strNewName.c_str()));
                             }
                             else
@@ -1322 +1349 @@
             if (RT_FAILURE(vrc))
                 throw p->setError(VBOX_E_IPRT_ERROR,
-                                  p->tr("Could not create snapshots folder '%s' (%Rrc)"), strTrgSnapshotFolder.c_str(), vrc);
+                                  p->tr("Could not create snapshots folder '%s' (%Rrc)"),
+                                  strTrgSnapshotFolder.c_str(), vrc);
         }
         /* Clone all save state files. */
@@ -1328 +1356 @@
         {
             SAVESTATETASK sst = d->llSaveStateFiles.at(i);
-            const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER, RTPathFilename(sst.strSaveStateFile.c_str()));
+            const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
+                                                        RTPathFilename(sst.strSaveStateFile.c_str()));
 
             /* Move to next sub-operation. */
-            rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Copy save state file '%s' ..."), RTPathFilename(sst.strSaveStateFile.c_str())).raw(), sst.uWeight);
+            rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Copy save state file '%s' ..."),
+                                                RTPathFilename(sst.strSaveStateFile.c_str())).raw(), sst.uWeight);
             if (FAILED(rc)) throw rc;
             /* Copy the file only if it was not copied already. */
             if (!newFiles.contains(strTrgSaveState.c_str()))
             {
-                int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0, MachineCloneVMPrivate::copyStateFileProgress, &d->pProgress);
+                int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0,
+                                       MachineCloneVMPrivate::copyStateFileProgress, &d->pProgress);
                 if (RT_FAILURE(vrc))
                     throw p->setError(VBOX_E_IPRT_ERROR,
-                                      p->tr("Could not copy state file '%s' to '%s' (%Rrc)"), sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
+                                      p->tr("Could not copy state file '%s' to '%s' (%Rrc)"),
+                                            sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
                 newFiles.append(strTrgSaveState);
             }
@@ -1351 +1383 @@
 
         {
-            rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Create Machine Clone '%s' ..."), trgMCF.machineUserData.strName.c_str()).raw(), 1);
+            rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Create Machine Clone '%s' ..."),
+                                                trgMCF.machineUserData.strName.c_str()).raw(), 1);
             if (FAILED(rc)) throw rc;
             /* After modifying the new machine config, we can copy the stuff

trunk/src/VBox/Main/src-server/MediumImpl.cpp

@@ -682 +682 @@
     /* complete the progress if run asynchronously */
     if (pTask->isAsync())
-    {
         if (!pTask->mProgress.isNull())
-            pTask->mProgress->notifyComplete(rc);
-    }
+            pTask->mProgress->i_notifyComplete(rc);
 
     /* pTask is no longer needed, delete it. */

trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp

@@ -158 +158 @@
     HRESULT hrc = S_OK;
     if (!mCompleted)
-         hrc = Progress::notifyComplete(aResultCode);
+         hrc = Progress::i_notifyComplete(aResultCode);
     return hrc;
 }
@@ -178 +178 @@
         va_list va;
         va_start(va, aText);
-        hrc = Progress::notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
+        hrc = Progress::i_notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
         va_end(va);
     }
@@ -376 +376 @@
                         Utf8Str strText(bstrText);
                         LogFlowThisFunc(("Got ErrorInfo(%s); hrcResult=%Rhrc\n", strText.c_str(), hrcResult));
-                        Progress::notifyComplete((HRESULT)hrcResult,
-                                                 Guid(bstrIID).ref(),
-                                                 Utf8Str(bstrComponent).c_str(),
-                                                 "%s", strText.c_str());
+                        Progress::i_notifyComplete((HRESULT)hrcResult,
+                                                   Guid(bstrIID).ref(),
+                                                   Utf8Str(bstrComponent).c_str(),
+                                                   "%s", strText.c_str());
                     }
                     else
                     {
                         LogFlowThisFunc(("ErrorInfo failed with hrc=%Rhrc; hrcResult=%Rhrc\n", hrc, hrcResult));
-                        Progress::notifyComplete((HRESULT)hrcResult,
-                                                 COM_IIDOF(IProgress),
-                                                 "ProgressProxy",
-                                                 tr("No error info"));
+                        Progress::i_notifyComplete((HRESULT)hrcResult,
+                                                   COM_IIDOF(IProgress),
+                                                   "ProgressProxy",
+                                                   tr("No error info"));
                     }
                 }
@@ -467 +467 @@
                 double rdPercent = ((double)uPct / 100 * muOtherProgressWeight + muOtherProgressStartWeight)
                                  / m_ulTotalOperationsWeight * 100;
-                *aPercent = RT_MIN((ULONG)rdPercent, 99); /* mptrOtherProgress is cleared when its completed, so we can never return 100%. */
+                *aPercent = RT_MIN((ULONG)rdPercent, 99); /* mptrOtherProgress is cleared when its completed,
+                                                             so we can never return 100%. */
             }
         }

trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

@@ -1422 +1422 @@
         && mData->mCurrentSnapshot->i_getDepth() >= SETTINGS_SNAPSHOT_DEPTH_MAX)
     {
+        Utf8Str str;
+        str = "Cannot take another snapshot for machine '%s', because it exceeds the maximum";
+        str += "snapshot depth limit. Please delete some earlier snapshot which you no longer need";
         return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Cannot take another snapshot for machine '%s', because it exceeds the maximum snapshot depth limit. Please delete some earlier snapshot which you no longer need"),
+                        tr(str.c_str()),
                         mUserData->s.strName.c_str());
     }
@@ -1731 +1734 @@
             ++ulTotalWeight;         // assume one MB weight for each differencing hard disk to manage
             Assert(pAttach->i_getMedium());
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->i_getMedium()->i_getName().c_str()));
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount,
+                             pAttach->i_getMedium()->i_getName().c_str()));
         }
     }
@@ -1800 +1804 @@
         /* we might have been uninitialized because the session was accidentally
          * closed by the client, so don't assert */
-        aTask.pProgress->notifyComplete(E_FAIL,
-                                        COM_IIDOF(IMachine),
-                                        getComponentName(),
-                                        tr("The session has been accidentally closed"));
+        aTask.pProgress->i_notifyComplete(E_FAIL,
+                                          COM_IIDOF(IMachine),
+                                          getComponentName(),
+                                          tr("The session has been accidentally closed"));
 
         LogFlowThisFuncLeave();
@@ -2036 +2040 @@
 
     /* set the result (this will try to fetch current error info on failure) */
-    aTask.pProgress->notifyComplete(rc);
+    aTask.pProgress->i_notifyComplete(rc);
 
     if (SUCCEEDED(rc))
@@ -2110 +2114 @@
 
     AutoWriteLock snapshotLock(pSnapshot COMMA_LOCKVAL_SRC_POS);
+    Utf8Str str;
 
     size_t childrenCount = pSnapshot->i_getChildrenCount();
     if (childrenCount > 1)
+    {
+        str = "Snapshot '%s' of the machine '%s' cannot be deleted, because it has %d child snapshots,";
+        str += "which is more than the one snapshot allowed for deletion";
         return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Snapshot '%s' of the machine '%s' cannot be deleted, because it has %d child snapshots, which is more than the one snapshot allowed for deletion"),
+                        tr(str.c_str()),
                         pSnapshot->i_getName().c_str(),
                         mUserData->s.strName.c_str(),
                         childrenCount);
+    }
 
     if (pSnapshot == mData->mCurrentSnapshot && childrenCount >= 1)
+    {
+        str = "Snapshot '%s' of the machine '%s' cannot be deleted, because it is the current";
+        str += "snapshot and has one child snapshot";
         return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Snapshot '%s' of the machine '%s' cannot be deleted, because it is the current snapshot and has one child snapshot"),
+                        tr(str.c_str()),
                         pSnapshot->i_getName().c_str(),
                         mUserData->s.strName.c_str());
+    }
 
     /* If the snapshot being deleted is the current one, ensure current
@@ -2340 +2353 @@
         /* we might have been uninitialized because the session was accidentally
          * closed by the client, so don't assert */
-        aTask.pProgress->notifyComplete(E_FAIL,
-                                        COM_IIDOF(IMachine),
-                                        getComponentName(),
-                                        tr("The session has been accidentally closed"));
+        aTask.pProgress->i_notifyComplete(E_FAIL,
+                                          COM_IIDOF(IMachine),
+                                          getComponentName(),
+                                          tr("The session has been accidentally closed"));
         LogFlowThisFuncLeave();
         return;
@@ -2906 +2919 @@
 
     // report the result (this will try to fetch current error info on failure)
-    aTask.pProgress->notifyComplete(rc);
+    aTask.pProgress->i_notifyComplete(rc);
 
     if (SUCCEEDED(rc))

trunk/src/VBox/Main/src-server/VFSExplorerImpl.cpp

@@ -78 +78 @@
  * @return
  */
-HRESULT VFSExplorer::init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername, Utf8Str aPassword, VirtualBox *aVirtualBox)
+HRESULT VFSExplorer::init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername,
+                          Utf8Str aPassword, VirtualBox *aVirtualBox)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -312 +313 @@
                 if (   name != "."
                     && name != "..")
-                    fileList.push_back(VFSExplorer::Data::DirEntry(name, i_RTToVFSFileType(entry.Info.Attr.fMode), entry.Info.cbObject, entry.Info.Attr.fMode & (RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXG | RTFS_UNIX_IRWXO)));
+                    fileList.push_back(VFSExplorer::Data::DirEntry(name, i_RTToVFSFileType(entry.Info.Attr.fMode),
+                                       entry.Info.cbObject,
+                                       entry.Info.Attr.fMode & (RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXG | RTFS_UNIX_IRWXO)));
             }
         }
@@ -339 +342 @@
 
     if (!aTask->progress.isNull())
-        aTask->progress->notifyComplete(rc);
+        aTask->progress->i_notifyComplete(rc);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -386 +389 @@
 
     if (!aTask->progress.isNull())
-        aTask->progress->notifyComplete(rc);
+        aTask->progress->i_notifyComplete(rc);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -428 +431 @@
             {
                 /* Set always read/write permissions of the current logged in user. */
-                fileList.push_back(VFSExplorer::Data::DirEntry(pBuckets->pszName, VFSFileType_Directory, 0, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR));
+                fileList.push_back(VFSExplorer::Data::DirEntry(pBuckets->pszName, VFSFileType_Directory,
+                                   0, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR));
                 pBuckets = pBuckets->pNext;
             }
@@ -445 +449 @@
                 Utf8Str name(pKeys->pszName);
                 /* Set always read/write permissions of the current logged in user. */
-                fileList.push_back(VFSExplorer::Data::DirEntry(pKeys->pszName, VFSFileType_File, pKeys->cbFile, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR));
+                fileList.push_back(VFSExplorer::Data::DirEntry(pKeys->pszName, VFSFileType_File, pKeys->cbFile,
+                                   RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR));
                 pKeys = pKeys->pNext;
             }
@@ -466 +471 @@
 
     if (!aTask->progress.isNull())
-        aTask->progress->notifyComplete(rc);
+        aTask->progress->i_notifyComplete(rc);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));
@@ -520 +525 @@
 
     if (!aTask->progress.isNull())
-        aTask->progress->notifyComplete(rc);
+        aTask->progress->i_notifyComplete(rc);
 
     LogFlowFunc(("rc=%Rhrc\n", rc));

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -2560 +2560 @@
     }
 
-    d->progress->notifyComplete(rc);
+    d->progress->i_notifyComplete(rc);
 
     LogFlowFuncLeave();

trunk/src/VBox/Main/src-server/generic/NetIf-generic.cpp

@@ -157 +157 @@
 }
 
-int NetIfEnableStaticIpConfigV6(VirtualBox * /* vBox */, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
+int NetIfEnableStaticIpConfigV6(VirtualBox * /* vBox */, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address,
+                                IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
 {
     char szAddress[5*8 + 1 + 5 + 1];
@@ -205 +206 @@
             if (RT_FAILURE(rc))
             {
-                progress->notifyComplete(E_FAIL,
-                                         COM_IIDOF(IHostNetworkInterface),
-                                         HostNetworkInterface::getStaticComponentName(),
-                                         "Failed to get program path, rc=%Rrc\n", rc);
+                progress->i_notifyComplete(E_FAIL,
+                                           COM_IIDOF(IHostNetworkInterface),
+                                           HostNetworkInterface::getStaticComponentName(),
+                                           "Failed to get program path, rc=%Rrc\n", rc);
                 return rc;
             }
@@ -235 +236 @@
                     if (!strncmp(VBOXNETADPCTL_NAME ":", szBuf, sizeof(VBOXNETADPCTL_NAME)))
                     {
-                        progress->notifyComplete(E_FAIL,
-                                                 COM_IIDOF(IHostNetworkInterface),
-                                                 HostNetworkInterface::getStaticComponentName(),
-                                                 "%s", szBuf);
+                        progress->i_notifyComplete(E_FAIL,
+                                                   COM_IIDOF(IHostNetworkInterface),
+                                                   HostNetworkInterface::getStaticComponentName(),
+                                                   "%s", szBuf);
                         pclose(fp);
                         return E_FAIL;
@@ -254 +255 @@
                         if (RT_FAILURE(rc))
                         {
-                            progress->notifyComplete(E_FAIL,
-                                                     COM_IIDOF(IHostNetworkInterface),
-                                                     HostNetworkInterface::getStaticComponentName(),
-                                                     "Failed to get config info for %s (as reported by '" VBOXNETADPCTL_NAME " add')\n", szBuf);
+                            progress->i_notifyComplete(E_FAIL,
+                                                       COM_IIDOF(IHostNetworkInterface),
+                                                       HostNetworkInterface::getStaticComponentName(),
+                                                       "Failed to get config info for %s (as reported by '"
+                                                       VBOXNETADPCTL_NAME " add')\n", szBuf);
                         }
                         else
@@ -273 +275 @@
                     if ((rc = pclose(fp)) != 0)
                     {
-                        progress->notifyComplete(E_FAIL,
-                                                 COM_IIDOF(IHostNetworkInterface),
-                                                 HostNetworkInterface::getStaticComponentName(),
-                                                 "Failed to execute '" VBOXNETADPCTL_NAME " add' (exit status: %d)", rc);
+                        progress->i_notifyComplete(E_FAIL,
+                                                   COM_IIDOF(IHostNetworkInterface),
+                                                   HostNetworkInterface::getStaticComponentName(),
+                                                   "Failed to execute '" VBOXNETADPCTL_NAME " add' (exit status: %d)", rc);
                         rc = VERR_INTERNAL_ERROR;
                     }
@@ -284 +286 @@
                     /* Failed to add an interface */
                     rc = VERR_PERMISSION_DENIED;
-                    progress->notifyComplete(E_FAIL,
-                                             COM_IIDOF(IHostNetworkInterface),
-                                             HostNetworkInterface::getStaticComponentName(),
-                                             "Failed to execute '" VBOXNETADPCTL_NAME " add' (exit status: %d). Check permissions!", rc);
+                    progress->i_notifyComplete(E_FAIL,
+                                               COM_IIDOF(IHostNetworkInterface),
+                                               HostNetworkInterface::getStaticComponentName(),
+                                               "Failed to execute '" VBOXNETADPCTL_NAME
+                                               " add' (exit status: %d). Check permissions!", rc);
                     pclose(fp);
                 }
             }
             if (RT_SUCCESS(rc))
-                progress->notifyComplete(rc);
+                progress->i_notifyComplete(rc);
             else
                 hrc = E_FAIL;
@@ -337 +340 @@
             rc = NetIfAdpCtl(Utf8Str(ifname).c_str(), "remove", NULL, NULL);
             if (RT_FAILURE(rc))
-                progress->notifyComplete(E_FAIL,
-                                         COM_IIDOF(IHostNetworkInterface),
-                                         HostNetworkInterface::getStaticComponentName(),
-                                         "Failed to execute '" VBOXNETADPCTL_NAME "' (exit status: %d)", rc);
+                progress->i_notifyComplete(E_FAIL,
+                                           COM_IIDOF(IHostNetworkInterface),
+                                           HostNetworkInterface::getStaticComponentName(),
+                                           "Failed to execute '" VBOXNETADPCTL_NAME "' (exit status: %d)", rc);
             else
-                progress->notifyComplete(S_OK);
+                progress->i_notifyComplete(S_OK);
         }
     }
     else
     {
-        progress->notifyComplete(hr);
+        progress->i_notifyComplete(hr);
         rc = VERR_INTERNAL_ERROR;
     }

trunk/src/VBox/Main/src-server/xpcom/server.cpp

@@ -114 +114 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SnapshotMachine, IMachine)
 
-NS_DECL_CLASSINFO(Progress)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
-
 NS_DECL_CLASSINFO(ProgressProxy)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ProgressProxy, IProgress)