VirtualBox

Changeset 2672 in vbox for trunk/src/VBox/Main/glue


Ignore:
Timestamp:
May 16, 2007 3:31:49 PM (18 years ago)
Author:
vboxsync
Message:

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

Location:
trunk/src/VBox/Main/glue
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r1959 r2672  
    2020 */
    2121
    22 #if defined (__WIN__)
    23 
    24 #else // !defined (__WIN__)
     22#if !defined (VBOX_WITH_XPCOM)
     23
     24#else
    2525
    2626#include <nsIServiceManager.h>
    … …  
    2828#include <nsCOMPtr.h>
    2929
    30 #include <nsIInterfaceInfo.h>
    31 #include <nsIInterfaceInfoManager.h>
    32 
    33 #endif // !defined (__WIN__)
    34 
     30#endif
    3531
    3632#include "VBox/com/VirtualBox.h"
    3733#include "VBox/com/ErrorInfo.h"
    3834#include "VBox/com/assert.h"
     35#include "VBox/com/com.h"
    3936
    4037#include <iprt/stream.h>
    4138#include <iprt/string.h>
     39
    4240#include <VBox/err.h>
    4341
    44 /**
    45  *  Resolves a given interface ID to a string containint interface name.
    46  *  If, for some reason, the given IID cannot be resolved to a name,
    47  *  a NULL string is returned. A non-NULL interface name must be freed
    48  *  using SysFreeString().
    49  */
    50 static void GetInterfaceNameByIID (const GUID &id, BSTR *name)
    51 {
    52     Assert (name);
    53     if (!name)
    54         return;
    55 
    56     *name = NULL;
    57 
    58 #if defined (__WIN__)
    59 
    60     LONG rc;
    61     LPOLESTR iidStr = NULL;
    62     if (StringFromIID (id, &iidStr) == S_OK)
    63     {
    64         HKEY ifaceKey;
    65         rc = RegOpenKeyExW (HKEY_CLASSES_ROOT, L"Interface", 0, KEY_QUERY_VALUE, &ifaceKey);
    66         if (rc == ERROR_SUCCESS)
    67         {
    68             HKEY iidKey;
    69             rc = RegOpenKeyExW (ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
    70             if (rc == ERROR_SUCCESS)
    71             {
    72                 // determine the size and type
    73                 DWORD sz, type;
    74                 rc = RegQueryValueExW (iidKey, NULL, NULL, &type, NULL, &sz);
    75                 if (rc == ERROR_SUCCESS && type == REG_SZ)
    76                 {
    77                     // query the value to BSTR
    78                     *name = SysAllocStringLen (NULL, (sz + 1) / sizeof (TCHAR) + 1);
    79                     rc = RegQueryValueExW (iidKey, NULL, NULL, NULL, (LPBYTE) *name, &sz);
    80                     if (rc != ERROR_SUCCESS)
    81                     {
    82                         SysFreeString (*name);
    83                         name = NULL;
    84                     }
    85                 }
    86                 RegCloseKey (iidKey);
    87             }
    88             RegCloseKey (ifaceKey);
    89         }
    90         CoTaskMemFree (iidStr);
    91     }
    92 
    93 #else
    94 
    95     nsresult rv;
    96     nsCOMPtr <nsIInterfaceInfoManager> iim =
    97         do_GetService (NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv);
    98     if (NS_SUCCEEDED (rv))
    99     {
    100         nsCOMPtr <nsIInterfaceInfo> iinfo;
    101         rv = iim->GetInfoForIID (&id, getter_AddRefs (iinfo));
    102         if (NS_SUCCEEDED (rv))
    103         {
    104             const char *iname = NULL;
    105             iinfo->GetNameShared (&iname);
    106             char *utf8IName = NULL;
    107             if (VBOX_SUCCESS (RTStrCurrentCPToUtf8 (&utf8IName, iname)))
    108             {
    109                 PRTUCS2 ucs2IName = NULL;
    110                 if (VBOX_SUCCESS (RTStrUtf8ToUcs2 (&ucs2IName, utf8IName)))
    111                 {
    112                     *name = SysAllocString ((OLECHAR *) ucs2IName);
    113                     RTStrUcs2Free (ucs2IName);
    114                 }
    115                 RTStrFree (utf8IName);
    116             }
    117         }
    118     }
    119 
    120 #endif
    121 }
    122 
    123 
    12442namespace com
    12543{
    12644
    127 // IErrorInfo class
     45// ErrorInfo class
    12846////////////////////////////////////////////////////////////////////////////////
    12947
    130 void ErrorInfo::init ()
     48void ErrorInfo::init (bool aKeepObj /* = false */)
    13149{
    13250    HRESULT rc = E_FAIL;
    13351
    134 #if defined (__WIN__)
     52#if !defined (VBOX_WITH_XPCOM)
    13553
    13654    ComPtr <IErrorInfo> err;
    … …  
    13856    if (rc == S_OK && err)
    13957    {
     58        if (aKeepObj)
     59            mErrorInfo = err;
     60
    14061        ComPtr <IVirtualBoxErrorInfo> info;
    14162        rc = err.queryInterfaceTo (info.asOutParam());
    … …  
    16586    }
    16687
    167 #else // !defined (__WIN__)
     88#else // !defined (VBOX_WITH_XPCOM)
    16889
    16990    nsCOMPtr <nsIExceptionService> es;
    … …  
    179100            if (NS_SUCCEEDED (rc) && ex)
    180101            {
     102                if (aKeepObj)
     103                    mErrorInfo = ex;
     104
    181105                ComPtr <IVirtualBoxErrorInfo> info;
    182106                rc = ex.queryInterfaceTo (info.asOutParam());
    … …  
    213137    AssertComRC (rc);
    214138
    215 #endif // !defined (__WIN__)
    216 }
    217 
    218 void ErrorInfo::init (IUnknown *i, const GUID &iid)
    219 {
    220     Assert (i);
    221     if (!i)
     139#endif // !defined (VBOX_WITH_XPCOM)
     140}
     141
     142void ErrorInfo::init (IUnknown *aI, const GUID &aIID, bool aKeepObj /* = false */)
     143{
     144    Assert (aI);
     145    if (!aI)
    222146        return;
    223147
    224 #if defined (__WIN__)
    225 
    226     ComPtr <IUnknown> iface = i;
     148#if !defined (VBOX_WITH_XPCOM)
     149
     150    ComPtr <IUnknown> iface = aI;
    227151    ComPtr <ISupportErrorInfo> serr;
    228152    HRESULT rc = iface.queryInterfaceTo (serr.asOutParam());
    229153    if (SUCCEEDED (rc))
    230154    {
    231         rc = serr->InterfaceSupportsErrorInfo (iid);
     155        rc = serr->InterfaceSupportsErrorInfo (aIID);
    232156        if (SUCCEEDED (rc))
    233             init();
    234     }
    235 
    236 #else // !defined (__WIN__)
    237 
    238     init();
    239 
    240 #endif // !defined (__WIN__)
     157            init (aKeepObj);
     158    }
     159
     160#else
     161
     162    init (aKeepObj);
     163
     164#endif
    241165
    242166    if (mIsBasicAvailable)
    243167    {
    244         mCalleeIID = iid;
    245         GetInterfaceNameByIID (iid, mCalleeName.asOutParam());
     168        mCalleeIID = aIID;
     169        GetInterfaceNameByIID (aIID, mCalleeName.asOutParam());
    246170    }
    247171}
    … …  
    270194
    271195    rc = info->COMGETTER(Text) (mText.asOutParam());
     196    gotSomething |= SUCCEEDED (rc);
     197    gotAll &= SUCCEEDED (rc);
     198
     199    ComPtr <IVirtualBoxErrorInfo> next;
     200    rc = info->COMGETTER(Next) (next.asOutParam());
     201    if (SUCCEEDED (rc) && !next.isNull())
     202    {
     203        mNext.reset (new ErrorInfo (next));
     204        Assert (mNext.get());
     205        if (!mNext.get())
     206            rc = E_OUTOFMEMORY;
     207    }
     208    else
     209        mNext.reset();
    272210    gotSomething |= SUCCEEDED (rc);
    273211    gotAll &= SUCCEEDED (rc);
    … …  
    300238}
    301239
    302 // IErrorInfo class
     240/**
     241 *  Sets the given error info object for the current thread.  If @a aPreserve
     242 *  is @c true, then the current error info set on the thread before this
     243 *  method is called will be preserved in the IVirtualBoxErrorInfo::next
     244 *  attribute of the new error info object that will be then set as the
     245 *  current error info object.
     246 */
     247
     248//static
     249HRESULT setError (IVirtualBoxErrorInfo *aInfo);
     250
     251// ProgressErrorInfo class
    303252////////////////////////////////////////////////////////////////////////////////
    304253
    305254ProgressErrorInfo::ProgressErrorInfo (IProgress *progress) :
    306     ErrorInfo (true)
     255    ErrorInfo (false /* aDummy */)
    307256{
    308257    Assert (progress);
    … …  
    316265}
    317266
     267// ErrorInfoKeeper class
     268////////////////////////////////////////////////////////////////////////////////
     269
     270HRESULT ErrorInfoKeeper::restore()
     271{
     272    if (mForgot)
     273        return S_OK;
     274
     275    HRESULT rc = S_OK;
     276
     277#if !defined (VBOX_WITH_XPCOM)
     278
     279    ComPtr <IErrorInfo> err;
     280    if (!mErrorInfo.isNull())
     281    {
     282        rc = mErrorInfo.queryInterfaceTo (err.asOutParam());
     283        AssertComRC (rc);
     284    }
     285    rc = ::SetErrorInfo (0, err);
     286
     287#else // !defined (VBOX_WITH_XPCOM)
     288
     289    nsCOMPtr <nsIExceptionService> es;
     290    es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
     291    if (NS_SUCCEEDED (rc))
     292    {
     293        nsCOMPtr <nsIExceptionManager> em;
     294        rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
     295        if (NS_SUCCEEDED (rc))
     296        {
     297            ComPtr <nsIException> ex;
     298            if (!mErrorInfo.isNull())
     299            {
     300                rc = mErrorInfo.queryInterfaceTo (ex.asOutParam());
     301                AssertComRC (rc);
     302            }
     303            rc = em->SetCurrentException (ex);
     304        }
     305    }
     306
     307#endif // !defined (VBOX_WITH_XPCOM)
     308
     309    if (SUCCEEDED (rc))
     310    {
     311        mErrorInfo.setNull();
     312        mForgot = true;
     313    }
     314
     315    return rc;
     316}
     317
    318318}; // namespace com
    319319

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

    r1 r2672  
    2020 */
    2121
    22 #if defined (__WIN__)
     22#if !defined (VBOX_WITH_XPCOM)
    2323
    2424#include <objbase.h>
    2525
    26 #else // !defined (__WIN__)
     26#else
    2727
    2828#include <stdlib.h>
    … …  
    3636#include <nsEventQueueUtils.h>
    3737
    38 #endif // !defined (__WIN__)
     38#include <nsIInterfaceInfo.h>
     39#include <nsIInterfaceInfoManager.h>
     40
     41#endif
     42
     43#include <iprt/string.h>
     44#include <VBox/err.h>
    3945
    4046#include "VBox/com/com.h"
    … …  
    4854    HRESULT rc = E_FAIL;
    4955
    50 #if defined (__WIN__)
     56#if !defined (VBOX_WITH_XPCOM)
     57
    5158    rc = CoInitializeEx (NULL, COINIT_MULTITHREADED |
    5259                               COINIT_DISABLE_OLE1DDE |
    5360                               COINIT_SPEED_OVER_MEMORY);
    54 #else
    55     /*
    56      * Set VBOX_XPCOM_HOME if not present
    57     */
     61
     62#else
     63
     64    /* Set VBOX_XPCOM_HOME if not present */
    5865    if (!getenv("VBOX_XPCOM_HOME"))
    5966    {
    … …  
    8289        }
    8390    }
     91
    8492#endif
    8593
    … …  
    9199void Shutdown()
    92100{
    93 #if defined (__WIN__)
     101#if !defined (VBOX_WITH_XPCOM)
     102
    94103    CoUninitialize();
    95 #else
     104
     105#else
     106
    96107    nsCOMPtr <nsIEventQueue> eventQ;
    97108    nsresult rc = NS_GetMainEventQ (getter_AddRefs (eventQ));
    … …  
    100111        BOOL isOnMainThread = FALSE;
    101112        eventQ->IsOnCurrentThread (&isOnMainThread);
    102         eventQ = nsnull; // early release
     113        eventQ = nsnull; /* early release */
    103114        if (isOnMainThread)
    104115        {
    105             // only the main thread needs to uninitialize XPCOM
     116            /* only the main thread needs to uninitialize XPCOM */
    106117            NS_ShutdownXPCOM (nsnull);
    107118            XPCOMGlueShutdown();
    108119        }
    109120    }
     121
    110122#endif
    111123}
    112124
     125void GetInterfaceNameByIID (const GUID &aIID, BSTR *aName)
     126{
     127    Assert (aName);
     128    if (!aName)
     129        return;
     130
     131    *aName = NULL;
     132
     133#if !defined (VBOX_WITH_XPCOM)
     134
     135    LONG rc;
     136    LPOLESTR iidStr = NULL;
     137    if (StringFromIID (aIID, &iidStr) == S_OK)
     138    {
     139        HKEY ifaceKey;
     140        rc = RegOpenKeyExW (HKEY_CLASSES_ROOT, L"Interface",
     141                            0, KEY_QUERY_VALUE, &ifaceKey);
     142        if (rc == ERROR_SUCCESS)
     143        {
     144            HKEY iidKey;
     145            rc = RegOpenKeyExW (ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
     146            if (rc == ERROR_SUCCESS)
     147            {
     148                /* determine the size and type */
     149                DWORD sz, type;
     150                rc = RegQueryValueExW (iidKey, NULL, NULL, &type, NULL, &sz);
     151                if (rc == ERROR_SUCCESS && type == REG_SZ)
     152                {
     153                    /* query the value to BSTR */
     154                    *aName = SysAllocStringLen (NULL, (sz + 1) /
     155                                                      sizeof (TCHAR) + 1);
     156                    rc = RegQueryValueExW (iidKey, NULL, NULL, NULL,
     157                                           (LPBYTE) *aName, &sz);
     158                    if (rc != ERROR_SUCCESS)
     159                    {
     160                        SysFreeString (*aName);
     161                        aName = NULL;
     162                    }
     163                }
     164                RegCloseKey (iidKey);
     165            }
     166            RegCloseKey (ifaceKey);
     167        }
     168        CoTaskMemFree (iidStr);
     169    }
     170
     171#else
     172
     173    nsresult rv;
     174    nsCOMPtr <nsIInterfaceInfoManager> iim =
     175        do_GetService (NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv);
     176    if (NS_SUCCEEDED (rv))
     177    {
     178        nsCOMPtr <nsIInterfaceInfo> iinfo;
     179        rv = iim->GetInfoForIID (&aIID, getter_AddRefs (iinfo));
     180        if (NS_SUCCEEDED (rv))
     181        {
     182            const char *iname = NULL;
     183            iinfo->GetNameShared (&iname);
     184            char *utf8IName = NULL;
     185            if (VBOX_SUCCESS (RTStrCurrentCPToUtf8 (&utf8IName, iname)))
     186            {
     187                PRTUCS2 ucs2IName = NULL;
     188                if (VBOX_SUCCESS (RTStrUtf8ToUcs2 (&ucs2IName, utf8IName)))
     189                {
     190                    *aName = SysAllocString ((OLECHAR *) ucs2IName);
     191                    RTStrUcs2Free (ucs2IName);
     192                }
     193                RTStrFree (utf8IName);
     194            }
     195        }
     196    }
     197
     198#endif
     199}
     200
    113201}; // namespace com
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette