Index: /trunk/include/VBox/com/Guid.h
===================================================================
--- /trunk/include/VBox/com/Guid.h	(revision 51686)
+++ /trunk/include/VBox/com/Guid.h	(revision 51687)
@@ -5,5 +5,5 @@
 
 /*
- * Copyright (C) 2006-2012 Oracle Corporation
+ * Copyright (C) 2006-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -36,8 +36,4 @@
 #endif
 
-#if defined(VBOX_WITH_XPCOM)
-# include <nsMemory.h>
-#endif
-
 #include "VBox/com/string.h"
 
@@ -48,10 +44,10 @@
 {
 
-typedef enum
-    {
-        ZERO_GUID,
-        NORMAL_GUID,
-        INVALID_GUID
-    }GuidState_t;
+typedef enum GuidState_t
+{
+    GUID_ZERO,
+    GUID_NORMAL,
+    GUID_INVALID
+} GuidState_t;
 
 /**
@@ -66,6 +62,6 @@
     {
         ::RTUuidClear(&mUuid);
-        refresh();
-        mGuidState = ZERO_GUID;
+        mGuidState = GUID_ZERO;
+        dbg_refresh();
     }
 
@@ -73,19 +69,15 @@
     {
         mUuid = that.mUuid;
-        refresh();
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
-        else
-            mGuidState = NORMAL_GUID;
+        mGuidState = that.mGuidState;
+        dbg_refresh();
     }
 
     Guid(const RTUUID &that)
     {
+        mGuidState = GUID_NORMAL;
         mUuid = that;
-        refresh();
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
-        else
-            mGuidState = NORMAL_GUID;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
     }
 
@@ -94,126 +86,213 @@
         AssertCompileSize(GUID, sizeof(RTUUID));
         ::memcpy(&mUuid, &that, sizeof(GUID));
-        refresh();
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
+        mGuidState = GUID_NORMAL;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
+    }
+
+    /**
+     * Construct a GUID from a string.
+     *
+     * @param   that        The UUID string. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     *                      invalid.
+     */
+    Guid(const char *that)
+    {
+        if (!that || !*that)
+        {
+            ::RTUuidClear(&mUuid);
+            mGuidState = GUID_ZERO;
+        }
         else
-            mGuidState = NORMAL_GUID;
-    }
-
-    /**
-     * Construct a GUID from a string.
-     *
-     * Should the string be invalid, the object will be set to the null GUID
-     * (isEmpty() == true).
-     *
-     * @param   that        The UUID string.  We feed this to RTUuidFromStr(),
-     *                      so check it out for the exact format.
-     */
-    Guid(const char *that)
-    {
-        mGuidState = NORMAL_GUID;
-
-        int rc = ::RTUuidFromStr(&mUuid, that);
-
-        if (RT_FAILURE(rc))
-        {
-            ::RTUuidClear(&mUuid);
-            mGuidState = INVALID_GUID;
-        }
-        else if(isEmpty())
-            mGuidState = ZERO_GUID;
-        refresh();
-    }
-
-    /**
-     * Construct a GUID from a BSTR.
-     *
-     * Should the string be empty or invalid, the object will be set to the
-     * null GUID (isEmpty() == true).
-     *
-     * @param   that        The UUID BSTR.  We feed this to RTUuidFromUtf16(),
-     *                      so check it out for the exact format.
-     */
-    Guid(const Bstr &that)
-    {
-        mGuidState = NORMAL_GUID;
-
-        if (that.isEmpty())
-        {
-            ::RTUuidClear(&mUuid);
-            mGuidState = ZERO_GUID;
-        }
-        else
-        {
-            int rc = ::RTUuidFromUtf16(&mUuid, that.raw());
+        {
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromStr(&mUuid, that);
             if (RT_FAILURE(rc))
             {
                 ::RTUuidClear(&mUuid);
-                mGuidState = INVALID_GUID;
+                mGuidState = GUID_INVALID;
             }
-        }
-
-        refresh();
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
+    }
+
+    /**
+     * Construct a GUID from a BSTR.
+     *
+     * @param   that        The UUID BSTR. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     *                      invalid.
+     */
+    Guid(CBSTR that)
+    {
+        if (!that || !*that)
+        {
+            ::RTUuidClear(&mUuid);
+            mGuidState = GUID_ZERO;
+        }
+        else
+        {
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromUtf16(&mUuid, that);
+            if (RT_FAILURE(rc))
+            {
+                ::RTUuidClear(&mUuid);
+                mGuidState = GUID_INVALID;
+            }
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
+    }
+
+    /**
+     * Construct a GUID from a Utf8Str.
+     *
+     * @param   that        The UUID Utf8Str. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const Utf8Str &that)
+    {
+        Guid(that.c_str());
+    }
+
+    /**
+     * Construct a GUID from a RTCString.
+     *
+     * @param   that        The UUID RTCString. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const RTCString &that)
+    {
+        Guid(that.c_str());
+    }
+
+    /**
+     * Construct a GUID from a Bstr.
+     *
+     * @param   that        The UUID Bstr. Can be with or without the curly
+     *                      brackets. Empty strings are translated to a zero
+     *                      GUID, and strings which are not confirming to
+     *                      valid GUID string representations are marked as
+     */
+    Guid(const Bstr &that)
+    {
+        Guid(that.raw());
     }
 
     Guid& operator=(const Guid &that)
     {
-        mGuidState = NORMAL_GUID;
-        ::memcpy(&mUuid, &that.mUuid, sizeof (RTUUID));
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
-        refresh();
+        mUuid = that.mUuid;
+        mGuidState = that.mGuidState;
+        dbg_refresh();
         return *this;
     }
+
+    Guid& operator=(const RTUUID &guid)
+    {
+        mUuid = guid;
+        mGuidState = GUID_NORMAL;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
+        return *this;
+    }
+
     Guid& operator=(const GUID &guid)
     {
-        mGuidState = NORMAL_GUID;
-        ::memcpy(&mUuid, &guid, sizeof (GUID));
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
-        refresh();
+        AssertCompileSize(GUID, sizeof(RTUUID));
+        ::memcpy(&mUuid, &guid, sizeof(GUID));
+        mGuidState = GUID_NORMAL;
+        if (isZero())
+            mGuidState = GUID_ZERO;
+        dbg_refresh();
         return *this;
     }
-    Guid& operator=(const RTUUID &guid)
-    {
-        mGuidState = NORMAL_GUID;
-        ::memcpy(&mUuid, &guid, sizeof (RTUUID));
-        if (isEmpty())
-            mGuidState = ZERO_GUID;
-        refresh();
+
+    Guid& operator=(const char *str)
+    {
+        if (!str || !*str)
+        {
+            ::RTUuidClear(&mUuid);
+            mGuidState = GUID_ZERO;
+        }
+        else
+        {
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromStr(&mUuid, str);
+            if (RT_FAILURE(rc))
+            {
+                ::RTUuidClear(&mUuid);
+                mGuidState = GUID_INVALID;
+            }
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
         return *this;
     }
-    Guid& operator=(const char *str)
-    {
-        mGuidState = NORMAL_GUID;
-        int rc = ::RTUuidFromStr(&mUuid, str);
-
-        if (RT_FAILURE(rc))
+
+    Guid& operator=(CBSTR str)
+    {
+        if (!str || !*str)
         {
             ::RTUuidClear(&mUuid);
-            mGuidState = INVALID_GUID;
+            mGuidState = GUID_ZERO;
         }
         else
         {
-            if (isEmpty())
-            mGuidState = ZERO_GUID;
-        }
-
-        refresh();
-
+            mGuidState = GUID_NORMAL;
+            int rc = ::RTUuidFromUtf16(&mUuid, str);
+            if (RT_FAILURE(rc))
+            {
+                ::RTUuidClear(&mUuid);
+                mGuidState = GUID_INVALID;
+            }
+            else if (isZero())
+                mGuidState = GUID_ZERO;
+        }
+        dbg_refresh();
         return *this;
     }
 
+    Guid& operator=(const Utf8Str &str)
+    {
+        return operator=(str.c_str());
+    }
+
+    Guid& operator=(const RTCString &str)
+    {
+        return operator=(str.c_str());
+    }
+
+    Guid& operator=(const Bstr &str)
+    {
+        return operator=(str.raw());
+    }
+
     void create()
     {
         ::RTUuidCreate(&mUuid);
-        mGuidState = NORMAL_GUID;
-        refresh();
-    }
+        mGuidState = GUID_NORMAL;
+        dbg_refresh();
+    }
+
     void clear()
     {
         ::RTUuidClear(&mUuid);
-        mGuidState = ZERO_GUID;
-        refresh();
+        mGuidState = GUID_ZERO;
+        dbg_refresh();
     }
 
@@ -226,9 +305,5 @@
     Utf8Str toString() const
     {
-        char buf[RTUUID_STR_LENGTH];
-
-        ::memset(buf,0,RTUUID_STR_LENGTH);
-
-        if (mGuidState == INVALID_GUID)
+        if (mGuidState == GUID_INVALID)
         {
             /* What to return in case of wrong Guid */
@@ -236,6 +311,7 @@
         }
 
-        ::RTUuidToStr(&mUuid, buf, RTUUID_STR_LENGTH);
-
+        char buf[RTUUID_STR_LENGTH];
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToStr(&mUuid, buf, sizeof(buf));
 
         return Utf8Str(buf);
@@ -250,6 +326,5 @@
     Utf8Str toStringCurly() const
     {
-
-        if (mGuidState == INVALID_GUID)
+        if (mGuidState == GUID_INVALID)
         {
             /* What to return in case of wrong Guid */
@@ -257,9 +332,9 @@
         }
 
-        char buf[RTUUID_STR_LENGTH + 2] = "{";
-
-        ::RTUuidToStr(&mUuid, buf + 1, RTUUID_STR_LENGTH);
+        char buf[RTUUID_STR_LENGTH + 2];
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToStr(&mUuid, buf + 1, sizeof(buf) - 2);
+        buf[0] = '{';
         buf[sizeof(buf) - 2] = '}';
-        buf[sizeof(buf) - 1] = '\0';
 
         return Utf8Str(buf);
@@ -274,9 +349,14 @@
     Bstr toUtf16() const
     {
-        if (mGuidState == INVALID_GUID)
+        if (mGuidState == GUID_INVALID)
+        {
+            /* What to return in case of wrong Guid */
           return Bstr("00000000-0000-0000-0000-00000000000");
+        }
 
         RTUTF16 buf[RTUUID_STR_LENGTH];
-        ::RTUuidToUtf16(&mUuid, buf, RTUUID_STR_LENGTH);
+        ::memset(buf, '\0', sizeof(buf));
+        ::RTUuidToUtf16(&mUuid, buf, RT_ELEMENTS(buf));
+
         return Bstr(buf);
     }
@@ -284,22 +364,21 @@
     bool isValid() const
     {
-        bool res = true;
-        if (mGuidState == INVALID_GUID)
-            res = false;
-
-        return res;
+        return mGuidState != GUID_INVALID;
     }
 
     bool isZero() const
     {
-        return (::RTUuidIsNull(&mUuid) && mGuidState == ZERO_GUID);
+        return mGuidState == GUID_ZERO;
     }
 
     bool operator==(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    == 0; }
+    bool operator==(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) == 0; }
     bool operator==(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) == 0; }
     bool operator!=(const Guid &that) const { return !operator==(that); }
     bool operator!=(const GUID &guid) const { return !operator==(guid); }
-    bool operator<( const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    < 0; }
-    bool operator<( const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; }
+    bool operator!=(const RTUUID &guid) const { return !operator==(guid); }
+    bool operator<(const Guid &that) const { return ::RTUuidCompare(&mUuid, &that.mUuid)    < 0; }
+    bool operator<(const GUID &guid) const { return ::RTUuidCompare(&mUuid, (PRTUUID)&guid) < 0; }
+    bool operator<(const RTUUID &guid) const { return ::RTUuidCompare(&mUuid, &guid) < 0; }
 
     /**
@@ -319,93 +398,8 @@
     }
 
-#if !defined(VBOX_WITH_XPCOM)
-
-    /** To assign instances to OUT_GUID parameters from within the interface
-     * method. */
-    const Guid &cloneTo(GUID *pguid) const
-    {
-        if (pguid)
-            ::memcpy(pguid, &mUuid, sizeof(GUID));
-        return *this;
-    }
-
-    /** To pass instances as OUT_GUID parameters to interface methods. */
-    GUID *asOutParam()
-    {
-        return (GUID *)&mUuid;
-    }
-
-#else
-
-    /** To assign instances to OUT_GUID parameters from within the
-     * interface method */
-    const Guid &cloneTo(nsID **ppGuid) const
-    {
-        if (ppGuid)
-            *ppGuid = (nsID *)nsMemory::Clone(&mUuid, sizeof(nsID));
-
-        return *this;
-    }
-
-    /**
-     * Internal helper class for asOutParam().
-     *
-     * This takes a GUID refrence in the constructor and copies the mUuid from
-     * the method to that instance in its destructor.
-     */
-    class GuidOutParam
-    {
-        GuidOutParam(Guid &guid)
-            : ptr(0),
-              outer(guid)
-        {
-            outer.clear();
-        }
-
-        nsID *ptr;
-        Guid &outer;
-        GuidOutParam(const GuidOutParam &that); // disabled
-        GuidOutParam &operator=(const GuidOutParam &that); // disabled
-    public:
-        operator nsID**() { return &ptr; }
-        ~GuidOutParam()
-        {
-            if (ptr && outer.isEmpty())
-            {
-                outer = *ptr;
-                outer.refresh();
-                nsMemory::Free(ptr);
-            }
-        }
-        friend class Guid;
-    };
-
-    /** to pass instances as OUT_GUID parameters to interface methods */
-    GuidOutParam asOutParam() { return GuidOutParam(*this); }
-
-#endif
-
-    /* to directly test IN_GUID interface method's parameters */
-    static bool isEmpty(const GUID &guid)
-    {
-        return ::RTUuidIsNull((PRTUUID)&guid);
-    }
-
-    /**
-     *  Static immutable empty object. May be used for comparison purposes.
+    /**
+     *  Static immutable empty (zero) object. May be used for comparison purposes.
      */
     static const Guid Empty;
-
-protected:
-
-    bool isEmpty() const
-    {
-        return ::RTUuidIsNull(&mUuid);
-    }
-
-    bool isNotEmpty() const
-    {
-        return !::RTUuidIsNull(&mUuid);
-    }
 
 private:
@@ -417,9 +411,19 @@
      * in release code.
      */
-    inline void refresh()
+    inline void dbg_refresh()
     {
 #ifdef DEBUG
-//        ::RTUuidToStr(&mUuid, mszUuid, RTUUID_STR_LENGTH);
-//        m_pcszUUID = mszUuid;
+        switch (mGuidState)
+        {
+            case GUID_ZERO:
+            case GUID_NORMAL:
+                ::RTUuidToStr(&mUuid, mszUuid, RTUUID_STR_LENGTH);
+                break;
+            default:
+                ::memset(mszUuid, '\0', sizeof(mszUuid));
+                ::RTStrCopy(mszUuid, sizeof(mszUuid), "INVALID");
+                break;
+        }
+        m_pcszUUID = mszUuid;
 #endif
     }
@@ -437,17 +441,4 @@
 #endif
 };
-/*
-inline Bstr asGuidStr(const Bstr& str)
-{
-   Guid guid(str);
-   return guid.isEmpty() ? Bstr() : guid.toUtf16();
-}
-*/
-//inline bool isValidGuid(const Bstr& str)
-//{
-//   Guid guid(str);
-//   return guid.isValid();
-////   return !guid.isEmpty();
-//}
 
 } /* namespace com */
Index: /trunk/src/VBox/Main/include/ProgressImpl.h
===================================================================
--- /trunk/src/VBox/Main/include/ProgressImpl.h	(revision 51686)
+++ /trunk/src/VBox/Main/include/ProgressImpl.h	(revision 51687)
@@ -6,5 +6,5 @@
 
 /*
- * Copyright (C) 2006-2013 Oracle Corporation
+ * Copyright (C) 2006-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -91,5 +91,4 @@
      * @param aDescription
      * @param aCancelable
-     * @param aId
      * @return
      */
@@ -100,6 +99,5 @@
                   IUnknown *aInitiator,
                   Utf8Str aDescription,
-                  BOOL aCancelable,
-                  OUT_GUID aId = NULL)
+                  BOOL aCancelable)
     {
         return init(
@@ -113,6 +111,5 @@
             1,      // ulTotalOperationsWeight
             aDescription, // aFirstOperationDescription
-            1,      // ulFirstOperationWeight
-            aId);
+            1);     // ulFirstOperationWeight
     }
 
@@ -126,5 +123,4 @@
      * @param cOperations
      * @param bstrFirstOperationDescription
-     * @param aId
      * @return
      */
@@ -136,6 +132,5 @@
                   Utf8Str aDescription, BOOL aCancelable,
                   ULONG cOperations,
-                  Utf8Str aFirstOperationDescription,
-                  OUT_GUID aId = NULL)
+                  Utf8Str aFirstOperationDescription)
     {
         return init(
@@ -149,6 +144,5 @@
             cOperations,      // ulTotalOperationsWeight = cOperations
             aFirstOperationDescription, // aFirstOperationDescription
-            1,      // ulFirstOperationWeight: weigh them all the same
-            aId);
+            1);     // ulFirstOperationWeight: weigh them all the same
     }
 
@@ -163,6 +157,5 @@
                   ULONG ulTotalOperationsWeight,
                   Utf8Str aFirstOperationDescription,
-                  ULONG ulFirstOperationWeight,
-                  OUT_GUID aId = NULL);
+                  ULONG ulFirstOperationWeight);
 
     HRESULT init(BOOL aCancelable,
@@ -170,15 +163,5 @@
                  Utf8Str aOperationDescription);
 
-//   initializer/uninitializer for internal purposes only
-    HRESULT init(AutoInitSpan &aAutoInitSpan,
-#if !defined (VBOX_COM_INPROC)
-               VirtualBox *aParent,
-#endif
-               IUnknown *aInitiator,
-               Utf8Str aDescription, OUT_GUID aId = NULL);
-    HRESULT init(AutoInitSpan &aAutoInitSpan);
-    void init(AutoUninitSpan &aAutoUninitSpan);
     void uninit();
