Changeset 30714 – Oracle VirtualBox

trunk/include/VBox/com/SupportErrorInfo.h

-              r28800
+              r30714
+    }
+    /**
+     * Returns true if multi-mode is enabled for the current thread (i.e. at
+     * least one MultiResult instance exists on the stack somewhere).
+     * @return
+     */
+    static bool isMultiEnabled();
 private:
 …
     static RTTLS sCounter;
-    friend class SupportErrorInfoBase;
     friend class MultiResultRef;
 };
 …
 };
-/**
- * The SupportErrorInfoBase template class provides basic error info support.
+ *
- * Basic error info support includes a group of setError() methods to set
- * extended error information on the current thread. This support does not
- * include all necessary implementation details (for example, implementation of
- * the ISupportErrorInfo interface on MS COM) to make the error info support
- * fully functional in a target component. These details are provided by the
- * SupportErrorInfoDerived class.
+ *
- * This way, this class is intended to be directly inherited only by
- * intermediate component base classes that will be then inherited by final
- * component classes through the SupportErrorInfoDerived template class. In
- * all other cases, the SupportErrorInfoImpl class should be used as a base for
- * final component classes instead.
- */
-class SupportErrorInfoBase
+{
-    static HRESULT setErrorInternal(HRESULT aResultCode,
-                                    const GUID *aIID,
-                                    const char *aComponent,
-                                    const Utf8Str &strText,
-                                    bool aWarning,
-                                    IVirtualBoxErrorInfo *aInfo = NULL);
-protected:
-    /**
-     * Returns an interface ID that is to be used in short setError() variants
-     * to specify the interface that has defined the error. Must be implemented
-     * in subclasses.
-     */
-    virtual const GUID &mainInterfaceID() const = 0;
-    /**
-     * Returns an component name (in UTF8) that is to be used in short
-     * setError() variants to specify the interface that has defined the error.
-     * Must be implemented in subclasses.
-     */
-    virtual const char *componentName() const = 0;
-    /**
-     * Same as #setError (HRESULT, const GUID &, const char *, const char *) but
-     * interprets the @a aText argument as a RTPrintf-like format string and the
-     * @a aArgs argument as an argument list for this format string.
-     */
-    static HRESULT setErrorV(HRESULT aResultCode, const GUID &aIID,
-                             const char *aComponent, const char *aText,
-                             va_list aArgs)
+    {
-        return setErrorInternal(aResultCode, &aIID, aComponent,
-                                Utf8StrFmtVA(aText, aArgs),
-                                false /* aWarning */);
+    }
-    /**
-     * Same as #setWarning (HRESULT, const GUID &, const char *, const char *)
-     * but interprets the @a aText argument as a RTPrintf-like format string and
-     * the @a aArgs argument as an argument list for this format string.
-     */
-    static HRESULT setWarningV(HRESULT aResultCode, const GUID &aIID,
-                               const char *aComponent, const char *aText,
-                               va_list aArgs)
+    {
-        return setErrorInternal(aResultCode, &aIID,
-                                aComponent,
-                                Utf8StrFmtVA(aText, aArgs),
-                                true /* aWarning */);
+    }
-    /**
-     * Same as #setError (HRESULT, const GUID &, const char *, const char *) but
-     * interprets the @a aText argument as a RTPrintf-like format string and
-     * takes a variable list of arguments for this format string.
-     */
-    static HRESULT setError(HRESULT aResultCode,
-                            const GUID &aIID,
-                            const char *aComponent,
-                            const char *aText,
-                            ...);
-    /**
-     * Same as #setWarning (HRESULT, const GUID &, const char *, const char *)
-     * but interprets the @a aText argument as a RTPrintf-like format string and
-     * takes a variable list of arguments for this format string.
-     */
-    static HRESULT setWarning(HRESULT aResultCode, const GUID &aIID,
-                              const char *aComponent, const char *aText,
-                              ...);
-    /**
-     * Sets the given error info object on the current thread.
+     *
-     * Note that In multi-error mode (see MultiResult), the existing error info
-     * object (if any) will be preserved by attaching it to the tail of the
-     * error chain of the given aInfo object.
+     *
-     * @param aInfo     Error info object to set (must not be NULL).
-     */
-    static HRESULT setErrorInfo(IVirtualBoxErrorInfo *aInfo)
+    {
-        AssertReturn (aInfo != NULL, E_FAIL);
-        return setErrorInternal(0, NULL, NULL, Utf8Str::Null, false, aInfo);
+    }
-    /**
-     * Same as #setError (HRESULT, const GUID &, const char *, const char *,
-     * ...) but uses the return value of the mainInterfaceID() method as an @a
-     * aIID argument and the return value of the componentName() method as a @a
-     * aComponent argument.
+     *
-     * This method is the most common (and convenient) way to set error
-     * information from within a component method. The typical usage pattern is:
-     * <code>
-     *     return setError (E_FAIL, "Terrible Error");
-     * </code>
-     * or
-     * <code>
-     *     HRESULT rc = setError (E_FAIL, "Terrible Error");
-     *     ...
-     *     return rc;
-     * </code>
-     */
-    HRESULT setError(HRESULT aResultCode, const char *aText, ...);
-    HRESULT setError(HRESULT aResultCode, const Utf8Str &strText);
-    /**
-     * Same as #setWarning (HRESULT, const GUID &, const char *, const char *,
-     * ...) but uses the return value of the mainInterfaceID() method as an @a
-     * aIID argument and the return value of the componentName() method as a @a
-     * aComponent argument.
+     *
-     * This method is the most common (and convenient) way to set warning
-     * information from within a component method. The typical usage pattern is:
-     * <code>
-     *     return setWarning (E_FAIL, "Dangerous warning");
-     * </code>
-     * or
-     * <code>
-     *     HRESULT rc = setWarning (E_FAIL, "Dangerous warning");
-     *     ...
-     *     return rc;
-     * </code>
-     */
-    HRESULT setWarning (HRESULT aResultCode, const char *aText, ...);
-    /**
-     * Same as #setError (HRESULT, const char *, ...) but takes a va_list
-     * argument instead of a variable argument list.
-     */
-    HRESULT setErrorV (HRESULT aResultCode, const char *aText, va_list aArgs)
+    {
-        return setError (aResultCode, mainInterfaceID(), componentName(),
-                         aText, aArgs);
+    }
-    /**
-     * Same as #setWarning (HRESULT, const char *, ...) but takes a va_list
-     * argument instead of a variable argument list.
-     */
-    HRESULT setWarningV (HRESULT aResultCode, const char *aText, va_list aArgs)
+    {
-        return setWarning (aResultCode, mainInterfaceID(), componentName(),
-                           aText, aArgs);
+    }
-    /**
-     * Same as #setError (HRESULT, const char *, ...) but allows to specify the
-     * interface ID manually.
-     */
-    HRESULT setError (HRESULT aResultCode, const GUID &aIID,
-                      const char *aText, ...);
-    /**
-     * Same as #setWarning (HRESULT, const char *, ...) but allows to specify
-     * the interface ID manually.
-     */
-    HRESULT setWarning (HRESULT aResultCode, const GUID &aIID,
-                        const char *aText, ...);
-};
-////////////////////////////////////////////////////////////////////////////////
-/**
- * The SupportErrorInfoDerived template class implements the remaining parts
- * of error info support in addition to SupportErrorInfoBase.
+ *
- * These parts include the ISupportErrorInfo implementation on the MS COM
- * platform and implementations of mandatory SupportErrorInfoBase virtual
- * methods.
+ *
- * On MS COM, the @a C template argument must declare a COM interface map using
- * BEGIN_COM_MAP / END_COM_MAP macros and this map must contain a
- * COM_INTERFACE_ENTRY(ISupportErrorInfo) definition. All interface entries that
- * follow it will be considered to support IErrorInfo, i.e. the
- * InterfaceSupportsErrorInfo() implementation will return S_OK for the
- * corresponding IIDs.
+ *
- * On all platforms, the @a C template argument must be a subclass of
- * SupportErrorInfoBase and also define the following method: <tt>public static
- * const char *ComponentName()</tt> that will be used as a value returned by the
- * SupportErrorInfoBase::componentName() implementation.
+ *
- * If SupportErrorInfoBase is used as a base for an intermediate component base
- * class FooBase then the final component FooFinal that inherits FooBase should
- * use this template class as follows:
- * <code>
- *     class FooFinal : public SupportErrorInfoDerived <FooBase, FooFinal, IFoo>
- *     {
- *         ...
- *     };
- * </code>
+ *
- * Note that if you don not use intermediate component base classes, you should
- * use the SupportErrorInfoImpl class as a base for your component instead.
+ *
- * @param B     Intermediate component base derived from SupportErrorInfoBase.
- * @param C     Component class that implements one or more COM interfaces.
- * @param I     Default interface for the component (for short #setError()
- *              versions).
- */
-template <class B, class C, class I>
-class ATL_NO_VTABLE SupportErrorInfoDerived : public B
-#if !defined (VBOX_WITH_XPCOM)
-    , public ISupportErrorInfo
-#endif
+{
-public:
-#if !defined (VBOX_WITH_XPCOM)
-    STDMETHOD(InterfaceSupportsErrorInfo) (REFIID aIID)
+    {
-        const _ATL_INTMAP_ENTRY* pEntries = C::_GetEntries();
-        Assert (pEntries);
-        if (!pEntries)
-            return S_FALSE;
-        BOOL bSupports = FALSE;
-        BOOL bISupportErrorInfoFound = FALSE;
-        while (pEntries->pFunc != NULL && !bSupports)
+        {
-            if (!bISupportErrorInfoFound)
+            {
-                /* skip the COM map entries until ISupportErrorInfo is found */
-                bISupportErrorInfoFound =
-                    InlineIsEqualGUID (*(pEntries->piid), IID_ISupportErrorInfo);
+            }
-            else
+            {
-                /* look for the requested interface in the rest of the com map */
-                bSupports = InlineIsEqualGUID (*(pEntries->piid), aIID);
+            }
-            pEntries++;
+        }
-        Assert (bISupportErrorInfoFound);
-        return bSupports ? S_OK : S_FALSE;
+    }
-#endif /* !defined (VBOX_WITH_XPCOM) */
-protected:
-    virtual const GUID &mainInterfaceID() const { return COM_IIDOF (I); }
-    virtual const char *componentName() const { return C::ComponentName(); }
-};
-////////////////////////////////////////////////////////////////////////////////
-/**
- * The SupportErrorInfoImpl template class provides complete error info support
- * for COM component classes.
+ *
- * Complete error info support includes what both SupportErrorInfoBase and
- * SupportErrorInfoDerived provide, e.g. a variety of setError() methods to
- * set extended error information from within a component's method
- * implementation and all necessary additional interface implementations (see
- * descriptions of these classes for details).
+ *
- * To add error info support to a Foo component that implements a IFoo
- * interface, use the following pattern:
- * <code>
- *     class Foo : public SupportErrorInfoImpl <Foo, IFoo>
- *     {
- *     public:
+ *
- *         ...
+ *
- *         static const char *ComponentName() const { return "Foo"; }
- *     };
- * </code>
+ *
- * Note that your component class (the @a C template argument) must provide the
- * ComponentName() implementation as shown above.
+ *
- * @param C Component class that implements one or more COM interfaces.
- * @param I Default interface for the component (for short #setError()
- *          versions).
- */
-template <class C, class I>
-class ATL_NO_VTABLE SupportErrorInfoImpl
-    : public SupportErrorInfoDerived <SupportErrorInfoBase, C, I>
+{
-};
 } /* namespace com */

trunk/include/VBox/com/VirtualBoxErrorInfo.h

-              r28800
+              r30714
     // IVirtualBoxErrorInfo properties
     COM_FORWARD_IVirtualBoxErrorInfo_GETTER_ResultCode_TO_OBJ (mReal)
     COM_FORWARD_IVirtualBoxErrorInfo_GETTER_InterfaceID_TO_OBJ (mReal)
     COM_FORWARD_IVirtualBoxErrorInfo_GETTER_Component_TO_OBJ (mReal)
     COM_FORWARD_IVirtualBoxErrorInfo_GETTER_Text_TO_OBJ (mReal)
+    COM_FORWARD_IVirtualBoxErrorInfo_GETTER_ResultCode_TO_OBJ(mReal)
+    COM_FORWARD_IVirtualBoxErrorInfo_GETTER_InterfaceID_TO_OBJ(mReal)
+    COM_FORWARD_IVirtualBoxErrorInfo_GETTER_Component_TO_OBJ(mReal)
+    COM_FORWARD_IVirtualBoxErrorInfo_GETTER_Text_TO_OBJ(mReal)
     STDMETHOD(COMGETTER(Next)) (IVirtualBoxErrorInfo **aNext);

trunk/include/VBox/com/defs.h

-              r30681
+              r30714
  *  @param i    interface class
  */
 #define COM_IIDOF(I) _ATL_IIDOF (I)
+#define COM_IIDOF(I) _ATL_IIDOF(I)
 #else /* defined (RT_OS_WINDOWS) */
 …
 #define STDMETHODIMP NS_IMETHODIMP
 #define COM_IIDOF(I) NS_GET_IID (I)
+#define COM_IIDOF(I) NS_GET_IID(I)
 /* A few very simple ATL emulator classes to provide

trunk/src/VBox/Frontends/VBoxBFE/VirtualBoxBase.h

r28800	r30714
277	277	cls::cls () {}; cls::~cls () {};
278	278
279		#define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls)
	279	#define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls, iface)
280	280
281	281	////////////////////////////////////////////////////////////////////////////////

trunk/src/VBox/Main/ApplianceImpl.cpp

-              r30681
+              r30714
  * @return
  */
 bool Appliance::isApplianceIdle() const
+bool Appliance::isApplianceIdle()
+{
     if (m->state == Data::ApplianceImporting)
         setError(VBOX_E_INVALID_OBJECT_STATE, "The appliance is busy importing files");
+        setError(VBOX_E_INVALID_OBJECT_STATE, tr("The appliance is busy importing files"));
     else if (m->state == Data::ApplianceExporting)
         setError(VBOX_E_INVALID_OBJECT_STATE, "The appliance is busy exporting files");
+        setError(VBOX_E_INVALID_OBJECT_STATE, tr("The appliance is busy exporting files"));
     else
         return true;
 …
+}
 void Appliance::parseBucket(Utf8Str &aPath, Utf8Str &aBucket) const
+void Appliance::parseBucket(Utf8Str &aPath, Utf8Str &aBucket)
+{
     /* Buckets are S3 specific. So parse the bucket out of the file path */

trunk/src/VBox/Main/ConsoleImpl.cpp

-              r30629
+              r30714
     if (RT_FAILURE(vrc))
         rc = setError(VBOX_E_FILE_ERROR,
             tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
             savedStateFile.raw(), vrc);
+                      tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
+                      savedStateFile.raw(), vrc);
     mSavedStateDataLoaded = true;
 …
     if (VERR_BUFFER_OVERFLOW == vrc)
         return setError(E_UNEXPECTED,
             tr("Temporary failure due to guest activity, please retry"));
+                        tr("Temporary failure due to guest activity, please retry"));
     /*
 …
         /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
     HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
         setError(VBOX_E_VM_ERROR,
             tr("Could not reset the machine (%Rrc)"),
             vrc);
+                 tr("Could not reset the machine (%Rrc)"),
+                 vrc);
     LogFlowThisFunc(("mMachineState=%d, rc=%08X\n", mMachineState, rc));
 …
         && mMachineState != MachineState_LiveSnapshotting
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
         /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
     rc = RT_SUCCESS(vrc) ? S_OK :
         setError(VBOX_E_VM_ERROR,
             tr("Could not add CPU to the machine (%Rrc)"),
             vrc);
+                 tr("Could not add CPU to the machine (%Rrc)"),
+                 vrc);
     if (RT_SUCCESS(vrc))
 …
         default:
+            return setError(VBOX_E_INVALID_VM_STATE,
+                            tr("Invalid machine state: %s"),
+                            Global::stringifyMachineState(mMachineState));
+            return setInvalidMachineStateError();
+    }
 …
     if (mMachineState != MachineState_Paused)
         return setError(VBOX_E_INVALID_VM_STATE,
             tr("Cannot resume the machine as it is not paused (machine state: %s)"),
             Global::stringifyMachineState(mMachineState));
+                        tr("Cannot resume the machine as it is not paused (machine state: %s)"),
+                        Global::stringifyMachineState(mMachineState));
     /* protect mpVM */
 …
     HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
         setError(VBOX_E_VM_ERROR,
             tr("Could not resume the machine execution (%Rrc)"),
             vrc);
+                 tr("Could not resume the machine execution (%Rrc)"),
+                 vrc);
     LogFlowThisFunc(("rc=%08X\n", rc));
 …
         && mMachineState != MachineState_LiveSnapshotting
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
     HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
         setError(VBOX_E_PDM_ERROR,
             tr("Controlled power off failed (%Rrc)"),
             vrc);
+                 tr("Controlled power off failed (%Rrc)"),
+                 vrc);
     LogFlowThisFunc(("rc=%08X\n", rc));
 …
         && mMachineState != MachineState_LiveSnapshotting
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
     if (mMachineState != MachineState_Running) /** @todo Live Migration: ??? */
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s)"),
+            Global::stringifyMachineState(mMachineState));
+        return setInvalidMachineStateError();
     /* protect mpVM */
 …
 /////////////////////////////////////////////////////////////////////////////
