Changeset 2672 in vbox

Timestamp:

May 16, 2007 3:31:49 PM (17 years ago)

Author:

vboxsync

Message:

Main: Ported latest dmik/exp branch changes (r21219:21226) into the trunk.

Location:

trunk

Files:

• include/VBox/com/ErrorInfo.h (modified) (9 diffs)
• include/VBox/com/com.h (modified) (1 diff)
• src/VBox/Main/ConsoleImpl.cpp (modified) (7 diffs)
• src/VBox/Main/MachineImpl.cpp (modified) (7 diffs)
• src/VBox/Main/VirtualBoxBase.cpp (modified) (3 diffs)
• src/VBox/Main/VirtualBoxErrorInfoImpl.cpp (modified) (4 diffs)
• src/VBox/Main/glue/ErrorInfo.cpp (modified) (9 diffs)
• src/VBox/Main/glue/com.cpp (modified) (6 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (1 diff)
• src/VBox/Main/include/VirtualBoxBase.h (modified) (8 diffs)
• src/VBox/Main/include/VirtualBoxErrorInfoImpl.h (modified) (3 diffs)

trunk/include/VBox/com/ErrorInfo.h

@@ -28 +28 @@
 #include "VBox/com/Guid.h"
 #include "VBox/com/assert.h"
+
+#include <iprt/memory> // for auto_copy_ptr
 
 struct IProgress;
@@ -102 +104 @@
      *  pointer available.
      */
-    explicit ErrorInfo() :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    { init(); }
+    explicit ErrorInfo()
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        { init(); }
 
     /**
@@ -118 +121 @@
      *              error
      */
-    template <class I> ErrorInfo (I *aPtr) :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    { init (aPtr, COM_IIDOF(I)); }
+    template <class I> ErrorInfo (I *aPtr)
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        { init (aPtr, COM_IIDOF(I)); }
 
     /**
@@ -129 +133 @@
      *              an error
      */
-    template <class I> ErrorInfo (const ComPtr <I> &aPtr) :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    { init (static_cast <I*> (aPtr), COM_IIDOF(I)); }
+    template <class I> ErrorInfo (const ComPtr <I> &aPtr)
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        { init (static_cast <I*> (aPtr), COM_IIDOF(I)); }
 
     /** Specialization for the IVirtualBoxErrorInfo smart pointer */
-    ErrorInfo (const ComPtr <IVirtualBoxErrorInfo> &aPtr) :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    { init (aPtr); }
+    ErrorInfo (const ComPtr <IVirtualBoxErrorInfo> &aPtr)
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        { init (aPtr); }
 
     /**
@@ -146 +152 @@
      *                  holds error info to be fetched by this instance
      */
-    ErrorInfo (IVirtualBoxErrorInfo *aInfo) :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    { init (aInfo); }
-
-    ~ErrorInfo();
+    ErrorInfo (IVirtualBoxErrorInfo *aInfo)
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        { init (aInfo); }
+
+    virtual ~ErrorInfo();
 
     /**
@@ -201 +208 @@
 
     /**
+     *  Returns the next error information object or @c NULL if there is none.
+     */
+    const ErrorInfo *getNext() const { return mNext.get(); }
+
+    /**
      *  Returns the name of the interface that defined the error
      */
@@ -233 +245 @@
 protected:
 
-    ErrorInfo (bool dummy) :
-        mIsBasicAvailable (false), mIsFullAvailable (false), mResultCode (S_OK)
-    {}
-
-    void init();
-    void init (IUnknown *i, const GUID &iid);
-    void init (IVirtualBoxErrorInfo *info);
-
-private:
-
-    bool mIsBasicAvailable;
-    bool mIsFullAvailable;
+    ErrorInfo (bool aDummy)
+        : mIsBasicAvailable (false), mIsFullAvailable (false)
+        , mResultCode (S_OK)
+        {}
+
+    void init (bool aKeepObj = false);
+    void init (IUnknown *aUnk, const GUID &aIID, bool aKeepObj = false);
+    void init (IVirtualBoxErrorInfo *aInfo);
+
+    bool mIsBasicAvailable : 1;
+    bool mIsFullAvailable : 1;
 
     HRESULT mResultCode;
@@ -251 +262 @@
     Bstr mText;
 
+    cppx::auto_copy_ptr <ErrorInfo> mNext;
+
     Bstr mInterfaceName;
     Guid mCalleeIID;
     Bstr mCalleeName;
+
+    ComPtr <IUnknown> mErrorInfo;
 };
 
 /**
- *  A convenience subclass of ErrorInfo, that, given an IProgress interface
+ *  A convenience subclass of ErrorInfo that, given an IProgress interface
  *  pointer, reads its errorInfo attribute and uses the returned
  *  IVirtualBoxErrorInfo instance to construct itself.
@@ -277 +292 @@
 };
 
+/**
+ *  A convenience subclass of ErrorInfo that allows to preserve the current
+ *  error info. Instances of this class fetch an error info object set on the
+ *  current thread and keep a reference to it, which allows to restore it
+ *  later using the #restore() method. This is useful to preserve error
+ *  information returned by some method for the duration of making another COM
+ *  call that may set its own error info and overwrite the existing
+ *  one. Preserving and restoring error information makes sense when some
+ *  method wants to return error information set by other call as its own
+ *  error information while it still needs to make another call before return.
+ *
+ *  The usage pattern is:
+ *  <code>
+ *      rc = foo->method();
+ *      if (FAILED (rc))
+ *      {
+ *           ErrorInfoKeeper eik;
+ *           ...
+ *           // bar may return error info as well
+ *           bar->method();
+ *           ...
+ *           // restore error info from foo to return it to the caller
+ *           eik.restore();
+ *           return rc;
+ *      }
+ *  </code>
+ */
+class ErrorInfoKeeper : public ErrorInfo
+{
+public:
+
+    /** Constructs a new instance that will fetch the current error info. */
+    ErrorInfoKeeper() : ErrorInfo (false), mForgot (false)
+        { init (true /* aKeepObj */); }
+
+    /**
+     *  Destroys this instance and automatically calls #restore() which will
+     *  either restorr error info fetched by the constructor or do nothing
+     *  if #forget() was called before destruction. */
+    ~ErrorInfoKeeper() { if (!mForgot) restore(); }
+
+    /**
+     *  Restores error info fetched by the constructor and forgets it
+     *  afterwards.
+     *
+     *  @return COM result of the restore operation.
+     */
+    HRESULT restore();
+
+    /**
+     *  Forgets error info fetched by the constructor which prevents it from
+     *  being restored by #restore() or by the destructor.
+     */
+    void forget() { mForgot = 0; }
+
+private:
+
+    bool mForgot : 1;
+};
+
 }; // namespace com
 