-    void uninit(AutoUninitSpan &aAutoUninitSpan);
 
 
Index: /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp
===================================================================
--- /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp	(revision 51686)
+++ /trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp	(revision 51687)
@@ -610,6 +610,5 @@
                                               static_cast<IExtPackFile *>(this),
                                               bstrDescription.raw(),
-                                              FALSE /*aCancelable*/,
-                                              NULL /*aId*/);
+                                              FALSE /*aCancelable*/);
             }
             if (SUCCEEDED(hrc))
@@ -1989,6 +1988,5 @@
                                           static_cast<IExtPackManager *>(this),
                                           bstrDescription.raw(),
-                                          FALSE /*aCancelable*/,
-                                          NULL /*aId*/);
+                                          FALSE /*aCancelable*/);
         }
         if (SUCCEEDED(hrc))
Index: /trunk/src/VBox/Main/src-all/ProgressImpl.cpp
===================================================================
--- /trunk/src/VBox/Main/src-all/ProgressImpl.cpp	(revision 51686)
+++ /trunk/src/VBox/Main/src-all/ProgressImpl.cpp	(revision 51687)
@@ -6,5 +6,5 @@
 
 /*
- * Copyright (C) 2006-2013 Oracle Corporation
+ * Copyright (C) 2006-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -419,14 +419,15 @@
  * ulTotalOperationsWeight = ulFirstOperationWeight = 1.
  *
- * @param aParent           See Progress::init().
- * @param aInitiator        See Progress::init().
- * @param aDescription      See Progress::init().
- * @param aCancelable       Flag whether the task maybe canceled.
- * @param cOperations       Number of operations within this task (at least 1).
+ * @param aParent       Parent object (only for server-side Progress objects).
+ * @param aInitiator    Initiator of the task (for server-side objects. Can be
+ *                      NULL which means initiator = parent, otherwise must not
+ *                      be NULL).
+ * @param aDescription  Overall task description.
+ * @param aCancelable   Flag whether the task maybe canceled.
+ * @param cOperations   Number of operations within this task (at least 1).
  * @param ulTotalOperationsWeight Total weight of operations; must be the sum of ulFirstOperationWeight and
  *                          what is later passed with each subsequent setNextOperation() call.
  * @param bstrFirstOperationDescription Description of the first operation.
  * @param ulFirstOperationWeight Weight of first sub-operation.
- * @param aId               See Progress::init().
  */
 HRESULT Progress::init(
@@ -440,6 +441,5 @@
                        ULONG ulTotalOperationsWeight,
                        Utf8Str aFirstOperationDescription,
-                       ULONG ulFirstOperationWeight,
-                       OUT_GUID aId /* = NULL */)
+                       ULONG ulFirstOperationWeight)
 {
     LogFlowThisFunc(("aDescription=\"%s\", cOperations=%d, ulTotalOperationsWeight=%d, aFirstOperationDescription=\"%s\", ulFirstOperationWeight=%d\n",
@@ -477,6 +477,6 @@
 #if !defined(VBOX_COM_INPROC)
     /* assign (and therefore addref) initiator only if it is not VirtualBox
- *      * (to avoid cycling); otherwise mInitiator will remain null which means
- *           * that it is the same as the parent */
+     * (to avoid cycling); otherwise mInitiator will remain null which means
+     * that it is the same as the parent */
     if (aInitiator)
     {
@@ -490,10 +490,8 @@
 
     unconst(mId).create();
-    if (aId)
-        mId.cloneTo(aId);
 
 #if !defined(VBOX_COM_INPROC)
     /* add to the global collection of progress operations (note: after
- *      * creating mId) */
+     * creating mId) */
     mParent->i_addProgress(this);
 #endif
Index: /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp
===================================================================
--- /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp	(revision 51686)
+++ /trunk/src/VBox/Main/src-client/ConsoleImpl.cpp	(revision 51687)
@@ -6924,6 +6924,5 @@
                                         ulTotalOperationsWeight,
                                         Bstr(tr("Starting Hard Disk operations")).raw(),
-                                        1,
-                                        NULL);
+                                        1);
             AssertComRCReturnRC(rc);
         }