+/*static*/
+HRESULT Console::setErrorStatic(HRESULT aResultCode, const char *pcsz, ...)
+{
+    va_list args;
+    va_start(args, pcsz);
+    HRESULT rc = setErrorInternal(aResultCode,
+                                  getStaticClassIID(),
+                                  getStaticComponentName(),
+                                  Utf8StrFmtVA(pcsz, args),
+                                  false /* aWarning */,
+                                  true /* aLogIt */);
+    va_end(args);
+    return rc;
+}
+HRESULT Console::setAuthLibraryError(const char *filename, int rc)
+{
+    return setError(E_FAIL, tr("Could not load the external authentication library '%s' (%Rrc)"), filename, rc);
+}
+HRESULT Console::setInvalidMachineStateError()
+{
+    return setError(VBOX_E_INVALID_VM_STATE,
+                    tr("Invalid machine state: %s"),
+                    Global::stringifyMachineState(mMachineState));
+}
 /**
  * @copydoc VirtualBox::handleUnexpectedExceptions
 …
     catch (const std::exception &err)
+    {
+        return setError(E_FAIL, tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
+                                err.what(), typeid(err).name(),
+                                pszFile, iLine, pszFunction);
+        return setErrorStatic(E_FAIL,
+                              tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
+                              err.what(), typeid(err).name(),
+                              pszFile, iLine, pszFunction);
+    }
     catch (...)
+    {
+        return setError(E_FAIL, tr("Unknown exception\n%s[%d] (%s)"),
+                                pszFile, iLine, pszFunction);
+        return setErrorStatic(E_FAIL,
+                              tr("Unknown exception\n%s[%d] (%s)"),
+                              pszFile, iLine, pszFunction);
+    }
 …
         case VMSTATE_RUNNING_LS:
+            return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot change drive during live migration"));
+            return setErrorInternal(VBOX_E_INVALID_VM_STATE,
+                                    COM_IIDOF(IConsole),
+                                    getStaticComponentName(),
+                                    Utf8Str(tr("Cannot change drive during live migration")),
+                                    false /*aWarning*/,
+                                    true /*aLogIt*/);
         default:
 …
         default:
+            return setError(VBOX_E_INVALID_VM_STATE,
+                            tr("Invalid machine state: %s"),
+                            Global::stringifyMachineState(mMachineState));
+            return setInvalidMachineStateError();
+    }
 …
             LogRel(("Failed to launch VRDP server (%Rrc), error message: '%s'\n",
                      vrc, errMsg.raw()));
             throw setError(E_FAIL, errMsg.c_str());
+            throw setErrorStatic(E_FAIL, errMsg.c_str());
+        }
 …
             /* Set the error message as the COM error.
              * Progress::notifyComplete() will pick it up later. */
             throw setError(E_FAIL, task->mErrorMsg.c_str());
+            throw setErrorStatic(E_FAIL, task->mErrorMsg.c_str());
+        }
+    }
 …
             alock.enter();
             if (RT_FAILURE(vrc))
                 throw setError(E_FAIL,
                                tr("Failed to save the machine state to '%s' (%Rrc)"),
                                strSavedStateFile.c_str(), vrc);
+                throw setErrorStatic(E_FAIL,
+                                     tr("Failed to save the machine state to '%s' (%Rrc)"),
+                                     strSavedStateFile.c_str(), vrc);
             pTask->mProgress->setCancelCallback(NULL, NULL);
             if (!pTask->mProgress->notifyPointOfNoReturn())
                 throw setError(E_FAIL, tr("Cancelled"));
+                throw setErrorStatic(E_FAIL, tr("Cancelled"));
             that->mptrCancelableProgress.setNull();
 …
                                       &rc);
                 if (RT_FAILURE(vrc))
                     throw setError(E_FAIL, Console::tr("%Rrc"), vrc);
+                    throw setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
                 if (FAILED(rc))
                     throw rc;
 …
                 if (RT_FAILURE(vrc))
+                {
                     rc = setError(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
+                    rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
                     pTask->mProgress->notifyComplete(rc);
                     if (that->mMachineState == MachineState_Saving)
 …
             task->mProgress->notifyComplete(rc,
                                             COM_IIDOF(IConsole),
                                             (CBSTR)Console::getComponentName(),
+                                            Console::getStaticComponentName(),
                                             errMsg.c_str());
         else

trunk/src/VBox/Main/ConsoleVRDPServer.cpp

r30681	r30714
1513	1513	if (RT_FAILURE(rc))
1514	1514	{
1515		mConsole->~~repor~~tAuthLibraryError(filename.raw(), rc);
	1515	mConsole->setAuthLibraryError(filename.raw(), rc);
1516	1516
1517	1517	mpfnAuthEntry = NULL;

trunk/src/VBox/Main/EventImpl.cpp

-              r30706
+              r30714
+{
     Data()
+        :
+        mType(VBoxEventType_Invalid),
+        mWaitEvent(NIL_RTSEMEVENT),
+        mWaitable(FALSE),
+        mProcessed(FALSE)
+        : mType(VBoxEventType_Invalid),
+          mWaitEvent(NIL_RTSEMEVENT),
+          mWaitable(FALSE),
+          mProcessed(FALSE)
     {}
     VBoxEventType_T         mType;
     RTSEMEVENT              mWaitEvent;
 …
+}
 HRESULT VBoxEvent::init(IEventSource *aSource, VBoxEventType_T aType, BOOL aWaitable)
+{
 …
         if (aWaitable)
+        {
             int vrc = ::RTSemEventCreate (&m->mWaitEvent);
+            int vrc = ::RTSemEventCreate(&m->mWaitEvent);
             if (RT_FAILURE(vrc))
 …
 class ATL_NO_VTABLE PassiveEventListener :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<PassiveEventListener, IEventListener>,
     public VirtualBoxSupportTranslation<PassiveEventListener>,
     VBOX_SCRIPTABLE_IMPL(IEventListener)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PassiveEventListener)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PassiveEventListener, IEventListener)
     DECLARE_NOT_AGGREGATABLE(PassiveEventListener)
 …
                         E_FAIL);
+    }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"PassiveEventListener"; }
 };

trunk/src/VBox/Main/GuestImpl.cpp

-              r30662
+              r30714
                 || fCancelled) /* If cancelled we have to report E_FAIL! */
+            {
+                HRESULT hr2 = it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR, COM_IIDOF(IGuest),
+                                                                  (CBSTR)Guest::getComponentName(), errMsg.c_str());
+                HRESULT hr2 = it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
+                                                                   COM_IIDOF(IGuest),
+                                                                   Guest::getStaticComponentName(),
+                                                                   "%s", errMsg.c_str());
                 AssertComRC(hr2);
                 LogFlowFunc(("Process (context ID=%u, status=%u) reported error: %s\n",
 …
         if (SUCCEEDED(it->second.pProgress->COMGETTER(Canceled)(&fCancelled)) && fCancelled)
+        {
+            it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR, COM_IIDOF(IGuest),
+                                                 (CBSTR)Guest::getComponentName(), Guest::tr("The output operation was cancelled"));
+            it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
+                                                 COM_IIDOF(IGuest),
+                                                 Guest::getStaticComponentName(),
+                                                 Guest::tr("The output operation was cancelled"));
+        }
         else
 …
              * progress object to become signalled.
              */
+            it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR, COM_IIDOF(IGuest),
+                                                 (CBSTR)Guest::getComponentName(), Guest::tr("The operation was cancelled because client is shutting down"));
+            it->second.pProgress->notifyComplete(VBOX_E_IPRT_ERROR,
+                                                 COM_IIDOF(IGuest),
+                                                 Guest::getStaticComponentName(),
+                                                 Guest::tr("The operation was cancelled because client is shutting down"));
+        }
         /*

trunk/src/VBox/Main/HostImpl.cpp

-              r30377
+              r30714
     m->pUSBProxyService = new USBProxyServiceLinux(this);
 # elif defined (RT_OS_OS2)
     m->pUSBProxyService = new USBProxyServiceOs2 (this);
+    m->pUSBProxyService = new USBProxyServiceOs2(this);
 # elif defined (RT_OS_SOLARIS)
     m->pUSBProxyService = new USBProxyServiceSolaris(this);
 …
+    }
     return setErrorNoLog (VBOX_E_OBJECT_NOT_FOUND, tr (
         "Could not find a USB device with address '%ls'"),
         aAddress);
+    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
+                         tr("Could not find a USB device with address '%ls'"),
+                         aAddress);
 #else   /* !VBOX_WITH_USB */
 …
         if (m->pUSBProxyService->getLastError() == VERR_FILE_NOT_FOUND)
+            return setWarning (E_FAIL,
+                tr ("Could not load the Host USB Proxy Service (%Rrc). "
+                    "The service might not be installed on the host computer"),
+                m->pUSBProxyService->getLastError());
+            return setWarning(E_FAIL,
+                              tr("Could not load the Host USB Proxy Service (%Rrc). The service might not be installed on the host computer"),
+                              m->pUSBProxyService->getLastError());
         if (m->pUSBProxyService->getLastError() == VINF_SUCCESS)
 #ifdef RT_OS_LINUX

trunk/src/VBox/Main/MachineImpl.cpp

-              r30632
+              r30714
 HRESULT Machine::registeredInit()
+{
+    AssertReturn(getClassID() == clsidMachine, E_FAIL);
+    AssertReturn(!isSessionMachine(), E_FAIL);
+    AssertReturn(!isSnapshotMachine(), E_FAIL);
     AssertReturn(!mData->mUuid.isEmpty(), E_FAIL);
     AssertReturn(!mData->mAccessible, E_FAIL);
 …
         return;
+    Assert(getClassID() == clsidMachine);
+    Assert(!isSnapshotMachine());
+    Assert(!isSessionMachine());
     Assert(!!mData);
 …
         errorInfo->init(mData->mAccessError.getResultCode(),
                         mData->mAccessError.getInterfaceID(),
                         mData->mAccessError.getComponent(),
                         mData->mAccessError.getText());
+                        Utf8Str(mData->mAccessError.getComponent()).c_str(),
+                        Utf8Str(mData->mAccessError.getText()));
         rc = errorInfo.queryInterfaceTo(aAccessError);