trunk/include/VBox/com/com.h

@@ -38 +38 @@
 
 /**
- *  Shutdowns the COM runtime.
+ *  Shuts down the COM runtime.
  *  Must be called on every thread before termination.
- *  No any COM calls may be made after this method returns.
+ *  No COM calls may be made after this method returns.
  */
 void Shutdown();
+
+/**
+ *  Resolves a given interface ID to a string containing the interface name.
+ *  If, for some reason, the given IID cannot be resolved to a name, a NULL
+ *  string is returned. A non-NULL string returned by this funciton must be
+ *  freed using SysFreeString().
+ *
+ *  @param aIID     ID of the interface to get a name for
+ *  @param aName    Resolved interface name or @c NULL on error
+ */
+void GetInterfaceNameByIID (const GUID &aIID, BSTR *aName);
 
 }; // namespace com

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1785 +1785 @@
     if (FAILED (rc) && !taskCreationFailed)
     {
-        /* fetch any existing error info */
-        ErrorInfo ei;
+        /* preserve existing error info */
+        ErrorInfoKeeper eik;
 
         if (beganSavingState)
@@ -1807 +1807 @@
         else
             setMachineStateLocally (lastMachineState);
-
-        /* restore fetched error info */
-        setError (ei);
     }
 
@@ -2340 +2337 @@
     if (FAILED (rc) && !taskCreationFailed)
     {
-        /* fetch any existing error info */
-        ErrorInfo ei;
+        /* preserve existing error info */
+        ErrorInfoKeeper eik;
 
         if (beganTakingSnapshot && takingSnapshotOnline)
@@ -2363 +2360 @@
         else
             setMachineStateLocally (lastMachineState);
-
-        /* restore fetched error info */
-        setError (ei);
     }
 
@@ -6795 +6789 @@
             if (FAILED (hrc) || VBOX_FAILURE (vrc))
             {
-                /* preserve the current error info */
-                ErrorInfo ei;
+                /* preserve existing error info */
+                ErrorInfoKeeper eik;
 
                 /*
@@ -6804 +6798 @@
                 HRESULT hrc2 = console->powerDown();
                 AssertComRC (hrc2);
-
-                setError (ei);
             }
         }
@@ -6860 +6852 @@
          */
 
-        /* preserve the current error info */
-        ErrorInfo ei;
+        /* preserve existing error info */
+        ErrorInfoKeeper eik;
 
         Assert (console->mpVM == NULL);
         vmstateChangeCallback (NULL, VMSTATE_TERMINATED, VMSTATE_CREATING,
                                console);
-        setError (ei);
     }
 

trunk/src/VBox/Main/MachineImpl.cpp

@@ -8951 +8951 @@
         }
 
-        /* fetch the current error info */
-        ErrorInfo mergeEi;
+        /* preserve existing error info */
+        ErrorInfoKeeper mergeEik;
         HRESULT mergeRc = rc;
 
@@ -9026 +9026 @@
         while (0);
 
-        /* restore the merge error if any */
+        /* restore the merge error if any (ErrorInfo will be restored
+         * automatically) */
         if (FAILED (mergeRc))
-        {
             rc = mergeRc;
-            setError (mergeEi);
-        }
     }
     while (0);
@@ -9039 +9037 @@
         if (!aTask.subTask)
         {
-            /* save current error info */
-            ErrorInfo ei;
+            /* preserve existing error info */
+            ErrorInfoKeeper eik;
 
             /* restore the machine state */
@@ -9055 +9053 @@
                               true /* aInformCallbacksAnyway */);
             }
-
-            /* restore current error info */
-            setError (ei);
         }
 
@@ -9187 +9182 @@
             {
                 /* here we can still safely rollback, so do it */
-                ErrorInfo ei;
+                /* preserve existing error info */
+                ErrorInfoKeeper eik;
                 /* undo all changes */
                 rollback (false /* aNotify */);
-                setError (ei);
                 break;
             }