@@ -6943,6 +6942,5 @@
                                         10   /* ulTotalOperationsWeight */,
                                         Bstr(tr("Teleporting virtual machine")).raw(),
-                                        1    /* ulFirstOperationWeight */,
-                                        NULL);
+                                        1    /* ulFirstOperationWeight */);
         }
         else if (fFaultToleranceSyncEnabled)
@@ -6954,6 +6952,5 @@
                                         10   /* ulTotalOperationsWeight */,
                                         Bstr(tr("Fault Tolerance syncing of remote virtual machine")).raw(),
-                                        1    /* ulFirstOperationWeight */,
-                                        NULL);
+                                        1    /* ulFirstOperationWeight */);
         }
 
Index: /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp
===================================================================
--- /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp	(revision 51686)
+++ /trunk/src/VBox/Main/src-server/ProgressProxyImpl.cpp	(revision 51687)
@@ -5,5 +5,5 @@
 
 /*
- * Copyright (C) 2010-2011 Oracle Corporation
+ * Copyright (C) 2010-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -83,6 +83,5 @@
                           1 /* ulTotalOperationsWeight */,
                           bstrDescription /* bstrFirstOperationDescription */,
-                          1 /* ulFirstOperationWeight */,
-                          NULL /* pId */);
+                          1 /* ulFirstOperationWeight */);
 }
 
@@ -124,6 +123,5 @@
                           uTotalOperationsWeight,
                           bstrFirstOperationDescription,
-                          uFirstOperationWeight,
-                          NULL);
+                          uFirstOperationWeight);
 }
 