+    }
 …
     if (    aEnabled
         &&  mData->mRegistered
         &&  (   getClassID() != clsidSessionMachine
+        &&  (   !isSessionMachine()
              || (   mData->mMachineState != MachineState_PoweredOff
                  && mData->mMachineState != MachineState_Teleported
 …
     if (    aEnabled
         &&  mData->mRegistered
         &&  (   getClassID() != clsidSessionMachine
+        &&  (   !isSessionMachine()
              || (   mData->mMachineState != MachineState_PoweredOff
                  && mData->mMachineState != MachineState_Teleported
 …
         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
         if (getClassID() == clsidSnapshotMachine)
+        if (isSnapshotMachine())
+        {
             HRESULT rc = checkStateDependency(MutableStateDep);
 …
+        {
             if (   mData->mRegistered
                 && (   getClassID() != clsidSessionMachine  /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
+                && (   !isSessionMachine()  /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
                     || (   mData->mMachineState != MachineState_Paused
                         && mData->mMachineState != MachineState_Running
 …
+        {
             if (   mData->mRegistered
                 && (   getClassID() != clsidSessionMachine  /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
+                && (   !isSessionMachine() /** @todo This was just convered raw; Check if Running and Paused should actually be included here... (Live Migration) */
                     || (   mData->mMachineState != MachineState_Paused
                         && mData->mMachineState != MachineState_Running
 …
      * disk attachments will already be uninitialized and deleted, so this
      * code will not affect them. */
-    VBoxClsID clsid = getClassID();
     if (    !!mMediaData
          && (clsid == clsidMachine || clsid == clsidSnapshotMachine)
+         && (!isSessionMachine())
+       )
+    {
 …
+    }
     if (getClassID() == clsidMachine)
+    if (!isSessionMachine() && !isSnapshotMachine())
+    {
         // clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
 …
 Machine* Machine::getMachine()
+{
     if (getClassID() == clsidSessionMachine)
+    if (isSessionMachine())
         return (Machine*)mPeer;
     return this;
 …
                               Snapshot *aParentSnapshot)
+{
+    AssertReturn(getClassID() == clsidMachine, E_FAIL);
+    AssertReturn(!isSnapshotMachine(), E_FAIL);
+    AssertReturn(!isSessionMachine(), E_FAIL);
     HRESULT rc = S_OK;
 …
 HRESULT Machine::loadHardware(const settings::Hardware &data)
+{
     AssertReturn(getClassID() == clsidMachine || getClassID() == clsidSnapshotMachine, E_FAIL);
+    AssertReturn(!isSessionMachine(), E_FAIL);
     HRESULT rc = S_OK;
 …
                                         const Guid *aSnapshotId /* = NULL */)
+{
     AssertReturn(getClassID() == clsidMachine || getClassID() == clsidSnapshotMachine, E_FAIL);
+    AssertReturn(!isSessionMachine(), E_FAIL);
     HRESULT rc = S_OK;
 …
                                     const Guid *aSnapshotId /*= NULL*/)
+{
-    AssertReturn(   (getClassID() == clsidMachine && aSnapshotId == NULL)
-                 || (getClassID() == clsidSnapshotMachine && aSnapshotId != NULL),
-                 E_FAIL);
     HRESULT rc = S_OK;
 …
                 if (FAILED(rc))
+                {
+                    VBoxClsID clsid = getClassID();
+                    if (clsid == clsidSnapshotMachine)
+                    if (isSnapshotMachine())
+                    {
                         // wrap another error message around the "cannot find hard disk" set by findHardDisk
 …
                 if (medium->getType() == MediumType_Immutable)
+                {
                     if (getClassID() == clsidSnapshotMachine)
+                    if (isSnapshotMachine())
                         return setError(E_FAIL,
                                         tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
 …
+                }
                 if (    getClassID() != clsidSnapshotMachine
+                if (    !isSnapshotMachine()
                      && medium->getChildren().size() != 0
+                   )
 …
         if (!medium.isNull())
+        {
             if (getClassID() == clsidSnapshotMachine)
+            if (isSnapshotMachine())
                 rc = medium->attachTo(mData->mUuid, *aSnapshotId);
             else
 …
     ensureNoStateDependencies();
+    AssertReturn(    getClassID() == clsidMachine
+                  || getClassID() == clsidSessionMachine,
+    AssertReturn(!isSnapshotMachine(),
                  E_FAIL);
 …
          * to the client process that creates them) and thus don't need to
          * inform callbacks. */
         if (getClassID() == clsidSessionMachine)
+        if (isSessionMachine())
             mParent->onMachineDataChange(mData->mUuid);
+    }
 …
     if (FAILED(rc))
+    {
         MultiResultRef mrc(rc);
+        MultiResult mrc = rc;
         mrc = deleteImplicitDiffs(pfNeedsSaveSettings);
 …
     mMediaData.commit();
     if (getClassID() == clsidSessionMachine)
+    if (isSessionMachine())
+    {
         /* attach new data to the primary machine and reshare it */
 …
+    }
     if (getClassID() == clsidSessionMachine)
+    if (isSessionMachine())
+    {
         /* attach new data to the primary machine and reshare it */
 …
 void Machine::copyFrom(Machine *aThat)
+{
     AssertReturnVoid(getClassID() == clsidMachine || getClassID() == clsidSessionMachine);
     AssertReturnVoid(aThat->getClassID() == clsidSnapshotMachine);
+    AssertReturnVoid(!isSnapshotMachine());
+    AssertReturnVoid(aThat->isSnapshotMachine());
     AssertReturnVoid(!Global::IsOnline(mData->mMachineState));

trunk/src/VBox/Main/MediumImpl.cpp

r30681	r30714
865	865	{
866	866	Assert(!m->strLastAccessError.isEmpty());
867		rc = setError(E_FAIL, m->strLastAccessError.c_str());
	867	rc = setError(E_FAIL, "%s", m->strLastAccessError.c_str());
868	868	}
869	869	else

trunk/src/VBox/Main/ProgressImpl.cpp

-              r30681
+              r30714
  * @return              COM result indicator.
  */
 HRESULT ProgressBase::protectedInit (AutoInitSpan &aAutoInitSpan,
+HRESULT ProgressBase::protectedInit(AutoInitSpan &aAutoInitSpan,
 #if !defined (VBOX_COM_INPROC)
                             VirtualBox *aParent,
+                                    VirtualBox *aParent,
 #endif
+                            IUnknown *aInitiator,
+                            CBSTR aDescription, OUT_GUID aId /* = NULL */)
+                                    IUnknown *aInitiator,
+                                    CBSTR aDescription,
+                                    OUT_GUID aId /* = NULL */)
+{
     /* Guarantees subclasses call this method at the proper time */
 …
 // public methods only for internal purposes
 ////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the error info stored in the given progress object as the error info on
- * the current thread.
+ *
- * This method is useful if some other COM method uses IProgress to wait for
- * something and then wants to return a failed result of the operation it was
- * waiting for as its own result retaining the extended error info.
+ *
- * If the operation tracked by this progress object is completed successfully
- * and returned S_OK, this method does nothing but returns S_OK. Otherwise, the
- * failed warning or error result code specified at progress completion is
- * returned and the extended error info object (if any) is set on the current
- * thread.
+ *
- * Note that the given progress object must be completed, otherwise this method
- * will assert and fail.
- */
-/* static */
-HRESULT ProgressBase::setErrorInfoOnThread (IProgress *aProgress)
+{
-    AssertReturn(aProgress != NULL, E_INVALIDARG);
-    LONG iRc;
-    HRESULT rc = aProgress->COMGETTER(ResultCode) (&iRc);
-    AssertComRCReturnRC(rc);
-    HRESULT resultCode = iRc;
-    if (resultCode == S_OK)
-        return resultCode;
-    ComPtr<IVirtualBoxErrorInfo> errorInfo;
-    rc = aProgress->COMGETTER(ErrorInfo) (errorInfo.asOutParam());
-    AssertComRCReturnRC(rc);
-    if (!errorInfo.isNull())
-        setErrorInfo (errorInfo);
-    return resultCode;
+}
 /**
 …
 HRESULT Progress::notifyComplete(HRESULT aResultCode,
                                  const GUID &aIID,
                                  const Bstr &aComponent,
+                                 const char *pcszComponent,
                                  const char *aText,
                                  ...)
 …
     va_list va;
     va_start(va, aText);
     HRESULT hrc = notifyCompleteV(aResultCode, aIID, aComponent, aText, va);
+    HRESULT hrc = notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
     va_end(va);
     return hrc;
 …
 HRESULT Progress::notifyCompleteV(HRESULT aResultCode,
                                   const GUID &aIID,
                                   const Bstr &aComponent,
+                                  const char *pcszComponent,
                                   const char *aText,
                                   va_list va)
 …
     if (SUCCEEDED(rc))
+    {
         errorInfo->init(aResultCode, aIID, aComponent, Bstr(text));
+        errorInfo->init(aResultCode, aIID, pcszComponent, text);
         errorInfo.queryInterfaceTo(mErrorInfo.asOutParam());
+    }

trunk/src/VBox/Main/ProgressProxyImpl.cpp

-              r30632
+              r30714
 HRESULT ProgressProxy::notifyComplete(HRESULT aResultCode,
                                       const GUID &aIID,
                                       const Bstr &aComponent,
+                                      const char *pcszComponent,
                                       const char *aText,
                                       ...)
 …
         va_list va;
         va_start(va, aText);
         hrc = Progress::notifyCompleteV(aResultCode, aIID, aComponent, aText, va);
+        hrc = Progress::notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
         va_end(va);
+    }
 …
                         Utf8Str strText(bstrText);
                         LogFlowThisFunc(("Got ErrorInfo(%s); hrcResult=%Rhrc\n", strText.c_str(), hrcResult));
+                        Progress::notifyComplete((HRESULT)hrcResult, Guid(bstrIID), bstrComponent, "%s", strText.c_str());
+                        Progress::notifyComplete((HRESULT)hrcResult,
+                                                 Guid(bstrIID),
+                                                 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), Bstr("ProgressProxy"),
+                        Progress::notifyComplete((HRESULT)hrcResult,
+                                                 COM_IIDOF(IProgress),
+                                                 "ProgressProxy",
                                                  tr("No error info"));
+                    }

trunk/src/VBox/Main/VirtualBoxBase.cpp

-              r30111
+              r30714
+                {
                     /* inform AutoUninitSpan ctor there are no more callers */
                     RTSemEventSignal (mZeroCallersSem);
+                    RTSemEventSignal(mZeroCallersSem);
+                }
+            }
 …
     if (aState)
         *aState = mState;
+    if (FAILED(rc))
+    {
+        if (mState == VirtualBoxBase::Limited)
+            rc = setError(rc, "The object functionality is limited");
+        else
+            rc = setError(rc, "The object is not ready");
+    }
     return rc;
 …
     AssertMsgFailed (("mState = %d!", mState));
+}
-////////////////////////////////////////////////////////////////////////////////
-//
-// AutoInitSpan methods
-//
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates a smart initialization span object that places the object to
- * InInit state.
+ *
- * Please see the AutoInitSpan class description for more info.
+ *
- * @param aObj      |this| pointer of the managed VirtualBoxBase object whose
- *                  init() method is being called.
- * @param aResult   Default initialization result.
- */
-AutoInitSpan::AutoInitSpan(VirtualBoxBase *aObj,
-                           Result aResult /* = Failed */)
-    : mObj(aObj),
-      mResult(aResult),
-      mOk(false)
+{
-    Assert(aObj);
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    mOk = mObj->mState == VirtualBoxBase::NotReady;
-    AssertReturnVoid (mOk);
-    mObj->setState(VirtualBoxBase::InInit);
+}
-/**
- * Places the managed VirtualBoxBase object to  Ready/Limited state if the
- * initialization succeeded or partly succeeded, or places it to InitFailed
- * state and calls the object's uninit() method.
+ *
- * Please see the AutoInitSpan class description for more info.
- */
-AutoInitSpan::~AutoInitSpan()
+{
-    /* if the state was other than NotReady, do nothing */
-    if (!mOk)
-        return;
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    Assert(mObj->mState == VirtualBoxBase::InInit);
-    if (mObj->mCallers > 0)
+    {
-        Assert(mObj->mInitUninitWaiters > 0);
-        /* We have some pending addCaller() calls on other threads (created
-         * during InInit), signal that InInit is finished and they may go on. */
-        RTSemEventMultiSignal(mObj->mInitUninitSem);
+    }
-    if (mResult == Succeeded)
+    {
-        mObj->setState(VirtualBoxBase::Ready);
+    }
-    else
-    if (mResult == Limited)
+    {
-        mObj->setState(VirtualBoxBase::Limited);
+    }
-    else
+    {
-        mObj->setState(VirtualBoxBase::InitFailed);
-        /* leave the lock to prevent nesting when uninit() is called */
-        stateLock.leave();
-        /* call uninit() to let the object uninit itself after failed init() */
-        mObj->uninit();
-        /* Note: the object may no longer exist here (for example, it can call
-         * the destructor in uninit()) */
+    }
+}
-// AutoReinitSpan methods
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates a smart re-initialization span object and places the object to
- * InInit state.
+ *
- * Please see the AutoInitSpan class description for more info.
+ *
- * @param aObj      |this| pointer of the managed VirtualBoxBase object whose
- *                  re-initialization method is being called.
- */
-AutoReinitSpan::AutoReinitSpan(VirtualBoxBase *aObj)
-    : mObj(aObj),
-      mSucceeded(false),
-      mOk(false)
+{
-    Assert(aObj);
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    mOk = mObj->mState == VirtualBoxBase::Limited;
-    AssertReturnVoid (mOk);
-    mObj->setState(VirtualBoxBase::InInit);
+}
-/**
- * Places the managed VirtualBoxBase object to Ready state if the
- * re-initialization succeeded (i.e. #setSucceeded() has been called) or back to
- * Limited state otherwise.
+ *
- * Please see the AutoInitSpan class description for more info.
- */
-AutoReinitSpan::~AutoReinitSpan()
+{
-    /* if the state was other than Limited, do nothing */
-    if (!mOk)
-        return;
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    Assert(mObj->mState == VirtualBoxBase::InInit);
-    if (mObj->mCallers > 0 && mObj->mInitUninitWaiters > 0)
+    {
-        /* We have some pending addCaller() calls on other threads (created
-         * during InInit), signal that InInit is finished and they may go on. */
-        RTSemEventMultiSignal(mObj->mInitUninitSem);
+    }
-    if (mSucceeded)
+    {
-        mObj->setState(VirtualBoxBase::Ready);
+    }
-    else
+    {
-        mObj->setState(VirtualBoxBase::Limited);
+    }
+}
-// AutoUninitSpan methods
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates a smart uninitialization span object and places this object to
- * InUninit state.
+ *
- * Please see the AutoInitSpan class description for more info.
+ *
- * @note This method blocks the current thread execution until the number of
- *       callers of the managed VirtualBoxBase object drops to zero!
+ *
- * @param aObj  |this| pointer of the VirtualBoxBase object whose uninit()
- *              method is being called.
- */
-AutoUninitSpan::AutoUninitSpan(VirtualBoxBase *aObj)
-    : mObj(aObj),
-      mInitFailed(false),
-      mUninitDone(false)
+{
-    Assert(aObj);
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    Assert(mObj->mState != VirtualBoxBase::InInit);
-    /* Set mUninitDone to |true| if this object is already uninitialized
-     * (NotReady) or if another AutoUninitSpan is currently active on some
-     *  other thread (InUninit). */
-    mUninitDone =    mObj->mState == VirtualBoxBase::NotReady
-                  || mObj->mState == VirtualBoxBase::InUninit;
-    if (mObj->mState == VirtualBoxBase::InitFailed)
+    {
-        /* we've been called by init() on failure */
-        mInitFailed = true;
+    }
-    else
+    {
-        if (mUninitDone)
+        {
-            /* do nothing if already uninitialized */
-            if (mObj->mState == VirtualBoxBase::NotReady)
-                return;
-            /* otherwise, wait until another thread finishes uninitialization.
-             * This is necessary to make sure that when this method returns, the
-             * object is NotReady and therefore can be deleted (for example).
-             * In particular, this is used by
-             * VirtualBoxBaseWithTypedChildrenNEXT::uninitDependentChildren(). */
-            /* lazy semaphore creation */
-            if (mObj->mInitUninitSem == NIL_RTSEMEVENTMULTI)
+            {
-                RTSemEventMultiCreate(&mObj->mInitUninitSem);
-                Assert(mObj->mInitUninitWaiters == 0);
+            }
-            ++mObj->mInitUninitWaiters;
-            LogFlowFunc(("{%p}: Waiting for AutoUninitSpan to finish...\n",
-                         mObj));
-            stateLock.leave();
-            RTSemEventMultiWait(mObj->mInitUninitSem, RT_INDEFINITE_WAIT);
-            stateLock.enter();
-            if (--mObj->mInitUninitWaiters == 0)
+            {
-                /* destroy the semaphore since no more necessary */
-                RTSemEventMultiDestroy(mObj->mInitUninitSem);
-                mObj->mInitUninitSem = NIL_RTSEMEVENTMULTI;
+            }
-            return;
+        }
+    }
-    /* go to InUninit to prevent from adding new callers */
-    mObj->setState(VirtualBoxBase::InUninit);
-    /* wait for already existing callers to drop to zero */
-    if (mObj->mCallers > 0)
+    {
-        /* lazy creation */
-        Assert(mObj->mZeroCallersSem == NIL_RTSEMEVENT);
-        RTSemEventCreate(&mObj->mZeroCallersSem);
-        /* wait until remaining callers release the object */
-        LogFlowFunc(("{%p}: Waiting for callers (%d) to drop to zero...\n",
-                     mObj, mObj->mCallers));
-        stateLock.leave();
-        RTSemEventWait(mObj->mZeroCallersSem, RT_INDEFINITE_WAIT);
+    }
+}
-/**
- *  Places the managed VirtualBoxBase object to the NotReady state.
- */
-AutoUninitSpan::~AutoUninitSpan()
+{
-    /* do nothing if already uninitialized */
-    if (mUninitDone)
-        return;
-    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
-    Assert(mObj->mState == VirtualBoxBase::InUninit);
-    mObj->setState(VirtualBoxBase::NotReady);
+}
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxBase
-//
-////////////////////////////////////////////////////////////////////////////////
 /**
 …
  */
 // static
 const char *VirtualBoxBase::translate (const char * /* context */, const char *sourceText,
                                        const char * /* comment */)
+const char *VirtualBoxBase::translate(const char * /* context */, const char *sourceText,
+                                      const char * /* comment */)
+{
 #if 0
 …
+}
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxSupportTranslationBase
-//
-////////////////////////////////////////////////////////////////////////////////
-/**
- *  Modifies the given argument so that it will contain only a class name
- *  (null-terminated). The argument must point to a <b>non-constant</b>
- *  string containing a valid value, as it is generated by the
- *  __PRETTY_FUNCTION__ built-in macro of the GCC compiler, or by the
- *  __FUNCTION__ macro of any other compiler.
+ *
- *  The function assumes that the macro is used within the member of the
- *  class derived from the VirtualBoxSupportTranslation<> template.
+ *
- *  @param prettyFunctionName   string to modify
- *  @return
- *      true on success and false otherwise
- */
-bool VirtualBoxSupportTranslationBase::cutClassNameFrom__PRETTY_FUNCTION__ (char *fn)
+{
-    Assert(fn);
-    if (!fn)
-        return false;
-#if defined (__GNUC__)
-    // the format is like:
-    // VirtualBoxSupportTranslation<C>::VirtualBoxSupportTranslation() [with C = VirtualBox]
-    #define START " = "
-    #define END   "]"
-#elif defined (_MSC_VER)
-    // the format is like:
-    // VirtualBoxSupportTranslation<class VirtualBox>::__ctor
-    #define START "<class "
-    #define END   ">::"
-#endif
-    char *start = strstr(fn, START);
-    Assert(start);
-    if (start)
+    {
-        start += sizeof(START) - 1;
-        char *end = strstr(start, END);
-        Assert(end && (end > start));
-        if (end && (end > start))
+        {
-            size_t len = end - start;
-            memmove(fn, start, len);
-            fn[len] = 0;
-            return true;
+        }
+    }
-    #undef END
-    #undef START
-    return false;
+}
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxSupportErrorInfoImplBase
-//
-////////////////////////////////////////////////////////////////////////////////
-RTTLS VirtualBoxSupportErrorInfoImplBase::MultiResult::sCounter = NIL_RTTLS;
-void VirtualBoxSupportErrorInfoImplBase::MultiResult::init()
+{
-    if (sCounter == NIL_RTTLS)
+    {
-        sCounter = RTTlsAlloc();
-        AssertReturnVoid (sCounter != NIL_RTTLS);
+    }
-    uintptr_t counter = (uintptr_t) RTTlsGet (sCounter);
-    ++ counter;
-    RTTlsSet (sCounter, (void *) counter);
+}
-VirtualBoxSupportErrorInfoImplBase::MultiResult::~MultiResult()
+{
-    uintptr_t counter = (uintptr_t) RTTlsGet (sCounter);
-    AssertReturnVoid (counter != 0);
-    -- counter;
-    RTTlsSet (sCounter, (void *) counter);
+}
 /**
  *  Sets error info for the current thread. This is an internal function that
 …
  */
 /* static */
 HRESULT VirtualBoxSupportErrorInfoImplBase::setErrorInternal(HRESULT aResultCode,
                                                              const GUID &aIID,
                                                              const wchar_t *aComponent,
                                                              const Bstr &aText,
                                                              bool aWarning,
                                                              bool aLogIt)
+HRESULT VirtualBoxBase::setErrorInternal(HRESULT aResultCode,
+                                         const GUID &aIID,
+                                         const char *pcszComponent,
+                                         const Utf8Str &aText,
+                                         bool aWarning,
+                                         bool aLogIt)
+{
     /* whether multi-error mode is turned on */
+    bool preserve = ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
+    Bstr bstrComponent((CBSTR)aComponent);
+    bool preserve = MultiResult::isMultiEnabled();
     if (aLogIt)
+        LogRel(("ERROR [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%ls} aText={%ls} "
+                "aWarning=%RTbool, preserve=%RTbool\n",
+                aResultCode, aResultCode, &aIID, bstrComponent.raw(), aText.raw(), aWarning,
+        LogRel(("ERROR [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%s} aText={%s} aWarning=%RTbool, preserve=%RTbool\n",
+                aResultCode,
+                aResultCode,
+                &aIID,
+                pcszComponent,
+                aText.c_str(),
+                aWarning,
                 preserve));
 …
         /* set the current error info and preserve the previous one if any */
         rc = info->init(aResultCode, aIID, bstrComponent, aText, curInfo);
+        rc = info->init(aResultCode, aIID, pcszComponent, aText, curInfo);
         if (FAILED(rc)) break;
 …
             /* set the current error info and preserve the previous one if any */
             rc = info->init(aResultCode, aIID, bstrComponent, aText, curInfo);
+            rc = info->init(aResultCode, aIID, pcszComponent, Bstr(aText), curInfo);
             if (FAILED(rc)) break;
 …
              *  set the exception (nobody will be able to read it).
              */
+            LogWarningFunc (("Will not set an exception because "
+                             "nsIExceptionService is not available "
+                             "(NS_ERROR_UNEXPECTED). "
+                             "XPCOM is being shutdown?\n"));
+            LogWarningFunc(("Will not set an exception because nsIExceptionService is not available "
+                            "(NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
             rc = NS_OK;
+        }
 …
+}
+/**
+ * Shortcut instance method to calling the static setErrorInternal with the
+ * class interface ID and component name inserted correctly. This uses the
+ * virtual getClassIID() and getComponentName() methods which are automatically
+ * defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
+ * @param aResultCode
+ * @param pcsz
+ * @return
+ */
+HRESULT VirtualBoxBase::setError(HRESULT aResultCode, const char *pcsz, ...)
+{
+    va_list args;
+    va_start(args, pcsz);
+    HRESULT rc = setErrorInternal(aResultCode,
+                                  this->getClassIID(),
+                                  this->getComponentName(),
+                                  Utf8StrFmtVA(pcsz, args),
+                                  false /* aWarning */,
+                                  true /* aLogIt */);
+    va_end(args);
+    return rc;
+}
+/**
+ * Like setError(), but sets the "warning" bit in the call to setErrorInternal().
+ * @param aResultCode
+ * @param pcsz
+ * @return
+ */
+HRESULT VirtualBoxBase::setWarning(HRESULT aResultCode, const char *pcsz, ...)
+{
+    va_list args;
+    va_start(args, pcsz);
+    HRESULT rc = setErrorInternal(aResultCode,
+                                  this->getClassIID(),
+                                  this->getComponentName(),
+                                  Utf8StrFmtVA(pcsz, args),
+                                  true /* aWarning */,
+                                  true /* aLogIt */);
+    va_end(args);
+    return rc;
+}
+/**
+ * Like setError(), but disables the "log" flag in the call to setErrorInternal().
+ * @param aResultCode
+ * @param pcsz
+ * @return
+ */
+HRESULT VirtualBoxBase::setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...)
+{
+    va_list args;
+    va_start(args, pcsz);
+    HRESULT rc = setErrorInternal(aResultCode,
+                                  this->getClassIID(),
+                                  this->getComponentName(),
+                                  Utf8StrFmtVA(pcsz, args),
+                                  false /* aWarning */,
+                                  false /* aLogIt */);
+    va_end(args);
+    return rc;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+// AutoInitSpan methods
+//
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Creates a smart initialization span object that places the object to
+ * InInit state.
+ *
+ * Please see the AutoInitSpan class description for more info.
+ *
+ * @param aObj      |this| pointer of the managed VirtualBoxBase object whose
+ *                  init() method is being called.
+ * @param aResult   Default initialization result.
+ */
+AutoInitSpan::AutoInitSpan(VirtualBoxBase *aObj,
+                           Result aResult /* = Failed */)
+    : mObj(aObj),
+      mResult(aResult),
+      mOk(false)
+{
+    Assert(aObj);
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    mOk = mObj->mState == VirtualBoxBase::NotReady;
+    AssertReturnVoid (mOk);
+    mObj->setState(VirtualBoxBase::InInit);
+}
+/**
+ * Places the managed VirtualBoxBase object to  Ready/Limited state if the
+ * initialization succeeded or partly succeeded, or places it to InitFailed
+ * state and calls the object's uninit() method.
+ *
+ * Please see the AutoInitSpan class description for more info.
+ */
+AutoInitSpan::~AutoInitSpan()
+{
+    /* if the state was other than NotReady, do nothing */
+    if (!mOk)
+        return;
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    Assert(mObj->mState == VirtualBoxBase::InInit);
+    if (mObj->mCallers > 0)
+    {
+        Assert(mObj->mInitUninitWaiters > 0);
+        /* We have some pending addCaller() calls on other threads (created
+         * during InInit), signal that InInit is finished and they may go on. */
+        RTSemEventMultiSignal(mObj->mInitUninitSem);
+    }
+    if (mResult == Succeeded)
+    {
+        mObj->setState(VirtualBoxBase::Ready);
+    }
+    else
+    if (mResult == Limited)
+    {
+        mObj->setState(VirtualBoxBase::Limited);
+    }
+    else
+    {
+        mObj->setState(VirtualBoxBase::InitFailed);
+        /* leave the lock to prevent nesting when uninit() is called */
+        stateLock.leave();
+        /* call uninit() to let the object uninit itself after failed init() */
+        mObj->uninit();
+        /* Note: the object may no longer exist here (for example, it can call
+         * the destructor in uninit()) */
+    }
+}
+// AutoReinitSpan methods
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Creates a smart re-initialization span object and places the object to
+ * InInit state.
+ *
+ * Please see the AutoInitSpan class description for more info.
+ *
+ * @param aObj      |this| pointer of the managed VirtualBoxBase object whose
+ *                  re-initialization method is being called.
+ */
+AutoReinitSpan::AutoReinitSpan(VirtualBoxBase *aObj)
+    : mObj(aObj),
+      mSucceeded(false),
+      mOk(false)
+{
+    Assert(aObj);
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    mOk = mObj->mState == VirtualBoxBase::Limited;
+    AssertReturnVoid (mOk);
+    mObj->setState(VirtualBoxBase::InInit);
+}
+/**
+ * Places the managed VirtualBoxBase object to Ready state if the
+ * re-initialization succeeded (i.e. #setSucceeded() has been called) or back to
+ * Limited state otherwise.
+ *
+ * Please see the AutoInitSpan class description for more info.
+ */
+AutoReinitSpan::~AutoReinitSpan()
+{
+    /* if the state was other than Limited, do nothing */
+    if (!mOk)
+        return;
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    Assert(mObj->mState == VirtualBoxBase::InInit);
+    if (mObj->mCallers > 0 && mObj->mInitUninitWaiters > 0)
+    {
+        /* We have some pending addCaller() calls on other threads (created
+         * during InInit), signal that InInit is finished and they may go on. */
+        RTSemEventMultiSignal(mObj->mInitUninitSem);
+    }
+    if (mSucceeded)
+    {
+        mObj->setState(VirtualBoxBase::Ready);
+    }
+    else
+    {
+        mObj->setState(VirtualBoxBase::Limited);
+    }
+}
+// AutoUninitSpan methods
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Creates a smart uninitialization span object and places this object to
+ * InUninit state.
+ *
+ * Please see the AutoInitSpan class description for more info.
+ *
+ * @note This method blocks the current thread execution until the number of
+ *       callers of the managed VirtualBoxBase object drops to zero!
+ *
+ * @param aObj  |this| pointer of the VirtualBoxBase object whose uninit()
+ *              method is being called.
+ */
+AutoUninitSpan::AutoUninitSpan(VirtualBoxBase *aObj)
+    : mObj(aObj),
+      mInitFailed(false),
+      mUninitDone(false)
+{
+    Assert(aObj);
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    Assert(mObj->mState != VirtualBoxBase::InInit);
+    /* Set mUninitDone to |true| if this object is already uninitialized
+     * (NotReady) or if another AutoUninitSpan is currently active on some
+     *  other thread (InUninit). */
+    mUninitDone =    mObj->mState == VirtualBoxBase::NotReady
+                  || mObj->mState == VirtualBoxBase::InUninit;
+    if (mObj->mState == VirtualBoxBase::InitFailed)
+    {
+        /* we've been called by init() on failure */
+        mInitFailed = true;
+    }
+    else
+    {
+        if (mUninitDone)
+        {
+            /* do nothing if already uninitialized */
+            if (mObj->mState == VirtualBoxBase::NotReady)
+                return;
+            /* otherwise, wait until another thread finishes uninitialization.
+             * This is necessary to make sure that when this method returns, the
+             * object is NotReady and therefore can be deleted (for example).
+             * In particular, this is used by
+             * VirtualBoxBaseWithTypedChildrenNEXT::uninitDependentChildren(). */
+            /* lazy semaphore creation */
+            if (mObj->mInitUninitSem == NIL_RTSEMEVENTMULTI)
+            {
+                RTSemEventMultiCreate(&mObj->mInitUninitSem);
+                Assert(mObj->mInitUninitWaiters == 0);
+            }
+            ++mObj->mInitUninitWaiters;
+            LogFlowFunc(("{%p}: Waiting for AutoUninitSpan to finish...\n",
+                         mObj));
+            stateLock.leave();
+            RTSemEventMultiWait(mObj->mInitUninitSem, RT_INDEFINITE_WAIT);
+            stateLock.enter();
+            if (--mObj->mInitUninitWaiters == 0)
+            {
+                /* destroy the semaphore since no more necessary */
+                RTSemEventMultiDestroy(mObj->mInitUninitSem);
+                mObj->mInitUninitSem = NIL_RTSEMEVENTMULTI;
+            }
+            return;
+        }
+    }
+    /* go to InUninit to prevent from adding new callers */
+    mObj->setState(VirtualBoxBase::InUninit);
+    /* wait for already existing callers to drop to zero */
+    if (mObj->mCallers > 0)
+    {
+        /* lazy creation */
+        Assert(mObj->mZeroCallersSem == NIL_RTSEMEVENT);
+        RTSemEventCreate(&mObj->mZeroCallersSem);
+        /* wait until remaining callers release the object */
+        LogFlowFunc(("{%p}: Waiting for callers (%d) to drop to zero...\n",
+                     mObj, mObj->mCallers));
+        stateLock.leave();
+        RTSemEventWait(mObj->mZeroCallersSem, RT_INDEFINITE_WAIT);
+    }
+}
+/**
+ *  Places the managed VirtualBoxBase object to the NotReady state.
+ */
+AutoUninitSpan::~AutoUninitSpan()
+{
+    /* do nothing if already uninitialized */
+    if (mUninitDone)
+        return;
+    AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
+    Assert(mObj->mState == VirtualBoxBase::InUninit);
+    mObj->setState(VirtualBoxBase::NotReady);
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+// VirtualBoxSupportTranslationBase
+//
+////////////////////////////////////////////////////////////////////////////////
+/**
+ *  Modifies the given argument so that it will contain only a class name
+ *  (null-terminated). The argument must point to a <b>non-constant</b>
+ *  string containing a valid value, as it is generated by the
+ *  __PRETTY_FUNCTION__ built-in macro of the GCC compiler, or by the
+ *  __FUNCTION__ macro of any other compiler.
+ *
+ *  The function assumes that the macro is used within the member of the
+ *  class derived from the VirtualBoxSupportTranslation<> template.
+ *
+ *  @param prettyFunctionName   string to modify
+ *  @return
+ *      true on success and false otherwise
+ */
+bool VirtualBoxSupportTranslationBase::cutClassNameFrom__PRETTY_FUNCTION__ (char *fn)
+{
+    Assert(fn);
+    if (!fn)
+        return false;
+#if defined (__GNUC__)
+    // the format is like:
+    // VirtualBoxSupportTranslation<C>::VirtualBoxSupportTranslation() [with C = VirtualBox]
+    #define START " = "
+    #define END   "]"
+#elif defined (_MSC_VER)
+    // the format is like:
+    // VirtualBoxSupportTranslation<class VirtualBox>::__ctor
+    #define START "<class "
+    #define END   ">::"
+#endif
+    char *start = strstr(fn, START);
+    Assert(start);
+    if (start)
+    {
+        start += sizeof(START) - 1;
+        char *end = strstr(start, END);
+        Assert(end && (end > start));
+        if (end && (end > start))
+        {
+            size_t len = end - start;
+            memmove(fn, start, len);
+            fn[len] = 0;
+            return true;
+        }
+    }
+    #undef END
+    #undef START
+    return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+// VirtualBoxBaseWithChildrenNEXT methods
+//
+////////////////////////////////////////////////////////////////////////////////
 /**

trunk/src/VBox/Main/VirtualBoxErrorInfoImpl.cpp

-              r28800
+              r30714
 ////////////////////////////////////////////////////////////////////////////////
+HRESULT VirtualBoxErrorInfo::init (HRESULT aResultCode, const GUID &aIID,
+                                   CBSTR aComponent, CBSTR aText,
+                                   IVirtualBoxErrorInfo *aNext)
+{
+    mResultCode = aResultCode;
+    mIID = aIID;
+    mComponent = aComponent;
+    mText = aText;
+HRESULT VirtualBoxErrorInfo::init(HRESULT aResultCode,
+                                  const GUID &aIID,
+                                  const char *pcszComponent,
+                                  const Utf8Str &strText,
+                                  IVirtualBoxErrorInfo *aNext)
+{
+    m_resultCode = aResultCode;
+    m_IID = aIID;
+    m_strComponent = pcszComponent;
+    m_strText = strText;
     mNext = aNext;
 …
     CheckComArgOutPointerValid(aResultCode);
     *aResultCode = mResultCode;
+    *aResultCode = m_resultCode;
     return S_OK;
+}
 …
     CheckComArgOutPointerValid(aIID);
     mIID.toUtf16().cloneTo(aIID);
+    m_IID.toUtf16().cloneTo(aIID);
     return S_OK;
+}
 …
     CheckComArgOutPointerValid(aComponent);
     mComponent.cloneTo(aComponent);
+    m_strComponent.cloneTo(aComponent);
     return S_OK;
+}
 …
     CheckComArgOutPointerValid(aText);
     mText.cloneTo(aText);
+    m_strText.cloneTo(aText);
     return S_OK;
+}
 …
      * corresponding fields will simply remain null in this case). */
     mResultCode = S_OK;
     rc = aInfo->GetGUID (mIID.asOutParam());
+    m_resultCode = S_OK;
+    rc = aInfo->GetGUID(m_IID.asOutParam());
     AssertComRC (rc);
+    rc = aInfo->GetSource (mComponent.asOutParam());
+    Bstr bstrComponent;
+    rc = aInfo->GetSource(bstrComponent.asOutParam());
     AssertComRC (rc);
+    rc = aInfo->GetDescription (mText.asOutParam());
+    m_strComponent = bstrComponent;
+    Bstr bstrText;
+    rc = aInfo->GetDescription(bstrText.asOutParam());
     AssertComRC (rc);
+    m_strText = bstrText;
     return S_OK;
 …
      * corresponding fields will simply remain null in this case). */
     rc = aInfo->GetResult(&mResultCode);
+    rc = aInfo->GetResult(&m_resultCode);
     AssertComRC(rc);
 …
     if (NS_SUCCEEDED(rc))
+    {
         mText = Bstr(pszMsg);
+        m_strText = pszMsg;
         nsMemory::Free(pszMsg);
+    }
     else
         mText.setNull();
+        m_strText.setNull();
     return S_OK;
 …
     CheckComArgOutPointerValid(aMessage);
     Utf8Str (mText).cloneTo(aMessage);
+    m_strText.cloneTo(aMessage);
     return S_OK;
+}

trunk/src/VBox/Main/VirtualBoxImpl.cpp

-              r30591
+              r30714
     LogFlowFuncEnter();
     std::auto_ptr <StartSVCHelperClientData>
         d(static_cast <StartSVCHelperClientData *>(aUser));
+    std::auto_ptr<StartSVCHelperClientData>
+        d(static_cast<StartSVCHelperClientData*>(aUser));
     HRESULT rc = S_OK;
 …
         if (RT_FAILURE(vrc))
+        {
             rc = setError(E_FAIL,
                           tr("Could not create the communication channel (%Rrc)"), vrc);
+            rc = d->that->setError(E_FAIL,
+                                   tr("Could not create the communication channel (%Rrc)"), vrc);
             break;
+        }
 …
                  * (pressing the Cancel button to close the Run As dialog) */
                 if (vrc2 == VERR_CANCELLED)
                     rc = setError(E_FAIL,
                                   tr("Operation cancelled by the user"));
+                    rc = d->that->setError(E_FAIL,
+                                           tr("Operation cancelled by the user"));
                 else
                     rc = setError(E_FAIL,
                                   tr("Could not launch a privileged process '%s' (%Rrc)"),
                                   exePath, vrc2);
+                    rc = d->that->setError(E_FAIL,
+                                           tr("Could not launch a privileged process '%s' (%Rrc)"),
+                                           exePath, vrc2);
                 break;
+            }
 …
             if (RT_FAILURE(vrc))
+            {
                 rc = setError(E_FAIL,
                               tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
+                rc = d->that->setError(E_FAIL,
+                                       tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
                 break;
+            }
 …
         if (SUCCEEDED(rc) && RT_FAILURE(vrc))
+        {
             rc = setError(E_FAIL,
                           tr("Could not operate the communication channel (%Rrc)"), vrc);
+            rc = d->that->setError(E_FAIL,
+                                   tr("Could not operate the communication channel (%Rrc)"), vrc);
             break;
+        }
 …
         int vrc = RTDirCreateFullPath(strDir.c_str(), 0777);
         if (RT_FAILURE(vrc))
             return setError(E_FAIL,
                             tr("Could not create the directory '%s' (%Rrc)"),
                             strDir.c_str(),
                             vrc);
+            return setErrorStatic(E_FAIL,
+                                  Utf8StrFmt(tr("Could not create the directory '%s' (%Rrc)"),
+                                             strDir.c_str(),
+                                             vrc));
+    }
 …
     catch (const xml::Error &err)
+    {
+        return setError(E_FAIL, tr("%s.\n%s[%d] (%s)"),
+                                err.what(),
+                                pszFile, iLine, pszFunction);
+        return setErrorStatic(E_FAIL,
+                              Utf8StrFmt(tr("%s.\n%s[%d] (%s)"),
+                                         err.what(),
+                                         pszFile, iLine, pszFunction).c_str());
+    }
     catch (const std::exception &err)
+    {
+        return setError(E_FAIL, tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
+                                err.what(), typeid(err).name(),
+                                pszFile, iLine, pszFunction);
+        return setErrorStatic(E_FAIL,
+                              Utf8StrFmt(tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
+                                         err.what(), typeid(err).name(),
+                                         pszFile, iLine, pszFunction).c_str());
+    }
     catch (...)
+    {
+        return setError(E_FAIL, tr("Unknown exception\n%s[%d] (%s)"),
+                                pszFile, iLine, pszFunction);
+        return setErrorStatic(E_FAIL,
+                              Utf8StrFmt(tr("Unknown exception\n%s[%d] (%s)"),
+                                         pszFile, iLine, pszFunction).c_str());
+    }

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

-              r28800
+              r30714
             if (RT_FAILURE(rc))
+            {
+                progress->notifyComplete(E_FAIL, COM_IIDOF(IHostNetworkInterface), HostNetworkInterface::getComponentName(),
+                progress->notifyComplete(E_FAIL,
+                                         COM_IIDOF(IHostNetworkInterface),
+                                         HostNetworkInterface::getStaticComponentName(),
                                          "Failed to get program path, rc=%Rrc\n", rc);
                 return rc;
 …
                         if (RT_FAILURE(rc))
+                        {
+                            progress->notifyComplete(E_FAIL, COM_IIDOF(IHostNetworkInterface), HostNetworkInterface::getComponentName(),
+                            progress->notifyComplete(E_FAIL,
+                                                     COM_IIDOF(IHostNetworkInterface),
+                                                     HostNetworkInterface::getStaticComponentName(),
                                                      "Failed to get config info for %s (as reported by '" VBOXNETADPCTL_NAME " add')\n", szBuf);
+                        }
 …
                 if ((rc = pclose(fp)) != 0)
+                {
+                    progress->notifyComplete(E_FAIL, COM_IIDOF(IHostNetworkInterface), HostNetworkInterface::getComponentName(), "Failed to execute '"VBOXNETADPCTL_NAME " add' (exit status: %d)", rc);
+                    progress->notifyComplete(E_FAIL,
+                                             COM_IIDOF(IHostNetworkInterface),
+                                             HostNetworkInterface::getStaticComponentName(),
+                                             "Failed to execute '"VBOXNETADPCTL_NAME " add' (exit status: %d)", rc);
                     rc = VERR_INTERNAL_ERROR;
+                }
 …
             rc = NetIfAdpCtl(Utf8Str(ifname).c_str(), "remove", NULL, NULL);
             if (RT_FAILURE(rc))
+                progress->notifyComplete(E_FAIL, COM_IIDOF(IHostNetworkInterface), HostNetworkInterface::getComponentName(), "Failed to execute '"VBOXNETADPCTL_NAME "' (exit status: %d)", rc);
+                progress->notifyComplete(E_FAIL,
+                                         COM_IIDOF(IHostNetworkInterface),
+                                         HostNetworkInterface::getStaticComponentName(),
+                                         "Failed to execute '"VBOXNETADPCTL_NAME "' (exit status: %d)", rc);
             else
                 progress->notifyComplete(S_OK);

trunk/src/VBox/Main/glue/ErrorInfo.cpp

-              r30683
+              r30714
     mText = x.mText;
     if (x.m_pNext)
+    if (x.m_pNext != NULL)
         m_pNext = new ErrorInfo(x.m_pNext);
     else
 …
+    {
         m_pNext = new ErrorInfo(next);
         Assert(m_pNext);
+        Assert(m_pNext != NULL);
         if (!m_pNext)
             rc = E_OUTOFMEMORY;

trunk/src/VBox/Main/glue/SupportErrorInfo.cpp

-              r28800
+              r30714
+}
+// SupportErrorInfoBase methods
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Sets error info for the current thread. This is an internal function that
+ * gets eventually called by all public setError(), setWarning() and
+ * setErrorInfo() variants.
+ *
+ * The previous error info object (if any) will be preserved if the multi-error
+ * mode (see MultiResult) is turned on for the current thread.
+ *
+ * If @a aWarning is @c true, then the highest (31) bit in the @a aResultCode
+ * value which indicates the error severity is reset to zero to make sure the
+ * receiver will recognize that the created error info object represents a
+ * warning rather than an error.
+ *
+ * If @a aInfo is not NULL then all other paremeters are ignored and the given
+ * error info object is set on the current thread. Note that in this case, the
+ * existing error info object (if any) will be preserved by attaching it to the
+ * tail of the error chain of the given aInfo object in multi-error mode.
+ *
+ * If the error info is successfully set then this method returns aResultCode
+ * (or the result code returned as an output parameter of the
+ * aInfo->GetResultCode() call when @a aInfo is not NULL). This is done for
+ * conveinence: this way, setError() and friends may be used in return
+ * statements of COM method implementations.
+ *
+ * If setting error info fails then this method asserts and the failed result
+ * code is returned.
+ */
+/* static */
+HRESULT SupportErrorInfoBase::setErrorInternal(HRESULT aResultCode,
+                                               const GUID *aIID,
+                                               const char *aComponent,
+                                               const Utf8Str &strText,
+                                               bool aWarning,
+                                               IVirtualBoxErrorInfo *aInfo /*= NULL*/)
+/*static*/
+bool MultiResult::isMultiEnabled()
+{
+    /* whether multi-error mode is turned on */
+    bool preserve = ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
+    LogRel(("ERROR [COM]: aRC=%#08x aIID={%RTuuid} aComponent={%s} aText={%s} aWarning=%RTbool, aInfo=%p, preserve=%RTbool\n",
+            aResultCode,
+            aIID,
+            aComponent,
+            strText.c_str(),
+            aWarning,
+            aInfo,
+            preserve));
+    if (aInfo == NULL)
+    {
+        /* these are mandatory, others -- not */
+        AssertReturn((!aWarning && FAILED(aResultCode)) ||
+                      (aWarning && aResultCode != S_OK),
+                      E_FAIL);
+        AssertReturn(!strText.isEmpty(), E_FAIL);
+        /* reset the error severity bit if it's a warning */
+        if (aWarning)
+            aResultCode &= ~0x80000000;
+    }
+    HRESULT rc = S_OK;
+    do
+    {
+        ComPtr<IVirtualBoxErrorInfo> info;
+#if !defined (VBOX_WITH_XPCOM)
+        ComPtr<IVirtualBoxErrorInfo> curInfo;
+        if (preserve)
+        {
+            /* get the current error info if any */
+            ComPtr<IErrorInfo> err;
+            rc = ::GetErrorInfo(0, err.asOutParam());
+            if (FAILED(rc)) break;
+            rc = err.queryInterfaceTo(curInfo.asOutParam());
+            if (FAILED(rc))
+            {
+                /* create a IVirtualBoxErrorInfo wrapper for the native
+                 * IErrorInfo object */
+                ComObjPtr<VirtualBoxErrorInfo> wrapper;
+                rc = wrapper.createObject();
+                if (SUCCEEDED(rc))
+                {
+                    rc = wrapper->init(err);
+                    if (SUCCEEDED(rc))
+                        curInfo = wrapper;
+                }
+            }
+        }
+        /* On failure, curInfo will stay null */
+        Assert(SUCCEEDED(rc) || curInfo.isNull());
+        /* set the current error info and preserve the previous one if any */
+        if (aInfo != NULL)
+        {
+            if (curInfo.isNull())
+            {
+                info = aInfo;
+            }
+            else
+            {
+                ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
+                rc = infoObj.createObject();
+                if (FAILED(rc)) break;
+                rc = infoObj->init(aInfo, curInfo);
+                if (FAILED(rc)) break;
+                info = infoObj;
+            }
+            /* we want to return the head's result code */
+            rc = info->COMGETTER(ResultCode)(&aResultCode);
+            if (FAILED(rc)) break;
+        }
+        else
+        {
+            ComObjPtr<VirtualBoxErrorInfo> infoObj;
+            rc = infoObj.createObject();
+            if (FAILED(rc)) break;
+            rc = infoObj->init(aResultCode, aIID, aComponent, strText.c_str(), curInfo);
+            if (FAILED(rc)) break;
+            info = infoObj;
+        }
+        ComPtr<IErrorInfo> err;
+        rc = info.queryInterfaceTo(err.asOutParam());
+        if (SUCCEEDED(rc))
+            rc = ::SetErrorInfo(0, err);
+#else // !defined (VBOX_WITH_XPCOM)
+        nsCOMPtr <nsIExceptionService> es;
+        es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
+        if (NS_SUCCEEDED(rc))
+        {
+            nsCOMPtr <nsIExceptionManager> em;
+            rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
+            if (FAILED(rc)) break;
+            ComPtr<IVirtualBoxErrorInfo> curInfo;
+            if (preserve)
+            {
+                /* get the current error info if any */
+                ComPtr<nsIException> ex;
+                rc = em->GetCurrentException(ex.asOutParam());
+                if (FAILED(rc)) break;
+                rc = ex.queryInterfaceTo(curInfo.asOutParam());
+                if (FAILED(rc))
+                {
+                    /* create a IVirtualBoxErrorInfo wrapper for the native
+                     * nsIException object */
+                    ComObjPtr<VirtualBoxErrorInfo> wrapper;
+                    rc = wrapper.createObject();
+                    if (SUCCEEDED(rc))
+                    {
+                        rc = wrapper->init(ex);
+                        if (SUCCEEDED(rc))
+                            curInfo = wrapper;
+                    }
+                }
+            }
+            /* On failure, curInfo will stay null */
+            Assert(SUCCEEDED(rc) || curInfo.isNull());
+            /* set the current error info and preserve the previous one if any */
+            if (aInfo != NULL)
+            {
+                if (curInfo.isNull())
+                {
+                    info = aInfo;
+                }
+                else
+                {
+                    ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
+                    rc = infoObj.createObject();
+                    if (FAILED(rc)) break;
+                    rc = infoObj->init(aInfo, curInfo);
+                    if (FAILED(rc)) break;
+                    info = infoObj;
+                }
+                /* we want to return the head's result code */
+                PRInt32 lrc;
+                rc = info->COMGETTER(ResultCode)(&lrc); aResultCode = lrc;
+                if (FAILED(rc)) break;
+            }
+            else
+            {
+                ComObjPtr<VirtualBoxErrorInfo> infoObj;
+                rc = infoObj.createObject();
+                if (FAILED(rc)) break;
+                rc = infoObj->init(aResultCode, aIID, aComponent, strText, curInfo);
+                if (FAILED(rc)) break;
+                info = infoObj;
+            }
+            ComPtr<nsIException> ex;
+            rc = info.queryInterfaceTo(ex.asOutParam());
+            if (SUCCEEDED(rc))
+                rc = em->SetCurrentException(ex);
+        }
+        else if (rc == NS_ERROR_UNEXPECTED)
+        {
+            /*
+             *  It is possible that setError() is being called by the object
+             *  after the XPCOM shutdown sequence has been initiated
+             *  (for example, when XPCOM releases all instances it internally
+             *  references, which can cause object's FinalConstruct() and then
+             *  uninit()). In this case, do_GetService() above will return
+             *  NS_ERROR_UNEXPECTED and it doesn't actually make sense to
+             *  set the exception (nobody will be able to read it).
+             */
+            LogWarningFunc (("Will not set an exception because "
+                             "nsIExceptionService is not available "
+                             "(NS_ERROR_UNEXPECTED). "
+                             "XPCOM is being shutdown?\n"));
+            rc = NS_OK;
+        }
+#endif // !defined (VBOX_WITH_XPCOM)
+    }
+    while (0);
+    AssertComRC(rc);
+    return SUCCEEDED(rc) ? aResultCode : rc;
+}
+/* static */
+HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const GUID &aIID,
+                                       const char *aComponent, const char *aText,
+                                       ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setErrorV(aResultCode, aIID, aComponent, aText, args);
+    va_end(args);
+    return rc;
+}
+/* static */
+HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const GUID &aIID,
+                                         const char *aComponent, const char *aText,
+                                         ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setWarningV(aResultCode, aIID, aComponent, aText, args);
+    va_end(args);
+    return rc;
+}
+HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const char *aText, ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setErrorV(aResultCode, mainInterfaceID(), componentName(),
+                           aText, args);
+    va_end(args);
+    return rc;
+}
+HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const char *aText, ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setWarningV(aResultCode, mainInterfaceID(), componentName(),
+                             aText, args);
+    va_end(args);
+    return rc;
+}
+HRESULT SupportErrorInfoBase::setError(HRESULT aResultCode, const GUID &aIID,
+                                       const char *aText, ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setErrorV(aResultCode, aIID, componentName(), aText, args);
+    va_end(args);
+    return rc;
+}
+HRESULT SupportErrorInfoBase::setWarning(HRESULT aResultCode, const GUID &aIID,
+                                         const char *aText, ...)
+{
+    va_list args;
+    va_start(args, aText);
+    HRESULT rc = setWarningV(aResultCode, aIID, componentName(), aText, args);
+    va_end(args);
+    return rc;
+    return ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
+}

trunk/src/VBox/Main/idl/VirtualBox.xidl

-              r30702
+              r30714
       <desc>
         Tells VBoxSVC that <link to="IConsole::powerUp"/> has completed.
         This method may query status information from the progress object it
         received in <link to="IInternalMachineControl::beginPowerUp"/> and copy
         it over to any in progress <link to="IVirtualBox::openRemoteSession"/>
         call in order to complete that progress object.
+        This method may query status information from the progress object it
+        received in <link to="IInternalMachineControl::beginPowerUp"/> and copy
+        it over to any in progress <link to="IVirtualBox::openRemoteSession"/>
+        call in order to complete that progress object.
       </desc>
       <param name="result" type="long" dir="in"/>
 …
   </interface>
   <!--
   // ISnapshot

trunk/src/VBox/Main/idl/comimpl.xsl

-              r30627
+              r30714
   </xsl:variable>
   <xsl:value-of select="concat('      COM_INTERFACE_ENTRY(', $name, ')&#10;')" />
+  <xsl:value-of select="concat('        COM_INTERFACE_ENTRY(', $name, ')&#10;')" />
   <xsl:choose>
     <xsl:when test="$extends='$unknown'">
       <xsl:value-of select="   '      COM_INTERFACE_ENTRY(IDispatch)&#10;'" />
+      <xsl:value-of select="   '        COM_INTERFACE_ENTRY(IDispatch)&#10;'" />
     </xsl:when>
     <xsl:when test="//interface[@name=$extends]">
 …
     <xsl:value-of select="concat('    ', $mType, '    ', $mName,';&#10;')" />
     <xsl:value-of select="       'public:&#10;'" />
     <xsl:value-of select="concat('    STDMETHOD(COMGETTER(', $capsName,'))(',$pTypeNameOut,') {&#10;')" />
+    <xsl:value-of select="concat('    STDMETHOD(COMGETTER(', $capsName,'))(',$pTypeNameOut,')&#10;    {&#10;')" />
     <xsl:call-template name="genRetParam">
       <xsl:with-param name="type" select="@type" />
 …
     <xsl:if test="not(@readonly='yes')">
       <xsl:value-of select="concat('    STDMETHOD(COMSETTER(', $capsName,'))(',$pTypeNameIn,') {&#10;')" />
+      <xsl:value-of select="concat('    STDMETHOD(COMSETTER(', $capsName,'))(',$pTypeNameIn,')&#10;    {&#10;')" />
       <xsl:call-template name="genSetParam">
         <xsl:with-param name="type" select="@type" />
 …
     <xsl:value-of select="       '    // purely internal setter&#10;'" />
     <xsl:value-of select="concat('    int set_', @name,'(',$pTypeNameIn, ') {&#10;')" />
+    <xsl:value-of select="concat('    HRESULT set_', @name,'(',$pTypeNameIn, ')&#10;    {&#10;')" />
     <xsl:call-template name="genSetParam">
       <xsl:with-param name="type" select="@type" />
 …
   <xsl:value-of select="concat('class ATL_NO_VTABLE ',$implName,
                         ' : public VirtualBoxBase, VBOX_SCRIPTABLE_IMPL(',
+                        '&#10;    : public VirtualBoxBase,&#10;      VBOX_SCRIPTABLE_IMPL(',
                         @name, ')&#10;{&#10;')" />
   <xsl:value-of select="'public:&#10;'" />
+  <xsl:value-of select="concat('   DECLARE_NOT_AGGREGATABLE(', $implName, ')&#10;')" />
+  <xsl:value-of select="       '   DECLARE_PROTECT_FINAL_CONSTRUCT()&#10;'" />
+  <xsl:value-of select="concat('   BEGIN_COM_MAP(', $implName, ')&#10;')" />
+  <xsl:value-of select="concat('    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(', $implName, ', ', @name, ')&#10;')" />
+  <xsl:value-of select="concat('    DECLARE_NOT_AGGREGATABLE(', $implName, ')&#10;')" />
+  <xsl:value-of select="       '    DECLARE_PROTECT_FINAL_CONSTRUCT()&#10;'" />
+  <xsl:value-of select="concat('    BEGIN_COM_MAP(', $implName, ')&#10;')" />
   <xsl:call-template name="genComEntry">
     <xsl:with-param name="name" select="@name" />
   </xsl:call-template>
   <xsl:value-of select="       '   END_COM_MAP()&#10;'" />
   <xsl:value-of select="concat('   ', $implName, '() {}&#10;')" />
   <xsl:value-of select="concat('   virtual ~', $implName, '() {}&#10;')" />
+  <xsl:value-of select="       '    END_COM_MAP()&#10;'" />
+  <xsl:value-of select="concat('    ', $implName, '() {}&#10;')" />
+  <xsl:value-of select="concat('    virtual ~', $implName, '() {}&#10;')" />
   <xsl:text><![CDATA[
     HRESULT FinalConstruct()
 …
         return mEvent.createObject();
+    }
+    void FinalRelease() {
+    void FinalRelease()
+    {
         mEvent->FinalRelease();
+    }
 …
     <xsl:when test="$isVeto='yes'">
 <xsl:text><![CDATA[
     HRESULT init (IEventSource* aSource, VBoxEventType_T aType, BOOL aWaitable = TRUE)
+    HRESULT init(IEventSource* aSource, VBoxEventType_T aType, BOOL aWaitable = TRUE)
+    {
         NOREF(aWaitable);
 …
     <xsl:otherwise>
 <xsl:text><![CDATA[
     HRESULT init (IEventSource* aSource, VBoxEventType_T aType, BOOL aWaitable)
+    HRESULT init(IEventSource* aSource, VBoxEventType_T aType, BOOL aWaitable)
+    {
         return mEvent->init(aSource, aType, aWaitable);
 …
   <xsl:for-each select="//interface[@autogen=$G_kind]">
     <xsl:variable name="implName">
       <xsl:value-of select="concat(@name,'Impl')" />
+      <xsl:value-of select="substring(@name, 2)" />
     </xsl:variable>
     <xsl:call-template name="genSwitchCase">
 …
     <xsl:value-of select="concat('// ', @name,  ' implementation code &#10;')" />
     <xsl:variable name="implName">
       <xsl:value-of select="concat(@name,'Impl')" />
+      <xsl:value-of select="substring(@name, 2)" />
     </xsl:variable>

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

-              r29925
+              r30714
 class ATL_NO_VTABLE Appliance :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<Appliance, IAppliance>,
     public VirtualBoxSupportTranslation<Appliance>,
     VBOX_SCRIPTABLE_IMPL(IAppliance)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Appliance)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Appliance, IAppliance)
     DECLARE_NOT_AGGREGATABLE(Appliance)
 …
     HRESULT init(VirtualBox *aVirtualBox);
     void uninit();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Appliance"; }
     /* IAppliance properties */
 …
     Data *m;
     bool isApplianceIdle() const;
+    bool isApplianceIdle();
     HRESULT searchUniqueVMName(Utf8Str& aName) const;
 …
     struct LocationInfo;
     void parseURI(Utf8Str strUri, LocationInfo &locInfo) const;
     void parseBucket(Utf8Str &aPath, Utf8Str &aBucket) const;
+    void parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
     Utf8Str manifestFileName(Utf8Str aPath) const;
 …
 class ATL_NO_VTABLE VirtualSystemDescription :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<VirtualSystemDescription, IVirtualSystemDescription>,
     public VirtualBoxSupportTranslation<VirtualSystemDescription>,
     VBOX_SCRIPTABLE_IMPL(IVirtualSystemDescription)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VirtualSystemDescription)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualSystemDescription, IVirtualSystemDescription)
     DECLARE_NOT_AGGREGATABLE(VirtualSystemDescription)
 …
     HRESULT init();
     void uninit();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"VirtualSystemDescription"; }
     /* IVirtualSystemDescription properties */

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

-              r28800
+              r30714
 class ATL_NO_VTABLE AudioAdapter :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<AudioAdapter, IAudioAdapter>,
     public VirtualBoxSupportTranslation<AudioAdapter>,
     VBOX_SCRIPTABLE_IMPL(IAudioAdapter)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (AudioAdapter)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(AudioAdapter, IAudioAdapter)
     DECLARE_NOT_AGGREGATABLE(AudioAdapter)
 …
     void copyFrom(AudioAdapter *aThat);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"AudioAdapter"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE BIOSSettings :
-    public VirtualBoxSupportErrorInfoImpl<BIOSSettings, IBIOSSettings>,
     public VirtualBoxSupportTranslation<BIOSSettings>,
     public VirtualBoxBase,
 …
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(BIOSSettings, IBIOSSettings)
     DECLARE_NOT_AGGREGATABLE(BIOSSettings)
 …
     void applyDefaults (GuestOSType *aOsType);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"BIOSSettings"; }
 private:
     struct Data;

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

-              r30510
+              r30714
 class ATL_NO_VTABLE Console :
     public VirtualBoxBaseWithChildrenNEXT,
-    public VirtualBoxSupportErrorInfoImpl<Console, IConsole>,
     public VirtualBoxSupportTranslation<Console>,
     VBOX_SCRIPTABLE_IMPL(IConsole)
 …
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Console, IConsole)
     DECLARE_NOT_AGGREGATABLE(Console)
 …
     static const PDMDRVREG DrvStatusReg;
+    void reportAuthLibraryError(const char *filename, int rc)
+    {
+        setError(E_FAIL, tr("Could not load the external authentication library '%s' (%Rrc)"), filename, rc);
+    }
+    static HRESULT setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
+    HRESULT setAuthLibraryError(const char *filename, int rc);
+    HRESULT setInvalidMachineStateError();
     static HRESULT handleUnexpectedExceptions(RT_SRC_POS_DECL);
 …
     static const char *convertControllerTypeToDev(StorageControllerType_T enmCtrlType);
     static HRESULT convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Console"; }
 private:

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

-              r30627
+              r30714
 class ATL_NO_VTABLE RemoteDisplayInfo :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<RemoteDisplayInfo, IRemoteDisplayInfo>,
     public VirtualBoxSupportTranslation<RemoteDisplayInfo>,
     VBOX_SCRIPTABLE_IMPL(IRemoteDisplayInfo)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (RemoteDisplayInfo)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RemoteDisplayInfo, IRemoteDisplayInfo)
     DECLARE_NOT_AGGREGATABLE(RemoteDisplayInfo)
 …
     #undef DECL_GETTER
-    /* For VirtualBoxSupportErrorInfoImpl. */
-    static const wchar_t *getComponentName() { return L"RemoteDisplayInfo"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE DHCPServer :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<DHCPServer, IDHCPServer>,
     public VirtualBoxSupportTranslation<DHCPServer>,
     VBOX_SCRIPTABLE_IMPL(IDHCPServer)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (DHCPServer)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPServer, IDHCPServer)
     DECLARE_NOT_AGGREGATABLE (DHCPServer)
 …
     STDMETHOD(Stop)();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"DHCPServer"; }
 private:
     /** weak VirtualBox parent */

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

-              r30627
+              r30714
     public VirtualBoxBase,
     VBOX_SCRIPTABLE_IMPL(IEventListener),
-    public VirtualBoxSupportErrorInfoImpl<Display, IDisplay>,
     public VirtualBoxSupportTranslation<Display>,
     VBOX_SCRIPTABLE_IMPL(IDisplay)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Display)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Display, IDisplay)
     DECLARE_NOT_AGGREGATABLE(Display)
 …
     STDMETHOD(CompleteVHWACommand)(BYTE *pCommand);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Display"; }
     static const PDMDRVREG  DrvReg;

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

-              r30553
+              r30714
 class ATL_NO_VTABLE VBoxEvent :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<VBoxEvent, IEvent>,
     public VirtualBoxSupportTranslation<VBoxEvent>,
     VBOX_SCRIPTABLE_IMPL(IEvent)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxEvent)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxEvent, IEvent)
     DECLARE_NOT_AGGREGATABLE(VBoxEvent)
 …
     STDMETHOD(WaitProcessed)(LONG aTimeout, BOOL *aResult);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Event"; }
 private:
     struct Data;
 …
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxVetoEvent)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VBoxVetoEvent, IVetoEvent)
     DECLARE_NOT_AGGREGATABLE(VBoxVetoEvent)
 …
     STDMETHOD(GetVetos)(ComSafeArrayOut(BSTR, aVetos));
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"VetoEvent"; }
 private:
     struct Data;
 …
 class ATL_NO_VTABLE EventSource :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<EventSource, IEventSource>,
     public VirtualBoxSupportTranslation<EventSource>,
     VBOX_SCRIPTABLE_IMPL(IEventSource)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventSource)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventSource, IEventSource)
     DECLARE_NOT_AGGREGATABLE(EventSource)
 …
                               IEvent *         aEvent);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"EventSource"; }
 private:
     struct Data;

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

r28800	r30714
32	32	public:
33	33
34		VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Framebuffer)
	34	VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Framebuffer, IFramebuffer)
35	35
36	36	DECLARE_NOT_AGGREGATABLE (Framebuffer)

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

-              r30075
+              r30714
 class ATL_NO_VTABLE Guest :
-    public VirtualBoxSupportErrorInfoImpl<Guest, IGuest>,
     public VirtualBoxSupportTranslation<Guest>,
     public VirtualBoxBase,
 …
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Guest, IGuest)
     DECLARE_NOT_AGGREGATABLE(Guest)
 …
     HRESULT SetStatistic(ULONG aCpuId, GUESTSTATTYPE enmType, ULONG aVal);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Guest"; }
 # ifdef VBOX_WITH_GUEST_CONTROL
     /** Static callback for handling guest notifications. */
 …
+    {
         eVBoxGuestCtrlCallbackType  mType;
         /** Pointer to user-supplied data. */
+        /** Pointer to user-supplied data. */
         void                       *pvData;
         /** Size of user-supplied data. */

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

-              r28826
+              r30714
 class ATL_NO_VTABLE GuestOSType :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<GuestOSType, IGuestOSType>,
     public VirtualBoxSupportTranslation<GuestOSType>,
     VBOX_SCRIPTABLE_IMPL(IGuestOSType)
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (GuestOSType)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestOSType, IGuestOSType)
     DECLARE_NOT_AGGREGATABLE(GuestOSType)
 …
     uint32_t numSerialEnabled() const { return mNumSerialEnabled; }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"GuestOSType"; }
 private:

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

-              r29615
+              r30714
 class ATL_NO_VTABLE Host :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<Host, IHost>,
     public VirtualBoxSupportTranslation<Host>,
     VBOX_SCRIPTABLE_IMPL(IHost)
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Host, IHost)
     DECLARE_NOT_AGGREGATABLE(Host)
 …
     /**
-     * Simple run-time type identification without having to enable C++ RTTI.
-     * The class IDs are defined in VirtualBoxBase.h.
-     * @return
-     */
-    virtual VBoxClsID getClassID() const
+    {
-        return clsidHost;
+    }
-    /**
      * Override of the default locking class to be used for validating lock
      * order with the standard member lock handle.
 …
 #endif /* !VBOX_WITH_USB */
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Host"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE HostNetworkInterface :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<HostNetworkInterface, IHostNetworkInterface>,
     public VirtualBoxSupportTranslation<HostNetworkInterface>,
     VBOX_SCRIPTABLE_IMPL(IHostNetworkInterface)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (HostNetworkInterface)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostNetworkInterface, IHostNetworkInterface)
     DECLARE_NOT_AGGREGATABLE (HostNetworkInterface)
 …
     STDMETHOD(DhcpRediscover) ();
+    // for VirtualBoxSupportErrorInfoImpl
+    static const wchar_t *getComponentName() { return L"HostNetworkInterface"; }
+    HRESULT setVirtualBox(VirtualBox *pVBox);
-    HRESULT setVirtualBox(VirtualBox *pVBox);
 private:
     const Bstr mInterfaceName;

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

-              r28909
+              r30714
 class ATL_NO_VTABLE Keyboard :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<Keyboard, IKeyboard>,
     public VirtualBoxSupportTranslation<Keyboard>,
     VBOX_SCRIPTABLE_IMPL(IKeyboard)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Keyboard)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Keyboard, IKeyboard)
     DECLARE_NOT_AGGREGATABLE(Keyboard)
 …
                             ULONG *codesStored);
     STDMETHOD(PutCAD)();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Keyboard"; }
     static const PDMDRVREG  DrvReg;

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

-              r28800
+              r30714
 class ATL_NO_VTABLE MachineDebugger :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<MachineDebugger, IMachineDebugger>,
     public VirtualBoxSupportTranslation<MachineDebugger>,
     VBOX_SCRIPTABLE_IMPL(IMachineDebugger)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (MachineDebugger)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (MachineDebugger, IMachineDebugger)
     DECLARE_NOT_AGGREGATABLE (MachineDebugger)
 …
     void flushQueuedSettings();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"MachineDebugger"; }
 private:
     // private methods

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

-              r30380
+              r30714
 class ATL_NO_VTABLE Machine :
     public VirtualBoxBaseWithChildrenNEXT,
-    public VirtualBoxSupportErrorInfoImpl<Machine, IMachine>,
     public VirtualBoxSupportTranslation<Machine>,
     VBOX_SCRIPTABLE_IMPL(IMachine)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine, IMachine)
     DECLARE_NOT_AGGREGATABLE(Machine)
 …
     // public methods only for internal purposes
     /**
      * Simple run-time type identification without having to enable C++ RTTI.
      * The class IDs are defined in VirtualBoxBase.h.
      * @return
+     */
     virtual VBoxClsID getClassID() const
+    {
         return clsidMachine;
+    virtual bool isSnapshotMachine() const
+    {
+        return false;
+    }
+    virtual bool isSessionMachine() const
+    {
+        return false;
+    }
 …
                                BOOL *aRegistered = NULL);
     void releaseStateDependency();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Machine"; }
 protected:
 …
     // public methods only for internal purposes
+    /**
+     * Simple run-time type identification without having to enable C++ RTTI.
+     * The class IDs are defined in VirtualBoxBase.h.
+     * @return
+     */
+    virtual VBoxClsID getClassID() const
+    {
+        return clsidSessionMachine;
+    virtual bool isSessionMachine() const
+    {
+        return true;
+    }
 …
     // public methods only for internal purposes
+    /**
+     * Simple run-time type identification without having to enable C++ RTTI.
+     * The class IDs are defined in VirtualBoxBase.h.
+     * @return
+     */
+    virtual VBoxClsID getClassID() const
+    {
+        return clsidSnapshotMachine;
+    virtual bool isSnapshotMachine() const
+    {
+        return true;
+    }
 …
 inline const Guid &Machine::getSnapshotId() const
+{
     return getClassID() != clsidSnapshotMachine
                 ? Guid::Empty
                 : static_cast<const SnapshotMachine*>(this)->getSnapshotId();
+    return (isSnapshotMachine())
+                ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
+                : Guid::Empty;
+}

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

-              r28800
+              r30714
 class ATL_NO_VTABLE MediumAttachment :
     public VirtualBoxBase,
-    public com::SupportErrorInfoImpl<MediumAttachment, IMediumAttachment>,
     public VirtualBoxSupportTranslation<MediumAttachment>,
     VBOX_SCRIPTABLE_IMPL(IMediumAttachment)
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumAttachment, IMediumAttachment)
     DECLARE_NOT_AGGREGATABLE(MediumAttachment)
 …
     const char* getLogName(void) const { return mLogName.c_str(); }
-    /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "MediumAttachment"; }
 private:
     struct Data;

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

-              r28800
+              r30714
 class ATL_NO_VTABLE MediumFormat :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<MediumFormat, IMediumFormat>,
     public VirtualBoxSupportTranslation<MediumFormat>,
     VBOX_SCRIPTABLE_IMPL(IMediumFormat)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (MediumFormat)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumFormat, IMediumFormat)
     DECLARE_NOT_AGGREGATABLE (MediumFormat)
 …
     const PropertyList &properties() const { return m.properties; }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"MediumFormat"; }
 private:

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

-              r29325
+              r30714
 class ATL_NO_VTABLE Medium :
     public VirtualBoxBase,
-    public com::SupportErrorInfoImpl<Medium, IMedium>,
     public VirtualBoxSupportTranslation<Medium>,
     VBOX_SCRIPTABLE_IMPL(IMedium)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Medium)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Medium, IMedium)
     DECLARE_NOT_AGGREGATABLE(Medium)
 …
     Bstr preferredDiffFormat();
-    /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "Medium"; }
 private:

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