@@ -9306 +9301 @@
     if (FAILED (rc))
     {
-        ErrorInfo ei;
+        /* preserve existing error info */
+        ErrorInfoKeeper eik;
 
         if (!stateRestored)
@@ -9328 +9324 @@
                 saveSettings();
         }
-
-        setError (ei);
     }
 

trunk/src/VBox/Main/VirtualBoxBase.cpp

@@ -641 +641 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+/**
+ *  Sets error info for the current thread. This is an internal function that
+ *  gets eventually called by all public variants.  If @a aPreserve is
+ *  @c true, then the current error info object set on the thread before this
+ *  method is called will be preserved in the IVirtualBoxErrorInfo::next
+ *  attribute of the new error info object that will be then set as the
+ *  current error info object.
+ */
 // static
-HRESULT VirtualBoxSupportErrorInfoImplBase::setError (
-    HRESULT resultCode, const GUID &iid,
-    const Bstr &component,
-    const Bstr &text)
-{
-    LogRel (("ERROR [COM]: rc=%#08x IID={%Vuuid} component={%ls} text={%ls}\n",
-              resultCode, &iid, component.raw(), text.raw()));
+HRESULT VirtualBoxSupportErrorInfoImplBase::setErrorInternal (
+    HRESULT aResultCode, const GUID &aIID,
+    const Bstr &aComponent, const Bstr &aText,
+    bool aPreserve)
+{
+    LogRel (("ERROR [COM]: aRC=%#08x aIID={%Vuuid} aComponent={%ls} aText={%ls} "
+             "aPreserve=%RTbool\n",
+             aResultCode, &aIID, aComponent.raw(), aText.raw(), aPreserve));
 
     /* these are mandatory, others -- not */
-    Assert (FAILED (resultCode));
-    Assert (!text.isEmpty());
-    if (SUCCEEDED (resultCode) || text.isEmpty())
-        return E_FAIL;
-
-    ComObjPtr <VirtualBoxErrorInfo> info;
-    HRESULT rc = info.createObject();
-    if (SUCCEEDED (rc))
-    {
-        info->init (resultCode, iid, component, text);
+    AssertReturn (FAILED (aResultCode), E_FAIL);
+    AssertReturn (!aText.isEmpty(), E_FAIL);
+
+    HRESULT rc = S_OK;
+
+    do
+    {
+        ComObjPtr <VirtualBoxErrorInfo> info;
+        rc = info.createObject();
+        CheckComRCBreakRC (rc);
 
 #if defined (__WIN__)
+
+        ComPtr <IVirtualBoxErrorInfo> curInfo;
+        if (aPreserve)
+        {
+            /* get the current error info if any */
+            ComPtr <IErrorInfo> err;
+            rc = ::GetErrorInfo (0, err.asOutParam());
+            CheckComRCBreakRC (rc);
+            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 */
+        rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
+        CheckComRCBreakRC (rc);
 
         ComPtr <IErrorInfo> err;
@@ -677 +715 @@
             nsCOMPtr <nsIExceptionManager> em;
             rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
-            if (NS_SUCCEEDED (rc))
+            CheckComRCBreakRC (rc);
+
+            ComPtr <IVirtualBoxErrorInfo> curInfo;
+            if (aPreserve)
             {
+                /* get the current error info if any */
                 ComPtr <nsIException> ex;
-                rc = info.queryInterfaceTo (ex.asOutParam());
-                if (SUCCEEDED (rc))
-                    rc = em->SetCurrentException (ex);
+                rc = em->GetCurrentException (ex.asOutParam());
+                CheckComRCBreakRC (rc);
+                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 */
+            rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
+            CheckComRCBreakRC (rc);
+
+            ComPtr <nsIException> ex;
+            rc = info.queryInterfaceTo (ex.asOutParam());
+            if (SUCCEEDED (rc))
+                rc = em->SetCurrentException (ex);
         }
         else if (rc == NS_ERROR_UNEXPECTED)
@@ -705 +771 @@
 #endif // !defined (__WIN__)
     }
+    while (0);
 
     AssertComRC (rc);
 
-    return SUCCEEDED (rc) ? resultCode : rc;
-}
-
-// static
-HRESULT VirtualBoxSupportErrorInfoImplBase::setError (
-    HRESULT resultCode, const GUID &iid,
-    const Bstr &component,
-    const char *text, va_list args)
-{
-    return VirtualBoxSupportErrorInfoImplBase::setError (
-        resultCode, iid, component, Utf8StrFmt (text, args));
+    return SUCCEEDED (rc) ? aResultCode : rc;
 }
 

trunk/src/VBox/Main/VirtualBoxErrorInfoImpl.cpp

@@ -26 +26 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-void VirtualBoxErrorInfo::init (HRESULT aResultCode, const GUID &aIID,
-                                const BSTR aComponent, const BSTR aText,
-                                IVirtualBoxErrorInfo *aNext)
+HRESULT VirtualBoxErrorInfo::init (HRESULT aResultCode, const GUID &aIID,
+                                   const BSTR aComponent, const BSTR aText,
+                                   IVirtualBoxErrorInfo *aNext)
 {
     mResultCode = aResultCode;
@@ -35 +35 @@
     mText = aText;
     mNext = aNext;
+
+    return S_OK;
 }
 
@@ -87 +89 @@
 #if defined (__WIN__)
 
+/**
+ *  Initializes itself by fetching error information from the given error info
+ *  object.
+ */
+HRESULT VirtualBoxErrorInfo::init (IErrorInfo *aInfo)
+{
+    AssertReturn (aInfo, E_FAIL);
+
+    HRESULT rc = S_OK;
+
+    /* We don't return a failure if talking to IErrorInfo fails below to
+     * protect ourselves from bad IErrorInfo implementations (the
+     * corresponding fields will simply remain null in this case). */
+
+    mResultCode = S_OK;
+    rc = aInfo->GetGUID (mIID.asOutParam());
+    AssertComRC (rc);
+    rc = aInfo->GetSource (mComponent.asOutParam());
+    AssertComRC (rc);
+    rc = aInfo->GetDescription (mText.asOutParam());
+    AssertComRC (rc);
+    
+    return S_OK;
+}
+
 // IErrorInfo methods
 ////////////////////////////////////////////////////////////////////////////////
@@ -116 +143 @@
 
 #else // !defined (__WIN__)
+
+/**
+ *  Initializes itself by fetching error information from the given error info
+ *  object.
+ */
+HRESULT VirtualBoxErrorInfo::init (nsIException *aInfo)
+{
+    AssertReturn (aInfo, E_FAIL);
+
+    HRESULT rc = S_OK;
+
+    /* We don't return a failure if talking to nsIException fails below to
+     * protect ourselves from bad nsIException implementations (the
+     * corresponding fields will simply remain null in this case). */
+
+    rc = aInfo->GetResult (&mResultCode);
+    AssertComRC (rc);
+    Utf8Str message;
+    rc = aInfo->GetMessage (message.asOutParam());
+    AssertComRC (rc);
+    mText = message;
+    
+    return S_OK;
+}
 
 // nsIException methods

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

@@ -20 +20 @@
  */
 
-#if defined (__WIN__)
-
-#else // !defined (__WIN__)
+#if !defined (VBOX_WITH_XPCOM)
+
+#else
 
 #include <nsIServiceManager.h>
@@ -28 +28 @@
 #include <nsCOMPtr.h>
 
-#include <nsIInterfaceInfo.h>
-#include <nsIInterfaceInfoManager.h>
-
-#endif // !defined (__WIN__)
-
+#endif
 
 #include "VBox/com/VirtualBox.h"
 #include "VBox/com/ErrorInfo.h"
 #include "VBox/com/assert.h"
+#include "VBox/com/com.h"
 
 #include <iprt/stream.h>
 #include <iprt/string.h>
+
 #include <VBox/err.h>
 
-/**
- *  Resolves a given interface ID to a string containint interface name.
- *  If, for some reason, the given IID cannot be resolved to a name,
- *  a NULL string is returned. A non-NULL interface name must be freed
- *  using SysFreeString().
- */
-static void GetInterfaceNameByIID (const GUID &id, BSTR *name)
-{
-    Assert (name);
-    if (!name)
-        return;
-
-    *name = NULL;
-
-#if defined (__WIN__)
-
-    LONG rc;
-    LPOLESTR iidStr = NULL;
-    if (StringFromIID (id, &iidStr) == S_OK)
-    {
-        HKEY ifaceKey;
-        rc = RegOpenKeyExW (HKEY_CLASSES_ROOT, L"Interface", 0, KEY_QUERY_VALUE, &ifaceKey);
-        if (rc == ERROR_SUCCESS)
-        {
-            HKEY iidKey;
-            rc = RegOpenKeyExW (ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
-            if (rc == ERROR_SUCCESS)
-            {
-                // determine the size and type
-                DWORD sz, type;
-                rc = RegQueryValueExW (iidKey, NULL, NULL, &type, NULL, &sz);
-                if (rc == ERROR_SUCCESS && type == REG_SZ)
-                {
-                    // query the value to BSTR
-                    *name = SysAllocStringLen (NULL, (sz + 1) / sizeof (TCHAR) + 1);
-                    rc = RegQueryValueExW (iidKey, NULL, NULL, NULL, (LPBYTE) *name, &sz);
-                    if (rc != ERROR_SUCCESS)
-                    {
-                        SysFreeString (*name);
-                        name = NULL;
-                    }
-                }
-                RegCloseKey (iidKey);
-            }
-            RegCloseKey (ifaceKey);
-        }
-        CoTaskMemFree (iidStr);
-    }
-
-#else
-
-    nsresult rv;
-    nsCOMPtr <nsIInterfaceInfoManager> iim =
-        do_GetService (NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv);
-    if (NS_SUCCEEDED (rv))
-    {
-        nsCOMPtr <nsIInterfaceInfo> iinfo;
-        rv = iim->GetInfoForIID (&id, getter_AddRefs (iinfo));
-        if (NS_SUCCEEDED (rv))
-        {
-            const char *iname = NULL;
-            iinfo->GetNameShared (&iname);
-            char *utf8IName = NULL;
-            if (VBOX_SUCCESS (RTStrCurrentCPToUtf8 (&utf8IName, iname)))
-            {
-                PRTUCS2 ucs2IName = NULL;
-                if (VBOX_SUCCESS (RTStrUtf8ToUcs2 (&ucs2IName, utf8IName)))
-                {
-                    *name = SysAllocString ((OLECHAR *) ucs2IName);
-                    RTStrUcs2Free (ucs2IName);
-                }
-                RTStrFree (utf8IName);
-            }
-        }
-    }
-
-#endif
-}
-
-
 namespace com
 {
 
-// IErrorInfo class
+// ErrorInfo class
 ////////////////////////////////////////////////////////////////////////////////
 
-void ErrorInfo::init ()
+void ErrorInfo::init (bool aKeepObj /* = false */)
 {
     HRESULT rc = E_FAIL;
 
-#if defined (__WIN__)
+#if !defined (VBOX_WITH_XPCOM)
 
     ComPtr <IErrorInfo> err;
@@ -138 +56 @@
     if (rc == S_OK && err)
     {
+        if (aKeepObj)
+            mErrorInfo = err;
+
         ComPtr <IVirtualBoxErrorInfo> info;
         rc = err.queryInterfaceTo (info.asOutParam());
@@ -165 +86 @@
     }
 
-#else // !defined (__WIN__)
+#else // !defined (VBOX_WITH_XPCOM)
 
     nsCOMPtr <nsIExceptionService> es;
@@ -179 +100 @@
             if (NS_SUCCEEDED (rc) && ex)
             {
+                if (aKeepObj)
+                    mErrorInfo = ex;
+
                 ComPtr <IVirtualBoxErrorInfo> info;
                 rc = ex.queryInterfaceTo (info.asOutParam());
@@ -213 +137 @@
     AssertComRC (rc);
 
-#endif // !defined (__WIN__)
-}
-
-void ErrorInfo::init (IUnknown *i, const GUID &iid)
-{
-    Assert (i);
-    if (!i)
+#endif // !defined (VBOX_WITH_XPCOM)
+}
+
+void ErrorInfo::init (IUnknown *aI, const GUID &aIID, bool aKeepObj /* = false */)
+{
+    Assert (aI);
+    if (!aI)
         return;
 
-#if defined (__WIN__)
-
-    ComPtr <IUnknown> iface = i;
+#if !defined (VBOX_WITH_XPCOM)
+
+    ComPtr <IUnknown> iface = aI;
     ComPtr <ISupportErrorInfo> serr;
     HRESULT rc = iface.queryInterfaceTo (serr.asOutParam());
     if (SUCCEEDED (rc))
     {
-        rc = serr->InterfaceSupportsErrorInfo (iid);
+        rc = serr->InterfaceSupportsErrorInfo (aIID);
         if (SUCCEEDED (rc))
-            init();
-    }
-
-#else // !defined (__WIN__)
-
-    init();
-
-#endif // !defined (__WIN__)
+            init (aKeepObj);
+    }
+
+#else
+
+    init (aKeepObj);
+
+#endif
 
     if (mIsBasicAvailable)
     {
-        mCalleeIID = iid;
-        GetInterfaceNameByIID (iid, mCalleeName.asOutParam());
+        mCalleeIID = aIID;
+        GetInterfaceNameByIID (aIID, mCalleeName.asOutParam());
     }
 }
@@ -270 +194 @@
 
     rc = info->COMGETTER(Text) (mText.asOutParam());
+    gotSomething |= SUCCEEDED (rc);
+    gotAll &= SUCCEEDED (rc);
+
+    ComPtr <IVirtualBoxErrorInfo> next;
+    rc = info->COMGETTER(Next) (next.asOutParam());
+    if (SUCCEEDED (rc) && !next.isNull())
+    {
+        mNext.reset (new ErrorInfo (next));
+        Assert (mNext.get());
+        if (!mNext.get())
+            rc = E_OUTOFMEMORY;
+    }
+    else
+        mNext.reset();
     gotSomething |= SUCCEEDED (rc);
     gotAll &= SUCCEEDED (rc);
@@ -300 +238 @@
 }
 
-// IErrorInfo class
+/**
+ *  Sets the given error info object for the current thread.  If @a aPreserve
+ *  is @c true, then the current error info set on the thread before this
+ *  method is called will be preserved in the IVirtualBoxErrorInfo::next
+ *  attribute of the new error info object that will be then set as the
+ *  current error info object.
+ */
+
+//static
+HRESULT setError (IVirtualBoxErrorInfo *aInfo);
+
+// ProgressErrorInfo class
 ////////////////////////////////////////////////////////////////////////////////
 
 ProgressErrorInfo::ProgressErrorInfo (IProgress *progress) :
-    ErrorInfo (true)
+    ErrorInfo (false /* aDummy */)
 {
     Assert (progress);
@@ -316 +265 @@
 }
 
+// ErrorInfoKeeper class
+////////////////////////////////////////////////////////////////////////////////
+
+HRESULT ErrorInfoKeeper::restore()
+{
+    if (mForgot)
+        return S_OK;
+
+    HRESULT rc = S_OK;
+
+#if !defined (VBOX_WITH_XPCOM)
+
+    ComPtr <IErrorInfo> err;
+    if (!mErrorInfo.isNull())
+    {
+        rc = mErrorInfo.queryInterfaceTo (err.asOutParam());
+        AssertComRC (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 (NS_SUCCEEDED (rc))
+        {
+            ComPtr <nsIException> ex;
+            if (!mErrorInfo.isNull())
+            {
+                rc = mErrorInfo.queryInterfaceTo (ex.asOutParam());
+                AssertComRC (rc);
+            }
+            rc = em->SetCurrentException (ex);
+        }
+    }
+
+#endif // !defined (VBOX_WITH_XPCOM)
+
+    if (SUCCEEDED (rc))
+    {
+        mErrorInfo.setNull();
+        mForgot = true;
+    }
+
+    return rc;
+}
+
 }; // namespace com
 

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

@@ -20 +20 @@
  */
 
-#if defined (__WIN__)
+#if !defined (VBOX_WITH_XPCOM)
 
 #include <objbase.h>
 
-#else // !defined (__WIN__)
+#else
 
 #include <stdlib.h>
@@ -36 +36 @@
 #include <nsEventQueueUtils.h>
 
-#endif // !defined (__WIN__)
+#include <nsIInterfaceInfo.h>
+#include <nsIInterfaceInfoManager.h>
+
+#endif
+
+#include <iprt/string.h>
+#include <VBox/err.h>
 
 #include "VBox/com/com.h"
@@ -48 +54 @@
     HRESULT rc = E_FAIL;
 
-#if defined (__WIN__)
+#if !defined (VBOX_WITH_XPCOM)
+
     rc = CoInitializeEx (NULL, COINIT_MULTITHREADED |
                                COINIT_DISABLE_OLE1DDE |
                                COINIT_SPEED_OVER_MEMORY);
-#else
-    /*
-     * Set VBOX_XPCOM_HOME if not present
-     */
+
+#else
+
+    /* Set VBOX_XPCOM_HOME if not present */
     if (!getenv("VBOX_XPCOM_HOME"))
     {
@@ -82 +89 @@
         }
     }
+
 #endif
 
@@ -91 +99 @@
 void Shutdown()
 {
-#if defined (__WIN__)
+#if !defined (VBOX_WITH_XPCOM)
+
     CoUninitialize();
-#else
+
+#else
+
     nsCOMPtr <nsIEventQueue> eventQ;
     nsresult rc = NS_GetMainEventQ (getter_AddRefs (eventQ));
@@ -100 +111 @@
         BOOL isOnMainThread = FALSE;
         eventQ->IsOnCurrentThread (&isOnMainThread);
-        eventQ = nsnull; // early release
+        eventQ = nsnull; /* early release */
         if (isOnMainThread)
         {
-            // only the main thread needs to uninitialize XPCOM
+            /* only the main thread needs to uninitialize XPCOM */
             NS_ShutdownXPCOM (nsnull);
             XPCOMGlueShutdown();
         }
     }
+
 #endif
 }
 
+void GetInterfaceNameByIID (const GUID &aIID, BSTR *aName)
+{
+    Assert (aName);
+    if (!aName)
+        return;
+
+    *aName = NULL;
+
+#if !defined (VBOX_WITH_XPCOM)
+
+    LONG rc;
+    LPOLESTR iidStr = NULL;
+    if (StringFromIID (aIID, &iidStr) == S_OK)
+    {
+        HKEY ifaceKey;
+        rc = RegOpenKeyExW (HKEY_CLASSES_ROOT, L"Interface",
+                            0, KEY_QUERY_VALUE, &ifaceKey);
+        if (rc == ERROR_SUCCESS)
+        {
+            HKEY iidKey;
+            rc = RegOpenKeyExW (ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
+            if (rc == ERROR_SUCCESS)
+            {
+                /* determine the size and type */
+                DWORD sz, type;
+                rc = RegQueryValueExW (iidKey, NULL, NULL, &type, NULL, &sz);
+                if (rc == ERROR_SUCCESS && type == REG_SZ)
+                {
+                    /* query the value to BSTR */
+                    *aName = SysAllocStringLen (NULL, (sz + 1) /
+                                                      sizeof (TCHAR) + 1);
+                    rc = RegQueryValueExW (iidKey, NULL, NULL, NULL,
+                                           (LPBYTE) *aName, &sz);
+                    if (rc != ERROR_SUCCESS)
+                    {
+                        SysFreeString (*aName);
+                        aName = NULL;
+                    }
+                }
+                RegCloseKey (iidKey);
+            }
+            RegCloseKey (ifaceKey);
+        }
+        CoTaskMemFree (iidStr);
+    }
+
+#else
+
+    nsresult rv;
+    nsCOMPtr <nsIInterfaceInfoManager> iim =
+        do_GetService (NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv);
+    if (NS_SUCCEEDED (rv))
+    {
+        nsCOMPtr <nsIInterfaceInfo> iinfo;
+        rv = iim->GetInfoForIID (&aIID, getter_AddRefs (iinfo));
+        if (NS_SUCCEEDED (rv))
+        {
+            const char *iname = NULL;
+            iinfo->GetNameShared (&iname);
+            char *utf8IName = NULL;
+            if (VBOX_SUCCESS (RTStrCurrentCPToUtf8 (&utf8IName, iname)))
+            {
+                PRTUCS2 ucs2IName = NULL;
+                if (VBOX_SUCCESS (RTStrUtf8ToUcs2 (&ucs2IName, utf8IName)))
+                {
+                    *aName = SysAllocString ((OLECHAR *) ucs2IName);
+                    RTStrUcs2Free (ucs2IName);
+                }
+                RTStrFree (utf8IName);
+            }
+        }
+    }
+
+#endif
+}
+
 }; // namespace com

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

@@ -365 +365 @@
             Sometimes invocation of some component's method may involve
             methods of other components that may also fail (independently of
-            this method's failure), or a series of non-fatal errors may precede
-            a fatal error that causes method failure. In cases like that, it
-            may be desirable to preserve information about all errors happened
-            during method invocation and deliver it to the caller. The <link
-            to="#next"/> attribute is intended specifically for this purpose
-            and allows to represent a chain of errors through a single
-            IVirtualBoxErrorInfo instance set after method invocation.
+            this method's failure), or a series of non-fatal errors may
+            precede a fatal error that causes method failure. In cases like
+            that, it may be desirable to preserve information about all errors
+            happened during method invocation and deliver it to the
+            caller. The <link to="#next"/> attribute is intended specifically
+            for this purpose and allows to represent a chain of errors through
+            a single IVirtualBoxErrorInfo instance set after method
+            invocation. Note that errors are stored to a chain in the reverse
+            order, i.e. the initial error object you query right after method
+            invocation is the last error set by the callee, the object it
+            points to in the @a next attribute is the previous error and so
+            on, up to the first error (which is the last in the chain).
         </desc>
 

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

@@ -1032 +1032 @@
 class VirtualBoxSupportErrorInfoImplBase
 {
+    static HRESULT setErrorInternal (HRESULT aResultCode, const GUID &aIID,
+                                     const Bstr &aComponent, const Bstr &aText,
+                                     bool aPreserve);
+
 protected:
 
-    static HRESULT setError (HRESULT resultCode, const GUID &iid,
-                             const Bstr &component,
-                             const Bstr &text);
-
-    static HRESULT setError (HRESULT resultCode, const GUID &iid,
-                             const Bstr &component,
-                             const char *text, va_list args);
-
-    inline static HRESULT setError (const com::ErrorInfo &ei)
-    {
-        if (!ei.isBasicAvailable())
-            return S_OK;
-
-        Assert (FAILED (ei.getResultCode()));
-        Assert (!ei.getText().isEmpty());
-        return setError (ei.getResultCode(), ei.getInterfaceID(),
-                         ei.getComponent(), ei.getText());
+    inline static HRESULT setError (HRESULT aResultCode, const GUID &aIID,
+                                    const Bstr &aComponent,
+                                    const Bstr &aText)
+    {
+        return setErrorInternal (aResultCode, aIID, aComponent, aText,
+                                 false /* aPreserve */);
+    }
+
+    inline static HRESULT addError (HRESULT aResultCode, const GUID &aIID,
+                                    const Bstr &aComponent,
+                                    const Bstr &aText)
+    {
+        return setErrorInternal (aResultCode, aIID, aComponent, aText,
+                                 true /* aPreserve */);
+    }
+
+    static HRESULT setError (HRESULT aResultCode, const GUID &aIID,
+                             const Bstr &aComponent,
+                             const char *aText, va_list aArgs)
+    {
+        return setErrorInternal (aResultCode, aIID, aComponent,
+                                 Utf8StrFmt (aText, aArgs),
+                                 false /* aPreserve */);
+    }
+
+    static HRESULT addError (HRESULT aResultCode, const GUID &aIID,
+                             const Bstr &aComponent,
+                             const char *aText, va_list aArgs)
+    {
+        return setErrorInternal (aResultCode, aIID, aComponent,
+                                 Utf8StrFmt (aText, aArgs),
+                                 true /* aPreserve */);
     }
 };
@@ -1150 +1169 @@
      *  #setError (HRESULT, const char *, ...) for an example.
      *
-     *  @param  resultCode  result (error) code, must not be S_OK
-     *  @param  iid         IID of the intrface that defines the error
-     *  @param  component   name of the component that generates the error
-     *  @param  text        error message (must not be null), an RTStrPrintf-like
+     *  @param  aResultCode result (error) code, must not be S_OK
+     *  @param  aIID        IID of the intrface 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
@@ -1162 +1181 @@
      *      error argument.
      */
-    inline static HRESULT setError (HRESULT resultCode, const GUID &iid,
-                                    const wchar_t *component,
-                                    const char *text, ...)
+    inline static HRESULT setError (HRESULT aResultCode, const GUID &aIID,
+                                    const wchar_t *aComponent,
+                                    const char *aText, ...)
     {
         va_list args;
-        va_start (args, text);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError (
-            resultCode, iid, component, text, args);
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError
+            (aResultCode, aIID, aComponent, aText, args);
+        va_end (args);
+        return rc;
+    }
+
+    /**
+     *  This method is the same as #setError() except that it preserves the
+     *  error info object (if any) set for the current thread before this
+     *  method is called by storing it in the IVirtualBoxErrorInfo::next
+     *  attribute of the new error info object.
+     */
+    inline static HRESULT addError (HRESULT aResultCode, const GUID &aIID,
+                                    const wchar_t *aComponent,
+                                    const char *aText, ...)
+    {
+        va_list args;
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::addError
+            (aResultCode, aIID, aComponent, aText, args);
         va_end (args);
         return rc;
@@ -1197 +1234 @@
      *  </code>
      */
-    inline static HRESULT setError (HRESULT resultCode, const char *text, ...)
+    inline static HRESULT setError (HRESULT aResultCode, const char *aText, ...)
     {
         va_list args;
-        va_start (args, text);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError (
-            resultCode, COM_IIDOF(I), C::getComponentName(), text, args);
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText, args);
+        va_end (args);
+        return rc;
+    }
+
+    /**
+     *  This method is the same as #setError() except that it preserves the
+     *  error info object (if any) set for the current thread before this
+     *  method is called by storing it in the IVirtualBoxErrorInfo::next
+     *  attribute of the new error info object.
+     */
+    inline static HRESULT addError (HRESULT aResultCode, const char *aText, ...)
+    {
+        va_list args;
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::addError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText, args);
         va_end (args);
         return rc;
@@ -1216 +1269 @@
      *  and #setError (HRESULT, const char *, ...)  for details.
      */
-    inline static HRESULT setErrorV (HRESULT resultCode, const char *text, va_list args)
-    {
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError (
-            resultCode, COM_IIDOF(I), C::getComponentName(), text, args);
+    inline static HRESULT setErrorV (HRESULT aResultCode, const char *aText,
+                                     va_list aArgs)
+    {
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText, aArgs);
+        return rc;
+    }
+
+    /**
+     *  This method is the same as #setErrorV() except that it preserves the
+     *  error info object (if any) set for the current thread before this
+     *  method is called by storing it in the IVirtualBoxErrorInfo::next
+     *  attribute of the new error info object.
+     */
+    inline static HRESULT addErrorV (HRESULT aResultCode, const char *aText,
+                                     va_list aArgs)
+    {
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::addError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText, aArgs);
         return rc;
     }
@@ -1235 +1303 @@
      *  and #setError (HRESULT, const char *, ...)  for details.
      */
-    inline static HRESULT setErrorBstr (HRESULT resultCode, const Bstr &text)
-    {
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError (
-            resultCode, COM_IIDOF(I), C::getComponentName(), text);
+    inline static HRESULT setErrorBstr (HRESULT aResultCode, const Bstr &aText)
+    {
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText);
+        return rc;
+    }
+
+    /**
+     *  This method is the same as #setErrorBstr() except that it preserves the
+     *  error info object (if any) set for the current thread before this
+     *  method is called by storing it in the IVirtualBoxErrorInfo::next
+     *  attribute of the new error info object.
+     */
+    inline static HRESULT addErrorBstr (HRESULT aResultCode, const Bstr &aText)
+    {
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::addError
+            (aResultCode, COM_IIDOF(I), C::getComponentName(), aText);
         return rc;
     }
@@ -1251 +1332 @@
      *  for details.
      */
-    inline static HRESULT setError (HRESULT resultCode, const GUID &iid,
-                                    const char *text, ...)
+    inline static HRESULT setError (HRESULT aResultCode, const GUID &aIID,
+                                    const char *aText, ...)
     {
         va_list args;
-        va_start (args, text);
-        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError (
-            resultCode, iid, C::getComponentName(), text, args);
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::setError
+            (aResultCode, aIID, C::getComponentName(), aText, args);
         va_end (args);
         return rc;
@@ -1263 +1344 @@
 
     /**
-     *  Sets the error information for the current thread using the error
-     *  information previously fetched using an ErrorInfo instance.
-     *  This is useful, for instance, if you want to keep the error information
-     *  returned by some interface's method, but need to call another method
-     *  of some interface prior to returning from your method (calling
-     *  another method will normally reset the current error information).
-     */
-    inline static HRESULT setError (const com::ErrorInfo &ei)
-    {
-        return VirtualBoxSupportErrorInfoImplBase::setError (ei);
+     *  This method is the same as #setError() except that it preserves the
+     *  error info object (if any) set for the current thread before this
+     *  method is called by storing it in the IVirtualBoxErrorInfo::next
+     *  attribute of the new error info object.
+     */
+    inline static HRESULT addError (HRESULT aResultCode, const GUID &aIID,
+                                    const char *aText, ...)
+    {
+        va_list args;
+        va_start (args, aText);
+        HRESULT rc = VirtualBoxSupportErrorInfoImplBase::addError
+            (aResultCode, aIID, C::getComponentName(), aText, args);
+        va_end (args);
+        return rc;
     }
 

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

@@ -49 +49 @@
 
 #if defined (__WIN__)
+
+    HRESULT init (IErrorInfo *aInfo);
+
     STDMETHOD(GetGUID) (GUID *guid);
     STDMETHOD(GetSource) (BSTR *source);
@@ -54 +57 @@
     STDMETHOD(GetHelpFile) (BSTR *pBstrHelpFile);
     STDMETHOD(GetHelpContext) (DWORD *pdwHelpContext);
+
 #else // !defined (__WIN__)
+
+    HRESULT init (nsIException *aInfo);
+
     NS_DECL_NSIEXCEPTION
+
 #endif
 
@@ -61 +69 @@
 
     // public initializer/uninitializer for internal purposes only
-    void init (HRESULT aResultCode, const GUID &aIID,
-               const BSTR aComponent, const BSTR aText,
-               IVirtualBoxErrorInfo *aNext = NULL);
+    HRESULT init (HRESULT aResultCode, const GUID &aIID,
+                  const BSTR aComponent, const BSTR aText,
+                  IVirtualBoxErrorInfo *aNext = NULL);
 
     // IVirtualBoxErrorInfo properties