-              r28800
+              r30714
 #ifndef VBOXBFE_WITHOUT_COM
+    ,
-    public VirtualBoxSupportErrorInfoImpl<Mouse, IMouse>,
     public VirtualBoxSupportTranslation<Mouse>,
     VBOX_SCRIPTABLE_IMPL(IMouse)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Mouse)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Mouse, IMouse)
     DECLARE_NOT_AGGREGATABLE(Mouse)
 …
     STDMETHOD(PutMouseEventAbsolute)(LONG x, LONG y, LONG dz, LONG dw,
                                      LONG buttonState);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Mouse"; }
     static const PDMDRVREG  DrvReg;

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

-              r28864
+              r30714
 class ATL_NO_VTABLE NATEngine :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<NATEngine, INATEngine>,
     public VirtualBoxSupportTranslation<NATEngine>,
     VBOX_SCRIPTABLE_IMPL(INATEngine)
 …
         ULONG    mAliasMode;
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (NATEngine)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NATEngine, INATEngine)
     DECLARE_NOT_AGGREGATABLE(NATEngine)
 …
     STDMETHOD(RemoveRedirect)(IN_BSTR aName);
-    static const wchar_t *getComponentName() { return L"NATEngine"; }
 private:
     Backupable<Data> mData;

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

-              r28867
+              r30714
 class ATL_NO_VTABLE NetworkAdapter :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<NetworkAdapter, INetworkAdapter>,
     public VirtualBoxSupportTranslation<NetworkAdapter>,
     VBOX_SCRIPTABLE_IMPL(INetworkAdapter)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (NetworkAdapter)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NetworkAdapter, INetworkAdapter)
     DECLARE_NOT_AGGREGATABLE(NetworkAdapter)
 …
     void applyDefaults (GuestOSType *aOsType);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"NetworkAdapter"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE ParallelPort :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<ParallelPort, IParallelPort>,
     public VirtualBoxSupportTranslation<ParallelPort>,
     VBOX_SCRIPTABLE_IMPL(IParallelPort)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (ParallelPort)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ParallelPort, IParallelPort)
     DECLARE_NOT_AGGREGATABLE(ParallelPort)
 …
     // (ensure there is a caller and a read lock before calling them!)
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"ParallelPort"; }
 private:
     HRESULT checkSetPath(const Utf8Str &str);

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

-              r28800
+              r30714
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PerformanceMetric, IPerformanceMetric)
     DECLARE_NOT_AGGREGATABLE (PerformanceMetric)
 …
 class ATL_NO_VTABLE PerformanceCollector :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<PerformanceCollector, IPerformanceCollector>,
     public VirtualBoxSupportTranslation<PerformanceCollector>,
     VBOX_SCRIPTABLE_IMPL(IPerformanceCollector)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (PerformanceCollector)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PerformanceCollector, IPerformanceCollector)
     DECLARE_NOT_AGGREGATABLE (PerformanceCollector)
 …
     pm::CollectorHAL *getHAL() { return m.hal; };
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"PerformanceCollector"; }
 private:
     HRESULT toIPerformanceMetric(pm::Metric *src, IPerformanceMetric **dst);

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

-              r29923
+              r30714
  */
 class ATL_NO_VTABLE CombinedProgress :
+    public com::SupportErrorInfoDerived<ProgressBase, CombinedProgress, IProgress>,
+//     public com::SupportErrorInfoDerived<ProgressBase, CombinedProgress, IProgress>,
+    public Progress,
     public VirtualBoxSupportTranslation<CombinedProgress>
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CombinedProgress, IProgress)
     VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (CombinedProgress)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(CombinedProgress)
     DECLARE_NOT_AGGREGATABLE (CombinedProgress)
+    DECLARE_NOT_AGGREGATABLE(CombinedProgress)
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 …
     // public methods only for internal purposes
-    /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "CombinedProgress"; }
 private:

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

-              r29916
+              r30714
 class ATL_NO_VTABLE ProgressBase :
     public VirtualBoxBase,
-    public com::SupportErrorInfoBase,
     public VirtualBoxSupportTranslation<ProgressBase>,
     VBOX_SCRIPTABLE_IMPL(IProgress)
 …
 protected:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (ProgressBase)
+//  VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProgressBase, IProgress)
+//  cannot be added here or Windows will not buuld; as a result, ProgressBase cannot be
+//  instantiated, but we're not doing that anyway (but only its children)
     DECLARE_EMPTY_CTOR_DTOR (ProgressBase)
 …
     // public methods only for internal purposes
-    static HRESULT setErrorInfoOnThread (IProgress *aProgress);
     bool setCancelCallback(void (*pfnCallback)(void *), void *pvUser);
 …
  */
 class ATL_NO_VTABLE Progress :
     public com::SupportErrorInfoDerived<ProgressBase, Progress, IProgress>,
+    public ProgressBase,
     public VirtualBoxSupportTranslation<Progress>
+{
 public:
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (Progress)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Progress, IProgress)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(Progress)
     DECLARE_NOT_AGGREGATABLE (Progress)
 …
     HRESULT notifyComplete(HRESULT aResultCode,
                            const GUID &aIID,
                            const Bstr &aComponent,
+                           const char *pcszComponent,
                            const char *aText,
                            ...);
     HRESULT notifyCompleteV(HRESULT aResultCode,
                             const GUID &aIID,
                             const Bstr &aComponent,
+                            const char *pcszComponent,
                             const char *aText,
                             va_list va);
     bool notifyPointOfNoReturn(void);
-    /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "Progress"; }
 private:

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

-              r29937
+              r30714
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProgressProxy, IProgress)
     VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(ProgressProxy)
     DECLARE_NOT_AGGREGATABLE(ProgressProxy)
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 …
     HRESULT notifyComplete(HRESULT aResultCode,
                            const GUID &aIID,
                            const Bstr &aComponent,
+                           const char *pcszComponent,
                            const char *aText, ...);
     bool    setOtherProgressObject(IProgress *pOtherProgress);
+    bool setOtherProgressObject(IProgress *pOtherProgress);
     /** For com::SupportErrorInfoImpl. */

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

-              r28800
+              r30714
 class ATL_NO_VTABLE RemoteUSBDevice :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<RemoteUSBDevice, IHostUSBDevice>,
     public VirtualBoxSupportTranslation<RemoteUSBDevice>,
     VBOX_SCRIPTABLE_IMPL(IHostUSBDevice)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (OUSBDevice)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RemoteUSBDevice, IHostUSBDevice)
     DECLARE_NOT_AGGREGATABLE (RemoteUSBDevice)
 …
+    }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"RemoteUSBDevice"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE SerialPort :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<SerialPort, ISerialPort>,
     public VirtualBoxSupportTranslation<SerialPort>,
     VBOX_SCRIPTABLE_IMPL(ISerialPort)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (SerialPort)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SerialPort, ISerialPort)
     DECLARE_NOT_AGGREGATABLE(SerialPort)
 …
     // (ensure there is a caller and a read lock before calling them!)
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"SerialPort"; }
 private:
     HRESULT checkSetPath(const Utf8Str &str);

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

-              r29363
+              r30714
  *  Use SYS V IPC for watching a session.
  *  This is defined in the Makefile since it's also used by MachineImpl.h/cpp.
+ *
- *  @todo Dmitry, feel free to completely change this (and/or write a better description).
- *        (The same goes for the other darwin changes.)
  */
 #ifdef DOXYGEN_RUNNING
 …
 class ATL_NO_VTABLE Session :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<Session, ISession>,
     public VirtualBoxSupportTranslation<Session>,
     VBOX_SCRIPTABLE_IMPL(ISession),
 …
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Session, ISession)
     DECLARE_CLASSFACTORY()
 …
                                  IProgress *aProgress);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Session"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE SharedFolder :
     public VirtualBoxBaseWithChildrenNEXT,
-    public VirtualBoxSupportErrorInfoImpl<SharedFolder, ISharedFolder>,
     public VirtualBoxSupportTranslation<SharedFolder>,
     VBOX_SCRIPTABLE_IMPL(ISharedFolder)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (SharedFolder)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SharedFolder, ISharedFolder)
     DECLARE_NOT_AGGREGATABLE(SharedFolder)
 …
     BOOL isWritable() const { return m.writable; }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"SharedFolder"; }
 protected:

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

-              r28835
+              r30714
 class ATL_NO_VTABLE Snapshot :
-    public VirtualBoxSupportErrorInfoImpl<Snapshot, ISnapshot>,
     public VirtualBoxSupportTranslation<Snapshot>,
     public VirtualBoxBase, // WithTypedChildren<Snapshot>,
 …
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Snapshot, ISnapshot)
     DECLARE_NOT_AGGREGATABLE(Snapshot)
 …
     /**
-     * Simple run-time type identification without having to enable C++ RTTI.
-     * The class IDs are defined in VirtualBoxBase.h.
-     * @return
-     */
-    virtual VBoxClsID getClassID() const
+    {
-        return clsidSnapshot;
+    }
-    /**
      * Override of the default locking class to be used for validating lock
      * order with the standard member lock handle.
 …
     HRESULT saveSnapshotImpl(settings::Snapshot &data, bool aAttrsOnly);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName()
+    {
-        return L"Snapshot";
+    }
 private:
     struct Data;            // opaque, defined in SnapshotImpl.cpp

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

-              r29480
+              r30714
 class ATL_NO_VTABLE StorageController :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<StorageController, IStorageController>,
     public VirtualBoxSupportTranslation<StorageController>,
     VBOX_SCRIPTABLE_IMPL(IStorageController)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (StorageController)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(StorageController, IStorageController)
     DECLARE_NOT_AGGREGATABLE (StorageController)
 …
     ComObjPtr<StorageController> getPeer();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"StorageController"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE SystemProperties :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<SystemProperties, ISystemProperties>,
     public VirtualBoxSupportTranslation<SystemProperties>,
     VBOX_SCRIPTABLE_IMPL(ISystemProperties)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (SystemProperties)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (SystemProperties, ISystemProperties)
     DECLARE_NOT_AGGREGATABLE(SystemProperties)
 …
     // (ensure there is a caller and a read lock before calling them!)
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"SystemProperties"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE USBController :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<USBController, IUSBController>,
     public VirtualBoxSupportTranslation<USBController>,
     VBOX_SCRIPTABLE_IMPL(IUSBController)
+{
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (USBController)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBController, IUSBController)
     DECLARE_NOT_AGGREGATABLE (USBController)
 …
     Machine* getMachine();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"USBController"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE OUSBDevice :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<OUSBDevice, IUSBDevice>,
     public VirtualBoxSupportTranslation<OUSBDevice>,
     VBOX_SCRIPTABLE_IMPL(IUSBDevice)
 …
 public:
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (OUSBDevice)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(OUSBDevice, IUSBDevice)
     DECLARE_NOT_AGGREGATABLE(OUSBDevice)
 …
     // public methods only for internal purposes
     const Guid &id() const { return mData.id; }
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"USBDevice"; }
 private:

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

-              r28800
+              r30714
 class ATL_NO_VTABLE VFSExplorer :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<VFSExplorer, IVFSExplorer>,
     public VirtualBoxSupportTranslation<VFSExplorer>,
     VBOX_SCRIPTABLE_IMPL(IVFSExplorer)
+{
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VFSExplorer)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VFSExplorer, IVFSExplorer)
     DECLARE_NOT_AGGREGATABLE(VFSExplorer)
 …
     HRESULT init(VFSType_T aType, Utf8Str aFilePath, Utf8Str aHostname, Utf8Str aUsername, Utf8Str aPassword, VirtualBox *aVirtualBox);
     void uninit();
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"VFSExplorer"; }
     /* IVFSExplorer properties */

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

-              r28802
+              r30714
 class ATL_NO_VTABLE VRDPServer :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<VRDPServer, IVRDPServer>,
     public VirtualBoxSupportTranslation<VRDPServer>,
     VBOX_SCRIPTABLE_IMPL(IVRDPServer)
 …
     };
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VRDPServer)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VRDPServer, IVRDPServer)
     DECLARE_NOT_AGGREGATABLE(VRDPServer)
 …
     void copyFrom (VRDPServer *aThat);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"VRDPServer"; }
 private:

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

-              r29386
+              r30714
     do { \
         if (RT_UNLIKELY(!(expr))) \
+            setError(E_FAIL, "Assertion failed: [%s] at '%s' (%d) in %s.\n" \
+                             "Please contact the product vendor!", \
+                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
+            setErrorInternal(E_FAIL, \
+                             getStaticClassIID(), \
+                             getStaticComponentName(), \
+                             Utf8StrFmt("Assertion failed: [%s] at '%s' (%d) in %s.\nPlease contact the product vendor!", \
+                                        #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__), \
+                             false, true); \
     } while (0)
 #endif
 …
     do { \
         if (RT_UNLIKELY(!(expr))) \
+            setError(E_FAIL, "Assertion failed: [%s] at '%s' (%d) in %s.\n" \
+                             "%s.\n" \
+                             "Please contact the product vendor!", \
+                     #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__, Utf8StrFmt a .raw()); \
+            setErrorInternal(E_FAIL, \
+                             getStaticClassIID(), \
+                             getStaticComponentName(), \
+                             Utf8StrFmt("Assertion failed: [%s] at '%s' (%d) in %s.\n%s.\nPlease contact the product vendor!", \
+                                        #expr, __FILE__, __LINE__, __PRETTY_FUNCTION__), \
+                             false, true); \
     } while (0)
 #endif
 …
         if (RT_UNLIKELY(ComSafeArrayOutIsNull(arg))) \
             return setError(E_POINTER, \
                 tr("Output argument %s points to invalid memory location (%p)"), \
                 #arg, (void *) (arg)); \
+                            tr("Output argument %s points to invalid memory location (%p)"), \
+                            #arg, (void*)(arg)); \
     } while (0)
 …
 ////////////////////////////////////////////////////////////////////////////////
+/**
+ * This enum is used in the virtual method VirtualBoxBasePro::getClassID() to
+ * allow VirtualBox classes to identify themselves. Subclasses can override
+ * that method and return a value from this enum if run-time identification is
+ * needed anywhere.
+ */
+enum VBoxClsID
+{
+    clsidVirtualBox,
+    clsidHost,
+    clsidMachine,
+    clsidSessionMachine,
+    clsidSnapshotMachine,
+    clsidSnapshot,
+    clsidOther
+};
+#define VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface) \
+    virtual const IID& getClassIID() const \
+    { \
+        return cls::getStaticClassIID(); \
+    } \
+    static const IID& getStaticClassIID() \
+    { \
+        return COM_IIDOF(iface); \
+    } \
+    virtual const char* getComponentName() const \
+    { \
+        return cls::getStaticComponentName(); \
+    } \
+    static const char* getStaticComponentName() \
+    { \
+        return #cls; \
+    }
+/**
+ * VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT:
+ * This macro must be used once in the declaration of any class derived
+ * from VirtualBoxBase. It implements the pure virtual getClassIID() and
+ * getComponentName() methods. If this macro is not present, instances
+ * of a class derived from VirtualBoxBase cannot be instantiated.
+ *
+ * @param X The class name, e.g. "Class".
+ * @param IX The interface name which this class implements, e.g. "IClass".
+ */
+#ifdef VBOX_WITH_XPCOM
+  #define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls, iface) \
+    VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface)
+#else // #ifdef VBOX_WITH_XPCOM
+  #define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(cls, iface) \
+    VIRTUALBOXBASE_ADD_VIRTUAL_COMPONENT_METHODS(cls, iface) \
+    STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid) \
+    { \
+        const _ATL_INTMAP_ENTRY* pEntries = cls::_GetEntries(); \
+        Assert(pEntries); \
+        if (!pEntries) \
+            return S_FALSE; \
+        BOOL bSupports = FALSE; \
+        BOOL bISupportErrorInfoFound = FALSE; \
+        while (pEntries->pFunc != NULL && !bSupports) \
+        { \
+            if (!bISupportErrorInfoFound) \
+                bISupportErrorInfoFound = InlineIsEqualGUID(*(pEntries->piid), IID_ISupportErrorInfo); \
+            else \
+                bSupports = InlineIsEqualGUID(*(pEntries->piid), riid); \
+            pEntries++; \
+        } \
+        Assert(bISupportErrorInfoFound); \
+        return bSupports ? S_OK : S_FALSE; \
+    }
+#endif // #ifdef VBOX_WITH_XPCOM
 /**
 …
+ *
  * Declares functionality that should be available in all components.
+ *
- * Note that this class is always subclassed using the virtual keyword so
- * that only one instance of its VTBL and data is present in each derived class
- * even in case if VirtualBoxBaseProto appears more than once among base classes
- * of the particular component as a result of multiple inheritance.
+ *
- * This makes it possible to have intermediate base classes used by several
- * components that implement some common interface functionality but still let
- * the final component classes choose what VirtualBoxBase variant it wants to
- * use.
+ *
  * Among the basic functionality implemented by this class is the primary object
 …
     : public Lockable,
       public CComObjectRootEx<CComMultiThreadModel>
+#if !defined (VBOX_WITH_XPCOM)
+    , public ISupportErrorInfo
+#endif
+{
 public:
 …
     static const char *translate(const char *context, const char *sourceText,
                                  const char *comment = 0);
-public:
     /**
 …
     virtual void uninit() {}
+    virtual HRESULT addCaller(State *aState = NULL, bool aLimited = false);
+    virtual HRESULT addCaller(State *aState = NULL,
+                              bool aLimited = false);
     virtual void releaseCaller();
 …
     /**
+     * Simple run-time type identification without having to enable C++ RTTI.
+     * The class IDs are defined in VirtualBoxBase.h.
+     * @return
+     */
+    virtual VBoxClsID getClassID() const
+    {
+        return clsidOther;
+    }
+    /**
+     * Override of the default locking class to be used for validating lock
+     * order with the standard member lock handle.
+     * Pure virtual method for simple run-time type identification without
+     * having to enable C++ RTTI.
+     *
+     * This *must* be implemented by every subclass deriving from VirtualBoxBase;
+     * use the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro to do that most easily.
+     */
+    virtual const IID& getClassIID() const = 0;
+    /**
+     * Pure virtual method for simple run-time type identification without
+     * having to enable C++ RTTI.
+     *
+     * This *must* be implemented by every subclass deriving from VirtualBoxBase;
+     * use the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro to do that most easily.
+     */
+    virtual const char* getComponentName() const = 0;
+    /**
+     * Virtual method which determins the locking class to be used for validating
+     * lock order with the standard member lock handle. This method is overridden
+     * in a number of subclasses.
      */
     virtual VBoxLockingClass getLockingClass() const
 …
      */
     WriteLockHandle *stateLockHandle() { return &mStateLock; }
+    static HRESULT setErrorInternal(HRESULT aResultCode,
+                                    const GUID &aIID,
+                                    const char *aComponent,
+                                    const Utf8Str &aText,
+                                    bool aWarning,
+                                    bool aLogIt);
+    HRESULT setError(HRESULT aResultCode, const char *pcsz, ...);
+    HRESULT setWarning(HRESULT aResultCode, const char *pcsz, ...);
+    HRESULT setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...);
 private:
 …
 ////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxSupportTranslation, VirtualBoxSupportErrorInfoImpl
-//
-////////////////////////////////////////////////////////////////////////////////
-/**
- *  This macro adds the error info support to methods of the VirtualBoxBase
- *  class (by overriding them). Place it to the public section of the
- *  VirtualBoxBase subclass and the following methods will set the extended
- *  error info in case of failure instead of just returning the result code:
+ *
- *  <ul>
- *      <li>VirtualBoxBase::addCaller()
- *  </ul>
+ *
- *  @note The given VirtualBoxBase subclass must also inherit from both
- *  VirtualBoxSupportErrorInfoImpl and VirtualBoxSupportTranslation templates!
+ *
- *  @param C    VirtualBoxBase subclass to add the error info support to
- */
-#define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(C) \
-    virtual HRESULT addCaller(VirtualBoxBase::State *aState = NULL, \
-                              bool aLimited = false) \
-    { \
-        VirtualBoxBase::State protoState; \
-        HRESULT rc = VirtualBoxBase::addCaller(&protoState, aLimited); \
-        if (FAILED(rc)) \
-        { \
-            if (protoState == VirtualBoxBase::Limited) \
-                rc = setError(rc, tr("The object functionality is limited")); \
-            else \
-                rc = setError(rc, tr("The object is not ready")); \
-        } \
-        if (aState) \
-            *aState = protoState; \
-        return rc; \
-    } \
-////////////////////////////////////////////////////////////////////////////////
 /** Helper for VirtualBoxSupportTranslation. */
 …
 ////////////////////////////////////////////////////////////////////////////////
-/**
- *  Helper for the VirtualBoxSupportErrorInfoImpl template.
- */
-/// @todo switch to com::SupportErrorInfo* and remove
-class VirtualBoxSupportErrorInfoImplBase
+{
-    static HRESULT setErrorInternal(HRESULT aResultCode,
-                                    const GUID &aIID,
-                                    const wchar_t *aComponent,
-                                    const Bstr &aText,
-                                    bool aWarning,
-                                    bool aLogIt);
-protected:
-    /**
-     * The MultiResult class is a com::FWResult enhancement that also acts as a
-     * switch to turn on multi-error mode for #setError() or #setWarning()
-     * calls.
+     *
-     * When an instance of this class is created, multi-error mode is turned on
-     * for the current thread and the turn-on counter is increased by one. In
-     * multi-error mode, a call to #setError() or #setWarning() does not
-     * overwrite the current error or warning info object possibly set on the
-     * current thread by other method calls, but instead it stores this old
-     * object in the IVirtualBoxErrorInfo::next attribute of the new error
-     * object being set.
+     *
-     * This way, error/warning objects are stacked together and form a chain of
-     * errors where the most recent error is the first one retrieved by the
-     * calling party, the preceding error is what the
-     * IVirtualBoxErrorInfo::next attribute of the first error points to, and so
-     * on, up to the first error or warning occurred which is the last in the
-     * chain. See IVirtualBoxErrorInfo documentation for more info.
+     *
-     * When the instance of the MultiResult class goes out of scope and gets
-     * destroyed, it automatically decreases the turn-on counter by one. If
-     * the counter drops to zero, multi-error mode for the current thread is
-     * turned off and the thread switches back to single-error mode where every
-     * next error or warning object overwrites the previous one.
+     *
-     * Note that the caller of a COM method uses a non-S_OK result code to
-     * decide if the method has returned an error (negative codes) or a warning
-     * (positive non-zero codes) and will query extended error info only in
-     * these two cases. However, since multi-error mode implies that the method
-     * doesn't return control return to the caller immediately after the first
-     * error or warning but continues its execution, the functionality provided
-     * by the base com::FWResult class becomes very useful because it allows to
-     * preserve the error or the warning result code even if it is later assigned
-     * a S_OK value multiple times. See com::FWResult for details.
+     *
-     * Here is the typical usage pattern:
-     *  <code>
-        HRESULT Bar::method()
+        {
-            // assume multi-errors are turned off here...
-            if (something)
+            {
-                // Turn on multi-error mode and make sure severity is preserved
-                MultiResult rc = foo->method1();
-                // return on fatal error, but continue on warning or on success
-                if (FAILED(rc)) return rc;
-                rc = foo->method2();
-                // no matter what result, stack it and continue
-                // ...
-                // return the last worst result code (it will be preserved even if
-                // foo->method2() returns S_OK.
-                return rc;
+            }
-            // multi-errors are turned off here again...
-            return S_OK;
+        }
-     *  </code>
+     *
+     *
-     * @note This class is intended to be instantiated on the stack, therefore
-     *       You cannot create them using new(). Although it is possible to copy
-     *       instances of MultiResult or return them by value, please never do
-     *       that as it is breaks the class semantics (and will assert).
-     */
-    class MultiResult : public com::FWResult
+    {
-    public:
-        /**
-         * @copydoc com::FWResult::FWResult().
-         */
-        MultiResult(HRESULT aRC = E_FAIL) : FWResult(aRC) { init(); }
-        MultiResult(const MultiResult &aThat) : FWResult(aThat)
+        {
-            /* We need this copy constructor only for GCC that wants to have
-             * it in case of expressions like |MultiResult rc = E_FAIL;|. But
-             * we assert since the optimizer should actually avoid the
-             * temporary and call the other constructor directly instead. */
-            AssertFailed();
-            init();
+        }
-        ~MultiResult();
-        MultiResult &operator=(HRESULT aRC)
+        {
-            com::FWResult::operator=(aRC);
-            return *this;
+        }
-        MultiResult &operator=(const MultiResult &aThat)
+        {
-            /* We need this copy constructor only for GCC that wants to have
-             * it in case of expressions like |MultiResult rc = E_FAIL;|. But
-             * we assert since the optimizer should actually avoid the
-             * temporary and call the other constructor directly instead. */
-            AssertFailed();
-            com::FWResult::operator=(aThat);
-            return *this;
+        }
-    private:
-        DECLARE_CLS_NEW_DELETE_NOOP(MultiResult)
-        void init();
-        static RTTLS sCounter;
-        friend class VirtualBoxSupportErrorInfoImplBase;
-    };
-    static HRESULT setError(HRESULT aResultCode,
-                            const GUID &aIID,
-                            const wchar_t *aComponent,
-                            const Bstr &aText,
-                            bool aLogIt = true)
+    {
-        return setErrorInternal(aResultCode, aIID, aComponent, aText,
-                                false /* aWarning */, aLogIt);
+    }
-    static HRESULT setWarning(HRESULT aResultCode,
-                              const GUID &aIID,
-                              const wchar_t *aComponent,
-                              const Bstr &aText)
+    {
-        return setErrorInternal(aResultCode, aIID, aComponent, aText,
-                                true /* aWarning */, true /* aLogIt */);
+    }
-    static HRESULT setError(HRESULT aResultCode,
-                            const GUID &aIID,
-                            const wchar_t *aComponent,
-                            const char *aText, va_list aArgs, bool aLogIt = true)
+    {
-        return setErrorInternal(aResultCode, aIID, aComponent,
-                                Utf8StrFmtVA (aText, aArgs),
-                                false /* aWarning */, aLogIt);
+    }
-    static HRESULT setWarning(HRESULT aResultCode,
-                              const GUID &aIID,
-                              const wchar_t *aComponent,
-                              const char *aText, va_list aArgs)
+    {
-        return setErrorInternal(aResultCode, aIID, aComponent,
-                                Utf8StrFmtVA (aText, aArgs),
-                                true /* aWarning */, true /* aLogIt */);
+    }
-};
-/**
- *  This template implements ISupportErrorInfo for the given component class
- *  and provides the #setError() method to conveniently set the error information
- *  from within interface methods' implementations.
+ *
- *  On Windows, the template argument must define a COM interface map using
- *  BEGIN_COM_MAP / END_COM_MAP macros and this map must contain a
- *  COM_INTERFACE_ENTRY(ISupportErrorInfo) definition. All interface entries
- *  that follow it will be considered to support IErrorInfo, i.e. the
- *  InterfaceSupportsErrorInfo() implementation will return S_OK for the
- *  corresponding IID.
+ *
- *  On all platforms, the template argument must also define the following
- *  method: |public static const wchar_t *C::getComponentName()|. See
- *  #setError(HRESULT, const char *, ...) for a description on how it is
- *  used.
+ *
- *  @param C
- *      component class that implements one or more COM interfaces
- *  @param I
- *      default interface for the component. This interface's IID is used
- *      by the shortest form of #setError, for convenience.
- */
-/// @todo switch to com::SupportErrorInfo* and remove
-template<class C, class I>
-class ATL_NO_VTABLE VirtualBoxSupportErrorInfoImpl
-    : protected VirtualBoxSupportErrorInfoImplBase
-#if !defined (VBOX_WITH_XPCOM)
-    , public ISupportErrorInfo
-#else
-#endif
+{
-public:
-#if !defined (VBOX_WITH_XPCOM)
-    STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid)
+    {
-        const _ATL_INTMAP_ENTRY* pEntries = C::_GetEntries();
-        Assert(pEntries);
-        if (!pEntries)
-            return S_FALSE;
-        BOOL bSupports = FALSE;
-        BOOL bISupportErrorInfoFound = FALSE;
-        while (pEntries->pFunc != NULL && !bSupports)
+        {
-            if (!bISupportErrorInfoFound)
+            {
-                // skip the com map entries until ISupportErrorInfo is found
-                bISupportErrorInfoFound =
-                    InlineIsEqualGUID(*(pEntries->piid), IID_ISupportErrorInfo);
+            }
-            else
+            {
-                // look for the requested interface in the rest of the com map
-                bSupports = InlineIsEqualGUID(*(pEntries->piid), riid);
+            }
-            pEntries++;
+        }
-        Assert(bISupportErrorInfoFound);
-        return bSupports ? S_OK : S_FALSE;
+    }
-#endif // !defined (VBOX_WITH_XPCOM)
-protected:
-    /**
-     *  Sets the error information for the current thread.
-     *  This information can be retrieved by a caller of an interface method
-     *  using IErrorInfo on Windows or nsIException on Linux, or the cross-platform
-     *  IVirtualBoxErrorInfo interface that provides extended error info (only
-     *  for components from the VirtualBox COM library). Alternatively, the
-     *  platform-independent class com::ErrorInfo (defined in VBox[XP]COM.lib)
-     *  can be used to retrieve error info in a convenient way.
+     *
-     *  It is assumed that the interface method that uses this function returns
-     *  an unsuccessful result code to the caller (otherwise, there is no reason
-     *  for the caller to try to retrieve error info after method invocation).
+     *
-     *  Here is a table of correspondence between this method's arguments
-     *  and IErrorInfo/nsIException/IVirtualBoxErrorInfo attributes/methods:
+     *
-     *  argument    IErrorInfo      nsIException    IVirtualBoxErrorInfo
-     *  ----------------------------------------------------------------
-     *  resultCode  --              result          resultCode
-     *  iid         GetGUID         --              interfaceID
-     *  component   GetSource       --              component
-     *  text        GetDescription  message         text
+     *
-     *  This method is rarely needs to be used though. There are more convenient
-     *  overloaded versions, that automatically substitute some arguments
-     *  taking their values from the template parameters. See
-     *  #setError(HRESULT, const char *, ...) for an example.
+     *
-     *  @param  aResultCode result (error) code, must not be S_OK
-     *  @param  aIID        IID of the interface that defines the error
-     *  @param  aComponent  name of the component that generates the error
-     *  @param  aText       error message (must not be null), an RTStrPrintf-like
-     *                      format string in UTF-8 encoding
-     *  @param  ...         list of arguments for the format string
+     *
-     *  @return
-     *      the error argument, for convenience, If an error occurs while
-     *      creating error info itself, that error is returned instead of the
-     *      error argument.
-     */
-    static HRESULT setError(HRESULT aResultCode, const GUID &aIID,
-                            const wchar_t *aComponent,
-                            const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError(aResultCode,
-                                                                  aIID,
-                                                                  aComponent,
-                                                                  aText,
-                                                                  args,
-                                                                  true /* aLogIt */);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  This method is the same as #setError() except that it makes sure @a
-     *  aResultCode doesn't have the error severity bit (31) set when passed
-     *  down to the created IVirtualBoxErrorInfo object.
+     *
-     *  The error severity bit is always cleared by this call, thereof you can
-     *  use ordinary E_XXX result code constants, for convenience. However, this
-     *  behavior may be non-standard on some COM platforms.
-     */
-    static HRESULT setWarning(HRESULT aResultCode, const GUID &aIID,
-                              const wchar_t *aComponent,
-                              const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setWarning(
-            aResultCode, aIID, aComponent, aText, args);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  Sets the error information for the current thread.
-     *  A convenience method that automatically sets the default interface
-     *  ID (taken from the I template argument) and the component name
-     *  (a value of C::getComponentName()).
+     *
-     *  See #setError(HRESULT, const GUID &, const wchar_t *, const char *text, ...)
-     *  for details.
+     *
-     *  This method is the most common (and convenient) way  to set error
-     *  information from within interface methods. A typical pattern of usage
-     *  is looks like this:
+     *
-     *  <code>
-     *      return setError(E_FAIL, "Terrible Error");
-     *  </code>
-     *  or
-     *  <code>
-     *      HRESULT rc = setError(E_FAIL, "Terrible Error");
-     *      ...
-     *      return rc;
-     *  </code>
-     */
-    static HRESULT setError(HRESULT aResultCode, const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError(aResultCode,
-                                                                  COM_IIDOF(I),
-                                                                  C::getComponentName(),
-                                                                  aText,
-                                                                  args,
-                                                                  true /* aLogIt */);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  This method is the same as #setError() except that it makes sure @a
-     *  aResultCode doesn't have the error severity bit (31) set when passed
-     *  down to the created IVirtualBoxErrorInfo object.
+     *
-     *  The error severity bit is always cleared by this call, thereof you can
-     *  use ordinary E_XXX result code constants, for convenience. However, this
-     *  behavior may be non-standard on some COM platforms.
-     */
-    static HRESULT setWarning(HRESULT aResultCode, const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setWarning(aResultCode,
-                                                                    COM_IIDOF(I),
-                                                                    C::getComponentName(),
-                                                                    aText,
-                                                                    args);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  Sets the error information for the current thread, va_list variant.
-     *  A convenience method that automatically sets the default interface
-     *  ID (taken from the I template argument) and the component name
-     *  (a value of C::getComponentName()).
+     *
-     *  See #setError(HRESULT, const GUID &, const wchar_t *, const char *text, ...)
-     *  and #setError(HRESULT, const char *, ...)  for details.
-     */
-    static HRESULT setErrorV(HRESULT aResultCode, const char *aText,
-                             va_list aArgs)
+    {
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError(aResultCode,
-                                                                  COM_IIDOF(I),
-                                                                  C::getComponentName(),
-                                                                  aText,
-                                                                  aArgs,
-                                                                  true /* aLogIt */);
-        return rc;
+    }
-    /**
-     *  This method is the same as #setErrorV() except that it makes sure @a
-     *  aResultCode doesn't have the error severity bit (31) set when passed
-     *  down to the created IVirtualBoxErrorInfo object.
+     *
-     *  The error severity bit is always cleared by this call, thereof you can
-     *  use ordinary E_XXX result code constants, for convenience. However, this
-     *  behavior may be non-standard on some COM platforms.
-     */
-    static HRESULT setWarningV(HRESULT aResultCode, const char *aText,
-                               va_list aArgs)
+    {
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setWarning(aResultCode,
-                                                                    COM_IIDOF(I),
-                                                                    C::getComponentName(),
-                                                                    aText,
-                                                                    aArgs);
-        return rc;
+    }
-    /**
-     *  Sets the error information for the current thread.
-     *  A convenience method that automatically sets the component name
-     *  (a value of C::getComponentName()), but allows to specify the interface
-     *  id manually.
+     *
-     *  See #setError(HRESULT, const GUID &, const wchar_t *, const char *text, ...)
-     *  for details.
-     */
-    static HRESULT setError(HRESULT aResultCode, const GUID &aIID,
-                            const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError(aResultCode,
-                                                                  aIID,
-                                                                  C::getComponentName(),
-                                                                  aText,
-                                                                  args,
-                                                                  true /* aLogIt */);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  This method is the same as #setError() except that it makes sure @a
-     *  aResultCode doesn't have the error severity bit (31) set when passed
-     *  down to the created IVirtualBoxErrorInfo object.
+     *
-     *  The error severity bit is always cleared by this call, thereof you can
-     *  use ordinary E_XXX result code constants, for convenience. However, this
-     *  behavior may be non-standard on some COM platforms.
-     */
-    static HRESULT setWarning(HRESULT aResultCode, const GUID &aIID,
-                              const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setWarning(aResultCode,
-                                                                    aIID,
-                                                                    C::getComponentName(),
-                                                                    aText,
-                                                                    args);
-        va_end(args);
-        return rc;
+    }
-    /**
-     *  Sets the error information for the current thread but doesn't put
-     *  anything in the release log. This is very useful for avoiding
-     *  harmless error from causing confusion.
+     *
-     *  It is otherwise identical to #setError(HRESULT, const char *text, ...).
-     */
-    static HRESULT setErrorNoLog(HRESULT aResultCode, const char *aText, ...)
+    {
-        va_list args;
-        va_start(args, aText);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError(aResultCode,
-                                                                  COM_IIDOF(I),
-                                                                  C::getComponentName(),
-                                                                  aText,
-                                                                  args,
-                                                                  false /* aLogIt */);
-        va_end(args);
-        return rc;
+    }
-private:
-};
 /**
 …
-/// @todo (dmik) remove after we switch to VirtualBoxBaseNEXT completely
 /**
  *  Simple template that manages data structure allocation/deallocation

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

-              r30381
+              r30714
 class ATL_NO_VTABLE CallbackWrapper :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<CallbackWrapper, IVirtualBoxCallback>,
     public VirtualBoxSupportTranslation<CallbackWrapper>,
     VBOX_SCRIPTABLE_IMPL(ILocalOwner),
 …
+{
 public:
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CallbackWrapper, IVirtualBoxCallback)
     DECLARE_CLASSFACTORY()
 …
     STDMETHOD(OnShowWindow)(ULONG64 *winId);
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"CallbackWrapper"; }
 private:
     ComPtr<IVirtualBoxCallback> mVBoxCallback;

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

-              r30013
+              r30714
 #endif
+    VirtualBoxErrorInfo() : mResultCode(S_OK) {}
+    VirtualBoxErrorInfo()
+        : m_resultCode(S_OK)
+    {}
     // public initializer/uninitializer for internal purposes only
+    HRESULT init(HRESULT aResultCode, const GUID &aIID,
+                 CBSTR aComponent, CBSTR aText,
+    HRESULT init(HRESULT aResultCode,
+                 const GUID &aIID,
+                 const char *pcszComponent,
+                 const Utf8Str &strText,
                  IVirtualBoxErrorInfo *aNext = NULL);
 …
                             void *       /* c */) { return rc; }
     HRESULT mResultCode;
     Bstr mText;
     Guid mIID;
     Bstr mComponent;
+    HRESULT m_resultCode;
+    Utf8Str m_strText;
+    Guid    m_IID;
+    Utf8Str m_strComponent;
     ComPtr<IVirtualBoxErrorInfo> mNext;
 };

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

-              r30380
+              r30714
 class ATL_NO_VTABLE VirtualBox :
     public VirtualBoxBase,
-    public VirtualBoxSupportErrorInfoImpl<VirtualBox, IVirtualBox>,
     public VirtualBoxSupportTranslation<VirtualBox>,
     VBOX_SCRIPTABLE_IMPL(IVirtualBox)
 …
     friend class CallbackEvent;
     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualBox)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualBox, IVirtualBox)
     DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
 …
     /**
-     * Simple run-time type identification without having to enable C++ RTTI.
-     * The class IDs are defined in VirtualBoxBase.h.
-     * @return
-     */
-    virtual VBoxClsID getClassID() const
+    {
-        return clsidVirtualBox;
+    }
-    /**
      * Override of the default locking class to be used for validating lock
      * order with the standard member lock handle.
 …
     RWLockHandle& getMediaTreeLockHandle();
-    /* for VirtualBoxSupportErrorInfoImpl */
-    static const wchar_t *getComponentName() { return L"VirtualBox"; }
 private:
+    static HRESULT setErrorStatic(HRESULT aResultCode,
+                                  const Utf8Str &aText)
+    {
+        return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
+    }
     HRESULT checkMediaForConflicts2(const Guid &aId, const Utf8Str &aLocation,

trunk/src/VBox/Main/testcase/tstUSBLinux.h

-              r30269
+              r30714
+{
 public:
+    USBProxyServiceLinux() : mLastError(VINF_SUCCESS) {}
+    USBProxyServiceLinux()
+        : mLastError(VINF_SUCCESS)
+    {}
     HRESULT initSysfs(void);
     PUSBDEVICE getDevicesFromSysfs(void);
+    int getLastError(void) { return mLastError; }
+    int getLastError(void)
+    {
+        return mLastError;
+    }
 private:

Changeset 30714 in vbox

Legend:

Download in other formats: