VirtualBox

Changeset 98285 in vbox for trunk


Ignore:
Timestamp:
Jan 24, 2023 12:39:34 PM (21 months ago)
Author:
vboxsync
Message:

src-server/VirtualBoxImpl.cpp: rc -> hrc/vrc. bugref:10223

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r98264 r98285  
    482482    BaseFinalConstruct();
    483483
    484     HRESULT rc = init();
     484    HRESULT hrc = init();
    485485
    486486    LogRelFlowThisFuncLeave();
    487487    LogRel(("VirtualBox: object created\n"));
    488488
    489     return rc;
     489    return hrc;
    490490}
    491491
     
    556556     * unhelpful ones which cause us a lot of grief with troubleshooting. */
    557557
    558     HRESULT rc = S_OK;
     558    HRESULT hrc = S_OK;
    559559    bool fCreate = false;
    560560    try
    561561    {
    562562        /* Create the event source early as we may fire async event during settings loading (media). */
    563         rc = unconst(m->pEventSource).createObject();
    564         if (FAILED(rc)) throw rc;
    565         rc = m->pEventSource->init();
    566         if (FAILED(rc)) throw rc;
     563        hrc = unconst(m->pEventSource).createObject();
     564        if (FAILED(hrc)) throw hrc;
     565        hrc = m->pEventSource->init();
     566        if (FAILED(hrc)) throw hrc;
    567567
    568568
     
    620620        /* create the performance collector object BEFORE host */
    621621        unconst(m->pPerformanceCollector).createObject();
    622         rc = m->pPerformanceCollector->init();
    623         ComAssertComRCThrowRC(rc);
     622        hrc = m->pPerformanceCollector->init();
     623        ComAssertComRCThrowRC(hrc);
    624624#endif /* VBOX_WITH_RESOURCE_USAGE_API */
    625625
    626626        /* create the host object early, machines will need it */
    627627        unconst(m->pHost).createObject();
    628         rc = m->pHost->init(this);
    629         ComAssertComRCThrowRC(rc);
    630 
    631         rc = m->pHost->i_loadSettings(m->pMainConfigFile->host);
    632         if (FAILED(rc)) throw rc;
     628        hrc = m->pHost->init(this);
     629        ComAssertComRCThrowRC(hrc);
     630
     631        hrc = m->pHost->i_loadSettings(m->pMainConfigFile->host);
     632        if (FAILED(hrc)) throw hrc;
    633633
    634634        /*
     
    639639
    640640        /* create the system properties object, someone may need it too */
    641         rc = unconst(m->pSystemProperties).createObject();
    642         if (SUCCEEDED(rc))
    643             rc = m->pSystemProperties->init(this);
    644         ComAssertComRCThrowRC(rc);
    645 
    646         rc = m->pSystemProperties->i_loadSettings(m->pMainConfigFile->systemProperties);
    647         if (FAILED(rc)) throw rc;
     641        hrc = unconst(m->pSystemProperties).createObject();
     642        if (SUCCEEDED(hrc))
     643            hrc = m->pSystemProperties->init(this);
     644        ComAssertComRCThrowRC(hrc);
     645
     646        hrc = m->pSystemProperties->i_loadSettings(m->pMainConfigFile->systemProperties);
     647        if (FAILED(hrc)) throw hrc;
    648648#ifdef VBOX_WITH_MAIN_NLS
    649649        m->pVBoxTranslator = VirtualBoxTranslator::instance();
     
    664664                {
    665665                    com::Utf8Str strLocale;
    666                     HRESULT hrc = m->pSystemProperties->getLanguageId(strLocale);
    667                     if (SUCCEEDED(hrc))
     666                    HRESULT hrc2 = m->pSystemProperties->getLanguageId(strLocale);
     667                    if (SUCCEEDED(hrc2))
    668668                    {
    669669                        vrc = m->pVBoxTranslator->i_loadLanguage(strLocale.c_str());
    670670                        if (RT_FAILURE(vrc))
    671671                        {
    672                             hrc = Global::vboxStatusCodeToCOM(vrc);
    673                             LogRel(("Load language failed (%Rhrc).\n", hrc));
     672                            hrc2 = Global::vboxStatusCodeToCOM(vrc);
     673                            LogRel(("Load language failed (%Rhrc).\n", hrc2));
    674674                        }
    675675                    }
    676676                    else
    677677                    {
    678                         LogRel(("Getting language settings failed (%Rhrc).\n", hrc));
     678                        LogRel(("Getting language settings failed (%Rhrc).\n", hrc2));
    679679                        m->pVBoxTranslator->release();
    680680                        m->pVBoxTranslator = NULL;
     
    684684                else
    685685                {
    686                     HRESULT hrc = Global::vboxStatusCodeToCOM(vrc);
    687                     LogRel(("Register translation failed (%Rhrc).\n", hrc));
     686                    HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc);
     687                    LogRel(("Register translation failed (%Rhrc).\n", hrc2));
    688688                    m->pVBoxTranslator->release();
    689689                    m->pVBoxTranslator = NULL;
     
    693693            else
    694694            {
    695                 HRESULT hrc = Global::vboxStatusCodeToCOM(vrc);
    696                 LogRel(("Path constructing failed (%Rhrc).\n", hrc));
     695                HRESULT hrc2 = Global::vboxStatusCodeToCOM(vrc);
     696                LogRel(("Path constructing failed (%Rhrc).\n", hrc2));
    697697                m->pVBoxTranslator->release();
    698698                m->pVBoxTranslator = NULL;
     
    709709         * it is required for the VD plugins.
    710710         */
    711         rc = unconst(m->ptrExtPackManager).createObject();
    712         if (SUCCEEDED(rc))
    713             rc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON);
    714         if (FAILED(rc))
    715             throw rc;
     711        hrc = unconst(m->ptrExtPackManager).createObject();
     712        if (SUCCEEDED(hrc))
     713            hrc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON);
     714        if (FAILED(hrc))
     715            throw hrc;
    716716#endif
    717717        /* guest OS type objects, needed by machines */
     
    719719        {
    720720            ComObjPtr<GuestOSType> guestOSTypeObj;
    721             rc = guestOSTypeObj.createObject();
    722             if (SUCCEEDED(rc))
     721            hrc = guestOSTypeObj.createObject();
     722            if (SUCCEEDED(hrc))
    723723            {
    724                 rc = guestOSTypeObj->init(Global::sOSTypes[i]);
    725                 if (SUCCEEDED(rc))
     724                hrc = guestOSTypeObj->init(Global::sOSTypes[i]);
     725                if (SUCCEEDED(hrc))
    726726                    m->allGuestOSTypes.addChild(guestOSTypeObj);
    727727            }
    728             ComAssertComRCThrowRC(rc);
     728            ComAssertComRCThrowRC(hrc);
    729729        }
    730730
    731731        /* all registered media, needed by machines */
    732         if (FAILED(rc = initMedia(m->uuidMediaRegistry,
     732        if (FAILED(hrc = initMedia(m->uuidMediaRegistry,
    733733                                  m->pMainConfigFile->mediaRegistry,
    734734                                  Utf8Str::Empty)))     // const Utf8Str &machineFolder
    735             throw rc;
     735            throw hrc;
    736736
    737737        /* machines */
    738         if (FAILED(rc = initMachines()))
    739             throw rc;
     738        if (FAILED(hrc = initMachines()))
     739            throw hrc;
    740740
    741741#ifdef DEBUG
     
    752752
    753753            ComObjPtr<DHCPServer> pDhcpServer;
    754             if (SUCCEEDED(rc = pDhcpServer.createObject()))
    755                 rc = pDhcpServer->init(this, data);
    756             if (FAILED(rc)) throw rc;
    757 
    758             rc = i_registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);
    759             if (FAILED(rc)) throw rc;
     754            if (SUCCEEDED(hrc = pDhcpServer.createObject()))
     755                hrc = pDhcpServer->init(this, data);
     756            if (FAILED(hrc)) throw hrc;
     757
     758            hrc = i_registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);
     759            if (FAILED(hrc)) throw hrc;
    760760        }
    761761
     
    768768
    769769            ComObjPtr<NATNetwork> pNATNetwork;
    770             rc = pNATNetwork.createObject();
    771             AssertComRCThrowRC(rc);
    772             rc = pNATNetwork->init(this, "");
    773             AssertComRCThrowRC(rc);
    774             rc = pNATNetwork->i_loadSettings(net);
    775             AssertComRCThrowRC(rc);
    776             rc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);
    777             AssertComRCThrowRC(rc);
     770            hrc = pNATNetwork.createObject();
     771            AssertComRCThrowRC(hrc);
     772            hrc = pNATNetwork->init(this, "");
     773            AssertComRCThrowRC(hrc);
     774            hrc = pNATNetwork->i_loadSettings(net);
     775            AssertComRCThrowRC(hrc);
     776            hrc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);
     777            AssertComRCThrowRC(hrc);
    778778        }
    779779
     
    785785        {
    786786            ComObjPtr<HostOnlyNetwork> pHostOnlyNetwork;
    787             rc = pHostOnlyNetwork.createObject();
    788             AssertComRCThrowRC(rc);
    789             rc = pHostOnlyNetwork->init(this, "TODO???");
    790             AssertComRCThrowRC(rc);
    791             rc = pHostOnlyNetwork->i_loadSettings(*it);
    792             AssertComRCThrowRC(rc);
     787            hrc = pHostOnlyNetwork.createObject();
     788            AssertComRCThrowRC(hrc);
     789            hrc = pHostOnlyNetwork->init(this, "TODO???");
     790            AssertComRCThrowRC(hrc);
     791            hrc = pHostOnlyNetwork->i_loadSettings(*it);
     792            AssertComRCThrowRC(hrc);
    793793            m->allHostOnlyNetworks.addChild(pHostOnlyNetwork);
    794             AssertComRCThrowRC(rc);
     794            AssertComRCThrowRC(hrc);
    795795        }
    796796#endif /* VBOX_WITH_VMNET */
     
    803803        {
    804804            ComObjPtr<CloudNetwork> pCloudNetwork;
    805             rc = pCloudNetwork.createObject();
    806             AssertComRCThrowRC(rc);
    807             rc = pCloudNetwork->init(this, "");
    808             AssertComRCThrowRC(rc);
    809             rc = pCloudNetwork->i_loadSettings(*it);
    810             AssertComRCThrowRC(rc);
     805            hrc = pCloudNetwork.createObject();
     806            AssertComRCThrowRC(hrc);
     807            hrc = pCloudNetwork->init(this, "");
     808            AssertComRCThrowRC(hrc);
     809            hrc = pCloudNetwork->i_loadSettings(*it);
     810            AssertComRCThrowRC(hrc);
    811811            m->allCloudNetworks.addChild(pCloudNetwork);
    812             AssertComRCThrowRC(rc);
     812            AssertComRCThrowRC(hrc);
    813813        }
    814814#endif /* VBOX_WITH_CLOUD_NET */
    815815
    816816        /* cloud provider manager */
    817         rc = unconst(m->pCloudProviderManager).createObject();
    818         if (SUCCEEDED(rc))
    819             rc = m->pCloudProviderManager->init(this);
    820         ComAssertComRCThrowRC(rc);
    821         if (FAILED(rc)) throw rc;
     817        hrc = unconst(m->pCloudProviderManager).createObject();
     818        if (SUCCEEDED(hrc))
     819            hrc = m->pCloudProviderManager->init(this);
     820        ComAssertComRCThrowRC(hrc);
     821        if (FAILED(hrc)) throw hrc;
    822822    }
    823823    catch (HRESULT err)
    824824    {
    825825        /* we assume that error info is set by the thrower */
    826         rc = err;
     826        hrc = err;
    827827    }
    828828    catch (...)
    829829    {
    830         rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    831     }
    832 
    833     if (SUCCEEDED(rc))
     830        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     831    }
     832
     833    if (SUCCEEDED(hrc))
    834834    {
    835835        /* set up client monitoring */
     
    841841                delete m->pClientWatcher;
    842842                unconst(m->pClientWatcher) = NULL;
    843                 rc = E_FAIL;
     843                hrc = E_FAIL;
    844844            }
    845845        }
    846846        catch (std::bad_alloc &)
    847847        {
    848             rc = E_OUTOFMEMORY;
    849         }
    850     }
    851 
    852     if (SUCCEEDED(rc))
     848            hrc = E_OUTOFMEMORY;
     849        }
     850    }
     851
     852    if (SUCCEEDED(hrc))
    853853    {
    854854        try
     
    870870        catch (HRESULT aRC)
    871871        {
    872             rc = aRC;
     872            hrc = aRC;
    873873        }
    874874    }
     
    876876#ifdef VBOX_WITH_EXTPACK
    877877    /* Let the extension packs have a go at things. */
    878     if (SUCCEEDED(rc))
     878    if (SUCCEEDED(hrc))
    879879    {
    880880        lock.release();
     
    885885    /* Confirm a successful initialization when it's the case. Must be last,
    886886     * as on failure it will uninitialize the object. */
    887     if (SUCCEEDED(rc))
     887    if (SUCCEEDED(hrc))
    888888        autoInitSpan.setSucceeded();
    889889    else
    890         autoInitSpan.setFailed(rc);
    891 
    892     LogFlowThisFunc(("rc=%Rhrc\n", rc));
     890        autoInitSpan.setFailed(hrc);
     891
     892    LogFlowThisFunc(("hrc=%Rhrc\n", hrc));
    893893    LogFlowThisFuncLeave();
    894894    LogFlow(("===========================================================\n"));
     
    904904         ++it)
    905905    {
    906         HRESULT rc = S_OK;
     906        HRESULT hrc = S_OK;
    907907        const settings::MachineRegistryEntry &xmlMachine = *it;
    908908        Guid uuid = xmlMachine.uuid;
     
    917917        ComObjPtr<Machine> pMachine;
    918918        com::Utf8Str strPassword;
    919         if (SUCCEEDED(rc = pMachine.createObject()))
    920         {
    921             rc = pMachine->initFromSettings(this,
    922                                             xmlMachine.strSettingsFile,
    923                                             &uuid,
    924                                             strPassword);
    925             if (SUCCEEDED(rc))
    926                 rc = i_registerMachine(pMachine);
    927             if (FAILED(rc))
    928                 return rc;
     919        if (SUCCEEDED(hrc = pMachine.createObject()))
     920        {
     921            hrc = pMachine->initFromSettings(this, xmlMachine.strSettingsFile, &uuid, strPassword);
     922            if (SUCCEEDED(hrc))
     923                hrc = i_registerMachine(pMachine);
     924            if (FAILED(hrc))
     925                return hrc;
    929926        }
    930927    }
     
    969966    std::list<std::pair<Guid, DeviceType_T> > uIdsForNotify;
    970967
    971     HRESULT rc = S_OK;
     968    HRESULT hrc = S_OK;
    972969    settings::MediaList::const_iterator it;
    973970    for (it = mediaRegistry.llHardDisks.begin();
     
    977974        const settings::Medium &xmlHD = *it;
    978975
    979         rc = Medium::initFromSettings(this,
    980                                       DeviceType_HardDisk,
    981                                       uuidRegistry,
    982                                       strMachineFolder,
    983                                       xmlHD,
    984                                       treeLock,
    985                                       uIdsForNotify);
    986         if (FAILED(rc)) return rc;
     976        hrc = Medium::initFromSettings(this,
     977                                       DeviceType_HardDisk,
     978                                       uuidRegistry,
     979                                       strMachineFolder,
     980                                       xmlHD,
     981                                       treeLock,
     982                                       uIdsForNotify);
     983        if (FAILED(hrc)) return hrc;
    987984    }
    988985
     
    993990        const settings::Medium &xmlDvd = *it;
    994991
    995         rc = Medium::initFromSettings(this,
    996                                       DeviceType_DVD,
    997                                       uuidRegistry,
    998                                       strMachineFolder,
    999                                       xmlDvd,
    1000                                       treeLock,
    1001                                       uIdsForNotify);
    1002         if (FAILED(rc)) return rc;
     992        hrc = Medium::initFromSettings(this,
     993                                       DeviceType_DVD,
     994                                       uuidRegistry,
     995                                       strMachineFolder,
     996                                       xmlDvd,
     997                                       treeLock,
     998                                       uIdsForNotify);
     999        if (FAILED(hrc)) return hrc;
    10031000    }
    10041001
     
    10091006        const settings::Medium &xmlFloppy = *it;
    10101007
    1011         rc = Medium::initFromSettings(this,
    1012                                       DeviceType_Floppy,
    1013                                       uuidRegistry,
    1014                                       strMachineFolder,
    1015                                       xmlFloppy,
    1016                                       treeLock,
    1017                                       uIdsForNotify);
    1018         if (FAILED(rc)) return rc;
     1008        hrc = Medium::initFromSettings(this,
     1009                                       DeviceType_Floppy,
     1010                                       uuidRegistry,
     1011                                       strMachineFolder,
     1012                                       xmlFloppy,
     1013                                       treeLock,
     1014                                       uIdsForNotify);
     1015        if (FAILED(hrc)) return hrc;
    10191016    }
    10201017
     
    14491446    ComObjPtr<HostOnlyNetwork> HostOnlyNetwork;
    14501447    HostOnlyNetwork.createObject();
    1451     HRESULT rc = HostOnlyNetwork->init(this, aNetworkName);
    1452     if (FAILED(rc)) return rc;
     1448    HRESULT hrc = HostOnlyNetwork->init(this, aNetworkName);
     1449    if (FAILED(hrc)) return hrc;
    14531450
    14541451    m->allHostOnlyNetworks.addChild(HostOnlyNetwork);
     
    14561453    {
    14571454        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    1458         rc = i_saveSettings();
     1455        hrc = i_saveSettings();
    14591456        vboxLock.release();
    14601457
    1461         if (FAILED(rc))
     1458        if (FAILED(hrc))
    14621459            m->allHostOnlyNetworks.removeChild(HostOnlyNetwork);
    14631460        else
     
    14651462    }
    14661463
    1467     return rc;
     1464    return hrc;
    14681465#else /* !VBOX_WITH_VMNET */
    14691466    NOREF(aNetworkName);
     
    15361533#ifdef VBOX_WITH_VMNET
    15371534    Bstr name;
    1538     HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
    1539     if (FAILED(rc))
    1540         return rc;
     1535    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
     1536    if (FAILED(hrc))
     1537        return hrc;
    15411538    IHostOnlyNetwork *p = aNetwork;
    15421539    HostOnlyNetwork *network = static_cast<HostOnlyNetwork *>(p);
     
    15521549    {
    15531550        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    1554         rc = i_saveSettings();
     1551        hrc = i_saveSettings();
    15551552        vboxLock.release();
    15561553
    1557         if (FAILED(rc))
     1554        if (FAILED(hrc))
    15581555            m->allHostOnlyNetworks.addChild(network);
    15591556    }
    1560     return rc;
     1557    return hrc;
    15611558#else /* !VBOX_WITH_VMNET */
    15621559    NOREF(aNetwork);
     
    16071604            {
    16081605                ComPtr<INetworkAdapter> pNet;
    1609                 HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
    1610                 if (FAILED(rc) || pNet.isNull())
     1606                HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
     1607                if (FAILED(hrc) || pNet.isNull())
    16111608                    continue;
    16121609                Bstr strInternalNetwork;
    1613                 rc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());
    1614                 if (FAILED(rc) || strInternalNetwork.isEmpty())
     1610                hrc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());
     1611                if (FAILED(hrc) || strInternalNetwork.isEmpty())
    16151612                    continue;
    16161613
     
    16581655            {
    16591656                ComPtr<INetworkAdapter> pNet;
    1660                 HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
    1661                 if (FAILED(rc) || pNet.isNull())
     1657                HRESULT hrc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
     1658                if (FAILED(hrc) || pNet.isNull())
    16621659                    continue;
    16631660                Bstr strGenericNetworkDriver;
    1664                 rc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());
    1665                 if (FAILED(rc) || strGenericNetworkDriver.isEmpty())
     1661                hrc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());
     1662                if (FAILED(hrc) || strGenericNetworkDriver.isEmpty())
    16661663                    continue;
    16671664
     
    16901687                                             ComObjPtr<CloudNetwork> *aNetwork)
    16911688{
    1692     HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
    16931689    ComPtr<CloudNetwork> found;
    16941690    Bstr bstrNameToFind(aNetworkName);
     
    17071703        {
    17081704            *aNetwork = *it;
    1709             rc = S_OK;
    1710             break;
    1711         }
    1712     }
    1713     return rc;
     1705            return S_OK;
     1706        }
     1707    }
     1708    return VBOX_E_OBJECT_NOT_FOUND;
    17141709}
    17151710#endif /* VBOX_WITH_CLOUD_NET */
     
    17211716    ComObjPtr<CloudNetwork> cloudNetwork;
    17221717    cloudNetwork.createObject();
    1723     HRESULT rc = cloudNetwork->init(this, aNetworkName);
    1724     if (FAILED(rc)) return rc;
     1718    HRESULT hrc = cloudNetwork->init(this, aNetworkName);
     1719    if (FAILED(hrc)) return hrc;
    17251720
    17261721    m->allCloudNetworks.addChild(cloudNetwork);
     
    17281723    {
    17291724        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    1730         rc = i_saveSettings();
     1725        hrc = i_saveSettings();
    17311726        vboxLock.release();
    17321727
    1733         if (FAILED(rc))
     1728        if (FAILED(hrc))
    17341729            m->allCloudNetworks.removeChild(cloudNetwork);
    17351730        else
     
    17371732    }
    17381733
    1739     return rc;
     1734    return hrc;
    17401735#else /* !VBOX_WITH_CLOUD_NET */
    17411736    NOREF(aNetworkName);
     
    17651760#ifdef VBOX_WITH_CLOUD_NET
    17661761    Bstr name;
    1767     HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
    1768     if (FAILED(rc))
    1769         return rc;
     1762    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
     1763    if (FAILED(hrc))
     1764        return hrc;
    17701765    ICloudNetwork *p = aNetwork;
    17711766    CloudNetwork *network = static_cast<CloudNetwork *>(p);
     
    17811776    {
    17821777        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    1783         rc = i_saveSettings();
     1778        hrc = i_saveSettings();
    17841779        vboxLock.release();
    17851780
    1786         if (FAILED(rc))
     1781        if (FAILED(hrc))
    17871782            m->allCloudNetworks.addChild(network);
    17881783    }
    1789     return rc;
     1784    return hrc;
    17901785#else /* !VBOX_WITH_CLOUD_NET */
    17911786    NOREF(aNetwork);
     
    18681863        Utf8Str    fullName;
    18691864        Utf8StrFmt shortName("Firmware%c%s", RTPATH_DELIMITER, firmwareDesc[i].pszFileName);
    1870         int rc = i_calculateFullPath(shortName, fullName);
    1871         AssertRCReturn(rc, VBOX_E_IPRT_ERROR);
     1865        int vrc = i_calculateFullPath(shortName, fullName);
     1866        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
    18721867        if (RTFileExists(fullName.c_str()))
    18731868        {
     
    18781873
    18791874        char szVBoxPath[RTPATH_MAX];
    1880         rc = RTPathExecDir(szVBoxPath, RTPATH_MAX);
    1881         AssertRCReturn(rc, VBOX_E_IPRT_ERROR);
    1882         rc = RTPathAppend(szVBoxPath, sizeof(szVBoxPath), firmwareDesc[i].pszFileName);
     1875        vrc = RTPathExecDir(szVBoxPath, RTPATH_MAX);
     1876        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
     1877        vrc = RTPathAppend(szVBoxPath, sizeof(szVBoxPath), firmwareDesc[i].pszFileName);
     1878        AssertRCReturn(vrc, VBOX_E_IPRT_ERROR);
    18831879        if (RTFileExists(szVBoxPath))
    18841880        {
     
    19471943    if (strGroup.isEmpty())
    19481944        strGroup = "/";
    1949     HRESULT rc = i_validateMachineGroup(strGroup, true);
    1950     if (FAILED(rc))
    1951         return rc;
     1945    HRESULT hrc = i_validateMachineGroup(strGroup, true);
     1946    if (FAILED(hrc))
     1947        return hrc;
    19521948
    19531949    /* Compose the settings file name using the following scheme:
     
    21052101
    21062102    StringsList llGroups;
    2107     HRESULT rc = i_convertMachineGroups(aGroups, &llGroups);
    2108     if (FAILED(rc))
    2109         return rc;
     2103    HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups);
     2104    if (FAILED(hrc))
     2105        return hrc;
    21102106
    21112107    /** @todo r=bird: Would be goot to rewrite this parsing using offset into
     
    21562152    {
    21572153        /* do something else */
    2158         return setError(E_INVALIDARG,
    2159                  tr("'%s' is not a valid Guid"),
    2160                  id.toStringCurly().c_str());
     2154        return setError(E_INVALIDARG, tr("'%s' is not a valid Guid"), id.toStringCurly().c_str());
    21612155    }
    21622156
     
    21702164
    21712165        com::Utf8Str blstr;
    2172         rc = composeMachineFilename(aName,
    2173                                     llGroups.front(),
    2174                                     strNewCreateFlags,
    2175                                     blstr /* aBaseFolder */,
    2176                                     strSettingsFile);
    2177         if (FAILED(rc)) return rc;
     2166        hrc = composeMachineFilename(aName,
     2167                                     llGroups.front(),
     2168                                     strNewCreateFlags,
     2169                                     blstr /* aBaseFolder */,
     2170                                     strSettingsFile);
     2171        if (FAILED(hrc)) return hrc;
    21782172    }
    21792173
    21802174    /* create a new object */
    21812175    ComObjPtr<Machine> machine;
    2182     rc = machine.createObject();
    2183     if (FAILED(rc)) return rc;
     2176    hrc = machine.createObject();
     2177    if (FAILED(hrc)) return hrc;
    21842178
    21852179    ComObjPtr<GuestOSType> osType;
     
    21882182
    21892183    /* initialize the machine object */
    2190     rc = machine->init(this,
    2191                        strSettingsFile,
    2192                        aName,
    2193                        llGroups,
    2194                        aOsTypeId,
    2195                        osType,
    2196                        id,
    2197                        fForceOverwrite,
    2198                        fDirectoryIncludesUUID,
    2199                        aCipher,
    2200                        aPasswordId,
    2201                        aPassword);
    2202     if (SUCCEEDED(rc))
     2184    hrc = machine->init(this,
     2185                        strSettingsFile,
     2186                        aName,
     2187                        llGroups,
     2188                        aOsTypeId,
     2189                        osType,
     2190                        id,
     2191                        fForceOverwrite,
     2192                        fDirectoryIncludesUUID,
     2193                        aCipher,
     2194                        aPasswordId,
     2195                        aPassword);
     2196    if (SUCCEEDED(hrc))
    22032197    {
    22042198        /* set the return value */
    22052199        machine.queryInterfaceTo(aMachine.asOutParam());
    2206         AssertComRC(rc);
     2200        AssertComRC(hrc);
    22072201
    22082202#ifdef VBOX_WITH_EXTPACK
     
    22142208    LogFlowThisFuncLeave();
    22152209
    2216     return rc;
     2210    return hrc;
    22172211}
    22182212
     
    22212215                                ComPtr<IMachine> &aMachine)
    22222216{
    2223     HRESULT rc = E_FAIL;
    2224 
    22252217    /* create a new object */
    22262218    ComObjPtr<Machine> machine;
    2227     rc = machine.createObject();
    2228     if (SUCCEEDED(rc))
     2219    HRESULT hrc = machine.createObject();
     2220    if (SUCCEEDED(hrc))
    22292221    {
    22302222        /* initialize the machine object */
    2231         rc = machine->initFromSettings(this,
    2232                                        aSettingsFile,
    2233                                        NULL,          /* const Guid *aId */
    2234                                        aPassword);
    2235         if (SUCCEEDED(rc))
     2223        hrc = machine->initFromSettings(this, aSettingsFile, NULL /* const Guid *aId */, aPassword);
     2224        if (SUCCEEDED(hrc))
    22362225        {
    22372226            /* set the return value */
    22382227            machine.queryInterfaceTo(aMachine.asOutParam());
    2239             ComAssertComRC(rc);
    2240         }
    2241     }
    2242 
    2243     return rc;
     2228            ComAssertComRC(hrc);
     2229        }
     2230    }
     2231
     2232    return hrc;
    22442233}
    22452234
     
    22472236HRESULT VirtualBox::registerMachine(const ComPtr<IMachine> &aMachine)
    22482237{
    2249     HRESULT rc;
    2250 
    22512238    Bstr name;
    2252     rc = aMachine->COMGETTER(Name)(name.asOutParam());
    2253     if (FAILED(rc)) return rc;
     2239    HRESULT hrc = aMachine->COMGETTER(Name)(name.asOutParam());
     2240    if (FAILED(hrc)) return hrc;
    22542241
    22552242    /* We can safely cast child to Machine * here because only Machine
     
    22612248    ComAssertComRCRetRC(machCaller.hrc());
    22622249
    2263     rc = i_registerMachine(pMachine);
     2250    hrc = i_registerMachine(pMachine);
    22642251    /* fire an event */
    2265     if (SUCCEEDED(rc))
     2252    if (SUCCEEDED(hrc))
    22662253        i_onMachineRegistered(pMachine->i_getId(), TRUE);
    22672254
    2268     return rc;
     2255    return hrc;
    22692256}
    22702257
     
    22772264
    22782265    /* start with not found */
    2279     HRESULT rc = S_OK;
     2266    HRESULT hrc = S_OK;
    22802267    ComObjPtr<Machine> pMachineFound;
    22812268
     
    22832270    Utf8Str strFile(aSettingsFile);
    22842271    if (id.isValid() && !id.isZero())
    2285 
    2286         rc = i_findMachine(id,
    2287                            true /* fPermitInaccessible */,
    2288                            true /* setError */,
    2289                            &pMachineFound);
     2272        hrc = i_findMachine(id,
     2273                            true /* fPermitInaccessible */,
     2274                            true /* setError */,
     2275                            &pMachineFound);
    22902276        // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
    22912277    else
    22922278    {
    2293         rc = i_findMachineByName(strFile,
    2294                                  true /* setError */,
    2295                                  &pMachineFound);
     2279        hrc = i_findMachineByName(strFile,
     2280                                  true /* setError */,
     2281                                  &pMachineFound);
    22962282        // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
    22972283    }
     
    23002286    pMachineFound.queryInterfaceTo(aMachine.asOutParam());
    23012287
    2302     LogFlowThisFunc(("aName=\"%s\", aMachine=%p, rc=%08X\n", aSettingsFile.c_str(), &aMachine, rc));
     2288    LogFlowThisFunc(("aName=\"%s\", aMachine=%p, hrc=%08X\n", aSettingsFile.c_str(), &aMachine, hrc));
    23032289    LogFlowThisFuncLeave();
    23042290
    2305     return rc;
     2291    return hrc;
    23062292}
    23072293
     
    23102296{
    23112297    StringsList llGroups;
    2312     HRESULT rc = i_convertMachineGroups(aGroups, &llGroups);
    2313     if (FAILED(rc))
    2314         return rc;
     2298    HRESULT hrc = i_convertMachineGroups(aGroups, &llGroups);
     2299    if (FAILED(hrc))
     2300        return hrc;
    23152301
    23162302    /* we want to rely on sorted groups during compare, to save time */
     
    23842370        if (!pMachine.isNull())
    23852371        {
    2386             HRESULT rc = pMachine->COMGETTER(State)(&state);
    2387             if (rc == E_ACCESSDENIED)
    2388                 rc = S_OK;
    2389             AssertComRC(rc);
     2372            HRESULT hrc = pMachine->COMGETTER(State)(&state);
     2373            if (hrc == E_ACCESSDENIED)
     2374                hrc = S_OK;
     2375            AssertComRC(hrc);
    23902376        }
    23912377        aStates[i] = state;
     
    24212407    NOREF(aAccessMode); /**< @todo r=klaus make use of access mode */
    24222408
    2423     HRESULT rc = S_OK;
     2409    HRESULT hrc = S_OK;
    24242410
    24252411    ComObjPtr<Medium> medium;
     
    24362422                i_getDefaultHardDiskFormat(format);
    24372423
    2438             rc = medium->init(this,
    2439                               format,
    2440                               aLocation,
    2441                               Guid::Empty /* media registry: none yet */,
    2442                               aDeviceType);
    2443         }
    2444         break;
    2445 
    2446         case DeviceType_DVD:
    2447         case DeviceType_Floppy:
    2448         {
    2449 
    2450             if (format.isEmpty())
    2451                 return setError(E_INVALIDARG, tr("Format must be Valid Type%s"), format.c_str());
    2452 
    2453             // enforce read-only for DVDs even if caller specified ReadWrite
    2454             if (aDeviceType == DeviceType_DVD)
    2455                 aAccessMode = AccessMode_ReadOnly;
    2456 
    2457              rc = medium->init(this,
     2424            hrc = medium->init(this,
    24582425                               format,
    24592426                               aLocation,
    24602427                               Guid::Empty /* media registry: none yet */,
    24612428                               aDeviceType);
     2429        }
     2430        break;
     2431
     2432        case DeviceType_DVD:
     2433        case DeviceType_Floppy:
     2434        {
     2435
     2436            if (format.isEmpty())
     2437                return setError(E_INVALIDARG, tr("Format must be Valid Type%s"), format.c_str());
     2438
     2439            // enforce read-only for DVDs even if caller specified ReadWrite
     2440            if (aDeviceType == DeviceType_DVD)
     2441                aAccessMode = AccessMode_ReadOnly;
     2442
     2443             hrc = medium->init(this,
     2444                                format,
     2445                                aLocation,
     2446                                Guid::Empty /* media registry: none yet */,
     2447                                aDeviceType);
    24622448
    24632449         }
     
    24682454    }
    24692455
    2470     if (SUCCEEDED(rc))
     2456    if (SUCCEEDED(hrc))
    24712457    {
    24722458        medium.queryInterfaceTo(aMedium.asOutParam());
     
    24762462    }
    24772463
    2478     return rc;
     2464    return hrc;
    24792465}
    24802466
     
    24852471                               ComPtr<IMedium> &aMedium)
    24862472{
    2487     HRESULT rc = S_OK;
     2473    HRESULT hrc = S_OK;
    24882474    Guid id(aLocation);
    24892475    ComObjPtr<Medium> pMedium;
     
    25002486        case DeviceType_HardDisk:
    25012487            if (id.isValid() && !id.isZero())
    2502                 rc = i_findHardDiskById(id, false /* setError */, &pMedium);
     2488                hrc = i_findHardDiskById(id, false /* setError */, &pMedium);
    25032489            else
    2504                 rc = i_findHardDiskByLocation(aLocation,
    2505                                               false, /* aSetError */
    2506                                               &pMedium);
     2490                hrc = i_findHardDiskByLocation(aLocation, false, /* aSetError */ &pMedium);
    25072491        break;
    25082492
     
    25102494        case DeviceType_DVD:
    25112495            if (id.isValid() && !id.isZero())
    2512                 rc = i_findDVDOrFloppyImage(aDeviceType, &id, Utf8Str::Empty,
    2513                                             false /* setError */, &pMedium);
     2496                hrc = i_findDVDOrFloppyImage(aDeviceType, &id, Utf8Str::Empty, false /* setError */, &pMedium);
    25142497            else
    2515                 rc = i_findDVDOrFloppyImage(aDeviceType, NULL, aLocation,
    2516                                             false /* setError */, &pMedium);
     2498                hrc = i_findDVDOrFloppyImage(aDeviceType, NULL, aLocation, false /* setError */, &pMedium);
    25172499
    25182500            // enforce read-only for DVDs even if caller specified ReadWrite
     
    25302512        pMedium.createObject();
    25312513        treeLock.release();
    2532         rc = pMedium->init(this,
    2533                            aLocation,
    2534                            (aAccessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly,
    2535                            !!aForceNewUuid,
    2536                            aDeviceType);
     2514        hrc = pMedium->init(this,
     2515                            aLocation,
     2516                            (aAccessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly,
     2517                            !!aForceNewUuid,
     2518                            aDeviceType);
    25372519        treeLock.acquire();
    25382520
    2539         if (SUCCEEDED(rc))
    2540         {
    2541             rc = i_registerMedium(pMedium, &pMedium, treeLock);
     2521        if (SUCCEEDED(hrc))
     2522        {
     2523            hrc = i_registerMedium(pMedium, &pMedium, treeLock);
    25422524
    25432525            treeLock.release();
     
    25472529             * with the parent and this association needs to be broken. */
    25482530
    2549             if (FAILED(rc))
     2531            if (FAILED(hrc))
    25502532            {
    25512533                pMedium->uninit();
    2552                 rc = VBOX_E_OBJECT_NOT_FOUND;
     2534                hrc = VBOX_E_OBJECT_NOT_FOUND;
    25532535            }
    25542536            else
    2555             {
    25562537                fMediumRegistered = true;
    2557             }
    2558         }
    2559         else
    2560         {
    2561             if (rc != VBOX_E_INVALID_OBJECT_STATE)
    2562                 rc = VBOX_E_OBJECT_NOT_FOUND;
    2563         }
    2564     }
    2565 
    2566     if (SUCCEEDED(rc))
     2538        }
     2539        else if (hrc != VBOX_E_INVALID_OBJECT_STATE)
     2540            hrc = VBOX_E_OBJECT_NOT_FOUND;
     2541    }
     2542
     2543    if (SUCCEEDED(hrc))
    25672544    {
    25682545        pMedium.queryInterfaceTo(aMedium.asOutParam());
     
    25712548    }
    25722549
    2573     return rc;
     2550    return hrc;
    25742551}
    25752552
     
    25802557{
    25812558    ComObjPtr<GuestOSType> pType;
    2582     HRESULT rc = i_findGuestOSType(aId, pType);
     2559    HRESULT hrc = i_findGuestOSType(aId, pType);
    25832560    pType.queryInterfaceTo(aType.asOutParam());
    2584     return rc;
     2561    return hrc;
    25852562}
    25862563
     
    26492626    Utf8Str strValue(aValue);
    26502627    Utf8Str strOldValue;            // empty
    2651     HRESULT rc = S_OK;
     2628    HRESULT hrc = S_OK;
    26522629
    26532630    /* Because control characters in aKey have caused problems in the settings
     
    27092686
    27102687        /* save settings on success */
    2711         rc = i_saveSettings();
    2712         if (FAILED(rc)) return rc;
     2688        hrc = i_saveSettings();
     2689        if (FAILED(hrc)) return hrc;
    27132690    }
    27142691
     
    27172694        i_onExtraDataChanged(Guid::Empty, Bstr(aKey).raw(), Bstr(aValue).raw());
    27182695
    2719     return rc;
     2696    return hrc;
    27202697}
    27212698
     
    27382715    {
    27392716        Utf8Str strPlaintext;
    2740         int rc = i_decryptSetting(&strPlaintext, bstrCipher);
    2741         if (RT_SUCCESS(rc))
     2717        int vrc = i_decryptSetting(&strPlaintext, bstrCipher);
     2718        if (RT_SUCCESS(vrc))
    27422719            pMedium->i_setPropertyDirect("InitiatorSecret", strPlaintext);
    27432720        else
    2744             return rc;
     2721            return vrc;
    27452722    }
    27462723    return VINF_SUCCESS;
     
    27952772    char    szCipherBase64[128];
    27962773    size_t  cchCipherBase64;
    2797     int rc = i_encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext,
    2798                                  aPlaintext.length()+1, sizeof(abCiphertext));
    2799     if (RT_SUCCESS(rc))
    2800     {
    2801         rc = RTBase64Encode(abCiphertext, sizeof(abCiphertext),
    2802                             szCipherBase64, sizeof(szCipherBase64),
    2803                             &cchCipherBase64);
    2804         if (RT_SUCCESS(rc))
     2774    int vrc = i_encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext, aPlaintext.length()+1, sizeof(abCiphertext));
     2775    if (RT_SUCCESS(vrc))
     2776    {
     2777        vrc = RTBase64Encode(abCiphertext, sizeof(abCiphertext), szCipherBase64, sizeof(szCipherBase64), &cchCipherBase64);
     2778        if (RT_SUCCESS(vrc))
    28052779            *aCiphertext = szCipherBase64;
    28062780    }
    2807     return rc;
     2781    return vrc;
    28082782}
    28092783
     
    28192793    uint8_t abCiphertext[64];
    28202794    size_t  cbCiphertext;
    2821     int rc = RTBase64Decode(aCiphertext.c_str(),
    2822                             abCiphertext, sizeof(abCiphertext),
    2823                             &cbCiphertext, NULL);
    2824     if (RT_SUCCESS(rc))
    2825     {
    2826         rc = i_decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext);
    2827         if (RT_SUCCESS(rc))
     2795    int vrc = RTBase64Decode(aCiphertext.c_str(),
     2796                             abCiphertext, sizeof(abCiphertext),
     2797                             &cbCiphertext, NULL);
     2798    if (RT_SUCCESS(vrc))
     2799    {
     2800        vrc = i_decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext);
     2801        if (RT_SUCCESS(vrc))
    28282802        {
    28292803            for (unsigned i = 0; i < cbCiphertext; i++)
     
    28402814                }
    28412815            }
    2842             rc = VERR_INVALID_MAGIC;
    2843         }
    2844     }
    2845     return rc;
     2816            vrc = VERR_INVALID_MAGIC;
     2817        }
     2818    }
     2819    return vrc;
    28462820}
    28472821
     
    29902964    AssertReturn(event, E_FAIL);
    29912965
    2992     HRESULT rc;
     2966    HRESULT hrc;
    29932967    AutoCaller autoCaller(this);
    2994     if (SUCCEEDED((rc = autoCaller.hrc())))
     2968    if (SUCCEEDED((hrc = autoCaller.hrc())))
    29952969    {
    29962970        if (getObjectState().getState() != ObjectState::Ready)
     
    30032977            return S_OK;
    30042978        else
    3005             rc = E_FAIL;
     2979            hrc = E_FAIL;
    30062980    }
    30072981
     
    30092983    // the caller has allocated the object using new()
    30102984    delete event;
    3011     return rc;
     2985    return hrc;
    30122986}
    30132987
     
    30283002
    30293003    Bstr id;
    3030     HRESULT rc = aProgress->COMGETTER(Id)(id.asOutParam());
    3031     AssertComRCReturnRC(rc);
     3004    HRESULT hrc = aProgress->COMGETTER(Id)(id.asOutParam());
     3005    AssertComRCReturnRC(hrc);
    30323006
    30333007    /* protect mProgressOperations */
     
    31933167    /* create the i_SVCHelperClientThreadTask() argument */
    31943168
    3195     HRESULT hr = S_OK;
     3169    HRESULT hrc = S_OK;
    31963170    StartSVCHelperClientData *pTask = NULL;
    31973171    try
     
    32093183
    32103184        //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
    3211         hr = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER);
     3185        hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_WORKER);
    32123186
    32133187    }
    32143188    catch(std::bad_alloc &)
    32153189    {
    3216         hr = setError(E_OUTOFMEMORY);
     3190        hrc = setError(E_OUTOFMEMORY);
    32173191    }
    32183192    catch(...)
    32193193    {
    32203194        LogRel(("Could not create thread for StartSVCHelperClientData \n"));
    3221         hr = E_FAIL;
    3222     }
    3223 
    3224     return hr;
     3195        hrc = E_FAIL;
     3196    }
     3197
     3198    return hrc;
    32253199}
    32263200
     
    32323206{
    32333207    LogFlowFuncEnter();
    3234     HRESULT rc = S_OK;
     3208    HRESULT hrc = S_OK;
    32353209    bool userFuncCalled = false;
    32363210
    32373211    do
    32383212    {
    3239         AssertBreakStmt(pTask, rc = E_POINTER);
     3213        AssertBreakStmt(pTask, hrc = E_POINTER);
    32403214        AssertReturnVoid(!pTask->progress.isNull());
    32413215
     
    32453219        {
    32463220            /* it's too late */
    3247             rc = autoCaller.hrc();
     3221            hrc = autoCaller.hrc();
    32483222            break;
    32493223        }
     
    32583232        if (RT_FAILURE(vrc))
    32593233        {
    3260             rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc);
     3234            hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not create the communication channel (%Rrc)"), vrc);
    32613235            break;
    32623236        }
     
    32673241        if (!exePath)
    32683242        {
    3269             rc = pTask->that->setError(E_FAIL, tr("Cannot get executable name"));
     3243            hrc = pTask->that->setError(E_FAIL, tr("Cannot get executable name"));
    32703244            break;
    32713245        }
     
    33033277                 * (pressing the Cancel button to close the Run As dialog) */
    33043278                if (vrc2 == VERR_CANCELLED)
    3305                     rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user"));
     3279                    hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Operation canceled by the user"));
    33063280                else
    3307                     rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);
     3281                    hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a privileged process '%s' (%Rrc)"), exePath, vrc2);
    33083282                break;
    33093283            }
     
    33153289            if (RT_FAILURE(vrc))
    33163290            {
    3317                 rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
     3291                hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
    33183292                break;
    33193293            }
     
    33253299        {
    33263300            /* start the user supplied function */
    3327             rc = pTask->func(&client, pTask->progress, pTask->user, &vrc);
     3301            hrc = pTask->func(&client, pTask->progress, pTask->user, &vrc);
    33283302            userFuncCalled = true;
    33293303        }
     
    33363310        }
    33373311
    3338         if (SUCCEEDED(rc) && RT_FAILURE(vrc))
    3339         {
    3340             rc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc);
     3312        if (SUCCEEDED(hrc) && RT_FAILURE(vrc))
     3313        {
     3314            hrc = pTask->that->setErrorBoth(E_FAIL, vrc, tr("Could not operate the communication channel (%Rrc)"), vrc);
    33413315            break;
    33423316        }
     
    33443318    while (0);
    33453319
    3346     if (FAILED(rc) && !userFuncCalled)
     3320    if (FAILED(hrc) && !userFuncCalled)
    33473321    {
    33483322        /* call the user function in the "cleanup only" mode
     
    33513325    }
    33523326
    3353     pTask->progress->i_notifyComplete(rc);
     3327    pTask->progress->i_notifyComplete(hrc);
    33543328
    33553329    LogFlowFuncLeave();
     
    36743648    {
    36753649        ComPtr<INATNetwork> nat;
    3676         HRESULT rc = findNATNetworkByName(aNetworkName, nat);
    3677         if (FAILED(rc)) return -1;
    3678 
    3679         rc = nat->Start();
    3680         if (SUCCEEDED(rc))
     3650        HRESULT hrc = findNATNetworkByName(aNetworkName, nat);
     3651        if (FAILED(hrc)) return -1;
     3652
     3653        hrc = nat->Start();
     3654        if (SUCCEEDED(hrc))
    36813655            LogRel(("Started NAT network '%s'\n", aNetworkName.c_str()));
    36823656        else
    3683             LogRel(("Error %Rhrc starting NAT network '%s'\n", rc, aNetworkName.c_str()));
    3684         AssertComRCReturn(rc, -1);
     3657            LogRel(("Error %Rhrc starting NAT network '%s'\n", hrc, aNetworkName.c_str()));
     3658        AssertComRCReturn(hrc, -1);
    36853659    }
    36863660
     
    37033677    {
    37043678        ComPtr<INATNetwork> nat;
    3705         HRESULT rc = findNATNetworkByName(aNetworkName, nat);
    3706         if (FAILED(rc)) return -1;
    3707 
    3708         rc = nat->Stop();
    3709         if (SUCCEEDED(rc))
     3679        HRESULT hrc = findNATNetworkByName(aNetworkName, nat);
     3680        if (FAILED(hrc)) return -1;
     3681
     3682        hrc = nat->Stop();
     3683        if (SUCCEEDED(hrc))
    37103684            LogRel(("Stopped NAT network '%s'\n", aNetworkName.c_str()));
    37113685        else
    3712             LogRel(("Error %Rhrc stopping NAT network '%s'\n", rc, aNetworkName.c_str()));
    3713         AssertComRCReturn(rc, -1);
     3686            LogRel(("Error %Rhrc stopping NAT network '%s'\n", hrc, aNetworkName.c_str()));
     3687        AssertComRCReturn(hrc, -1);
    37143688    }
    37153689
     
    39023876                                  ComObjPtr<Machine> *aMachine /* = NULL */)
    39033877{
    3904     HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
     3878    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
    39053879
    39063880    AutoCaller autoCaller(this);
     
    39263900            if (pMachine->i_getId() == aId)
    39273901            {
    3928                 rc = S_OK;
     3902                hrc = S_OK;
    39293903                if (aMachine)
    39303904                    *aMachine = pMachine;
     
    39343908    }
    39353909
    3936     if (aSetError && FAILED(rc))
    3937         rc = setError(rc,
    3938                       tr("Could not find a registered machine with UUID {%RTuuid}"),
    3939                       aId.raw());
    3940 
    3941     return rc;
     3910    if (aSetError && FAILED(hrc))
     3911        hrc = setError(hrc, tr("Could not find a registered machine with UUID {%RTuuid}"), aId.raw());
     3912
     3913    return hrc;
    39423914}
    39433915
     
    39553927                                        ComObjPtr<Machine> *aMachine /* = NULL */)
    39563928{
    3957     HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
     3929    HRESULT hrc = VBOX_E_OBJECT_NOT_FOUND;
    39583930
    39593931    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
     
    39703942        if (pMachine->i_getName() == aName)
    39713943        {
    3972             rc = S_OK;
     3944            hrc = S_OK;
    39733945            if (aMachine)
    39743946                *aMachine = pMachine;
     
    39773949        if (!RTPathCompare(pMachine->i_getSettingsFileFull().c_str(), aName.c_str()))
    39783950        {
    3979             rc = S_OK;
     3951            hrc = S_OK;
    39803952            if (aMachine)
    39813953                *aMachine = pMachine;
     
    39843956    }
    39853957
    3986     if (aSetError && FAILED(rc))
    3987         rc = setError(rc,
    3988                       tr("Could not find a registered machine named '%s'"), aName.c_str());
    3989 
    3990     return rc;
     3958    if (aSetError && FAILED(hrc))
     3959        hrc = setError(hrc, tr("Could not find a registered machine named '%s'"), aName.c_str());
     3960
     3961    return hrc;
    39913962}
    39923963
     
    40273998            if (fPrimary)
    40283999            {
    4029                 HRESULT rc = pVirtualBox->i_findMachineByName(tmp,
    4030                                                               false /* aSetError */);
    4031                 if (SUCCEEDED(rc))
     4000                HRESULT hrc = pVirtualBox->i_findMachineByName(tmp, false /* aSetError */);
     4001                if (SUCCEEDED(hrc))
    40324002                    return VBOX_E_VM_ERROR;
    40334003            }
     
    40594029HRESULT VirtualBox::i_validateMachineGroup(const Utf8Str &aGroup, bool fPrimary)
    40604030{
    4061     HRESULT rc = i_validateMachineGroupHelper(aGroup, fPrimary, this);
    4062     if (FAILED(rc))
    4063     {
    4064         if (rc == VBOX_E_VM_ERROR)
    4065             rc = setError(E_INVALIDARG,
    4066                           tr("Machine group '%s' conflicts with a virtual machine name"),
    4067                           aGroup.c_str());
     4031    HRESULT hrc = i_validateMachineGroupHelper(aGroup, fPrimary, this);
     4032    if (FAILED(hrc))
     4033    {
     4034        if (hrc == VBOX_E_VM_ERROR)
     4035            hrc = setError(E_INVALIDARG, tr("Machine group '%s' conflicts with a virtual machine name"), aGroup.c_str());
    40684036        else
    4069             rc = setError(rc,
    4070                           tr("Invalid machine group '%s'"),
    4071                           aGroup.c_str());
    4072     }
    4073     return rc;
     4037            hrc = setError(hrc, tr("Invalid machine group '%s'"), aGroup.c_str());
     4038    }
     4039    return hrc;
    40744040}
    40754041
     
    40934059                group = "/";
    40944060
    4095             HRESULT rc = i_validateMachineGroup(group, i == 0);
    4096             if (FAILED(rc))
    4097                 return rc;
     4061            HRESULT hrc = i_validateMachineGroup(group, i == 0);
     4062            if (FAILED(hrc))
     4063                return hrc;
    40984064
    40994065            /* no duplicates please */
     
    42904256    }
    42914257
    4292     HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
     4258    HRESULT hrc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
    42934259
    42944260    if (aSetError && !found)
    42954261    {
    42964262        if (aId)
    4297             setError(rc,
     4263            setError(hrc,
    42984264                     tr("Could not find an image file with UUID {%RTuuid} in the media registry ('%s')"),
    42994265                     aId->raw(),
    43004266                     m->strSettingsFilePath.c_str());
    43014267        else
    4302             setError(rc,
     4268            setError(hrc,
    43034269                     tr("Could not find an image file with location '%s' in the media registry ('%s')"),
    43044270                     aLocation.c_str(),
     
    43064272    }
    43074273
    4308     return rc;
     4274    return hrc;
    43094275}
    43104276
     
    43514317
    43524318    // first search for host drive with that UUID
    4353     HRESULT rc = m->pHost->i_findHostDriveById(mediumType,
    4354                                                uuid,
    4355                                                fRefresh,
    4356                                                pMedium);
    4357     if (rc == VBOX_E_OBJECT_NOT_FOUND)
     4319    HRESULT hrc = m->pHost->i_findHostDriveById(mediumType, uuid, fRefresh, pMedium);
     4320    if (hrc == VBOX_E_OBJECT_NOT_FOUND)
    43584321                // then search for an image with that UUID
    4359         rc = i_findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium);
    4360 
    4361     return rc;
     4322        hrc = i_findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium);
     4323
     4324    return hrc;
    43624325}
    43634326
     
    45634526    AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    45644527
    4565     HRESULT rc = S_OK;
     4528    HRESULT hrc = S_OK;
    45664529
    45674530    ComObjPtr<Medium> pMediumFound;
     
    45694532
    45704533    if (aId.isValid() && !aId.isZero())
    4571         rc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
    4572     if (FAILED(rc) && !aLocation.isEmpty())
    4573         rc = i_findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);
    4574     if (SUCCEEDED(rc))
     4534        hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
     4535    if (FAILED(hrc) && !aLocation.isEmpty())
     4536        hrc = i_findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);
     4537    if (SUCCEEDED(hrc))
    45754538        pcszType = tr("hard disk");
    45764539
    45774540    if (!pcszType)
    45784541    {
    4579         rc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);
    4580         if (SUCCEEDED(rc))
     4542        hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);
     4543        if (SUCCEEDED(hrc))
    45814544            pcszType = tr("CD/DVD image");
    45824545    }
     
    45844547    if (!pcszType)
    45854548    {
    4586         rc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);
    4587         if (SUCCEEDED(rc))
     4549        hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);
     4550        if (SUCCEEDED(hrc))
    45884551            pcszType = tr("floppy image");
    45894552    }
     
    46284591    AutoReadLock alock(i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    46294592
    4630     HRESULT rc = S_OK;
    46314593    bool fInUse = false;
    46324594
    46334595    ComObjPtr<Medium> pMediumFound;
    46344596
     4597    HRESULT hrc;
    46354598    switch (deviceType)
    46364599    {
    46374600        case DeviceType_HardDisk:
    4638             rc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
     4601            hrc = i_findHardDiskById(aId, false /* aSetError */, &pMediumFound);
    46394602            break;
    46404603        case DeviceType_DVD:
    4641             rc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
     4604            hrc = i_findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
    46424605            break;
    46434606        case DeviceType_Floppy:
    4644             rc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
     4607            hrc = i_findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
    46454608            break;
    46464609        default:
    46474610            AssertMsgFailed(("Invalid device type %d\n", deviceType));
    4648     }
    4649 
    4650     if (SUCCEEDED(rc) && pMediumFound)
     4611            hrc = S_OK;
     4612            break;
     4613    }
     4614
     4615    if (SUCCEEDED(hrc) && pMediumFound)
    46514616        fInUse = true;
    46524617
     
    48004765            {
    48014766                const Data::PendingMachineRename &pmr = *it2;
    4802                 HRESULT rc = pMedium->i_updatePath(pmr.strConfigDirOld,
    4803                                                    pmr.strConfigDirNew);
    4804                 if (SUCCEEDED(rc))
     4767                HRESULT hrc = pMedium->i_updatePath(pmr.strConfigDirOld, pmr.strConfigDirNew);
     4768                if (SUCCEEDED(hrc))
    48054769                {
    48064770                    // Remember which medium objects has been changed,
    48074771                    // to trigger saving their registries later.
    48084772                    pDesc->llMedia.push_back(pMedium);
    4809                 } else if (rc == VBOX_E_FILE_ERROR)
     4773                } else if (hrc == VBOX_E_FILE_ERROR)
    48104774                    /* nothing */;
    48114775                else
    4812                     AssertComRC(rc);
     4776                    AssertComRC(hrc);
    48134777            }
    48144778        }
     
    48274791            //so there is no need to use delete operator for pDesc
    48284792            //after calling this function
    4829             HRESULT hr = pDesc->createThread();
     4793            HRESULT hrc = pDesc->createThread();
    48304794            pDesc = NULL;
    48314795
    4832             if (FAILED(hr))
     4796            if (FAILED(hrc))
    48334797            {
    48344798                // failure means that settings aren't saved, but there isn't
    48354799                // much we can do besides avoiding memory leaks
    4836                 LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hr));
     4800                LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hrc));
    48374801            }
    48384802        }
     
    48544818    };
    48554819
    4856     HRESULT rc;
    4857 
    48584820    for (size_t i = 0; i < RT_ELEMENTS(s); ++i)
    48594821    {
     
    48734835            {
    48744836                llTarget.push_back(settings::Medium::Empty);
    4875                 rc = pMedium->i_saveSettings(llTarget.back(), strMachineFolder);    // this recurses into child hard disks
    4876                 if (FAILED(rc))
     4837                HRESULT hrc = pMedium->i_saveSettings(llTarget.back(), strMachineFolder); // this recurses into child hard disks
     4838                if (FAILED(hrc))
    48774839                {
    48784840                    llTarget.pop_back();
    4879                     throw rc;
     4841                    throw hrc;
    48804842                }
    48814843            }
     
    49034865    i_unmarkRegistryModified(i_getGlobalRegistryId());
    49044866
    4905     HRESULT rc = S_OK;
     4867    HRESULT hrc = S_OK;
    49064868
    49074869    try
     
    49184880                // save actual machine registry entry
    49194881                settings::MachineRegistryEntry mre;
    4920                 rc = pMachine->i_saveRegistryEntry(mre);
     4882                hrc = pMachine->i_saveRegistryEntry(mre);
    49214883                m->pMainConfigFile->llMachines.push_back(mre);
    49224884            }
     
    49354897            {
    49364898                settings::DHCPServer d;
    4937                 rc = (*it)->i_saveSettings(d);
    4938                 if (FAILED(rc)) throw rc;
     4899                hrc = (*it)->i_saveSettings(d);
     4900                if (FAILED(hrc)) throw hrc;
    49394901                m->pMainConfigFile->llDhcpServers.push_back(d);
    49404902            }
     
    49514913            {
    49524914                settings::NATNetwork n;
    4953                 rc = (*it)->i_saveSettings(n);
    4954                 if (FAILED(rc)) throw rc;
     4915                hrc = (*it)->i_saveSettings(n);
     4916                if (FAILED(hrc)) throw hrc;
    49554917                m->pMainConfigFile->llNATNetworks.push_back(n);
    49564918            }
     
    49674929            {
    49684930                settings::HostOnlyNetwork n;
    4969                 rc = (*it)->i_saveSettings(n);
    4970                 if (FAILED(rc)) throw rc;
     4931                hrc = (*it)->i_saveSettings(n);
     4932                if (FAILED(hrc)) throw hrc;
    49714933                m->pMainConfigFile->llHostOnlyNetworks.push_back(n);
    49724934            }
     
    49834945            {
    49844946                settings::CloudNetwork n;
    4985                 rc = (*it)->i_saveSettings(n);
    4986                 if (FAILED(rc)) throw rc;
     4947                hrc = (*it)->i_saveSettings(n);
     4948                if (FAILED(hrc)) throw hrc;
    49874949                m->pMainConfigFile->llCloudNetworks.push_back(n);
    49884950            }
     
    49924954
    49934955        // host data (USB filters)
    4994         rc = m->pHost->i_saveSettings(m->pMainConfigFile->host);
    4995         if (FAILED(rc)) throw rc;
    4996 
    4997         rc = m->pSystemProperties->i_saveSettings(m->pMainConfigFile->systemProperties);
    4998         if (FAILED(rc)) throw rc;
     4956        hrc = m->pHost->i_saveSettings(m->pMainConfigFile->host);
     4957        if (FAILED(hrc)) throw hrc;
     4958
     4959        hrc = m->pSystemProperties->i_saveSettings(m->pMainConfigFile->systemProperties);
     4960        if (FAILED(hrc)) throw hrc;
    49994961
    50004962        // and write out the XML, still under the lock
    50014963        m->pMainConfigFile->write(m->strSettingsFilePath);
    50024964    }
    5003     catch (HRESULT err)
     4965    catch (HRESULT hrcXcpt)
    50044966    {
    50054967        /* we assume that error info is set by the thrower */
    5006         rc = err;
     4968        hrc = hrcXcpt;
    50074969    }
    50084970    catch (...)
    50094971    {
    5010         rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
    5011     }
    5012 
    5013     return rc;
     4972        hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
     4973    }
     4974
     4975    return hrc;
    50144976}
    50154977
     
    50364998    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
    50374999
    5038     HRESULT rc = S_OK;
     5000    HRESULT hrc = S_OK;
    50395001
    50405002    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     
    50425004    {
    50435005        ComObjPtr<Machine> pMachine;
    5044         rc = i_findMachine(aMachine->i_getId(),
    5045                            true /* fPermitInaccessible */,
    5046                            false /* aDoSetError */,
    5047                            &pMachine);
    5048         if (SUCCEEDED(rc))
     5006        hrc = i_findMachine(aMachine->i_getId(),
     5007                            true /* fPermitInaccessible */,
     5008                            false /* aDoSetError */,
     5009                            &pMachine);
     5010        if (SUCCEEDED(hrc))
    50495011        {
    50505012            /* sanity */
     
    50585020        }
    50595021
    5060         ComAssertRet(rc == VBOX_E_OBJECT_NOT_FOUND, rc);
    5061         rc = S_OK;
     5022        ComAssertRet(hrc == VBOX_E_OBJECT_NOT_FOUND, hrc);
     5023        hrc = S_OK;
    50625024    }
    50635025
    50645026    if (getObjectState().getState() != ObjectState::InInit)
    50655027    {
    5066         rc = aMachine->i_prepareRegister();
    5067         if (FAILED(rc)) return rc;
     5028        hrc = aMachine->i_prepareRegister();
     5029        if (FAILED(hrc)) return hrc;
    50685030    }
    50695031
     
    50725034
    50735035    if (getObjectState().getState() != ObjectState::InInit)
    5074         rc = i_saveSettings();
    5075 
    5076     return rc;
     5036        hrc = i_saveSettings();
     5037
     5038    return hrc;
    50775039}
    50785040
     
    51505112    }
    51515113
    5152     HRESULT rc;
     5114    HRESULT hrc;
    51535115
    51545116    Utf8Str strConflict;
    51555117    ComObjPtr<Medium> pDupMedium;
    5156     rc = i_checkMediaForConflicts(id,
    5157                                   strLocationFull,
    5158                                   strConflict,
    5159                                   &pDupMedium);
    5160     if (FAILED(rc)) return rc;
     5118    hrc = i_checkMediaForConflicts(id, strLocationFull, strConflict, &pDupMedium);
     5119    if (FAILED(hrc)) return hrc;
    51615120
    51625121    if (pDupMedium.isNull())
     
    52105169    mediaTreeLock.acquire();
    52115170
    5212     return rc;
     5171    return hrc;
    52135172}
    52145173
     
    53765335    m->allMachines.removeChild(pMachine);
    53775336    // save the global registry
    5378     HRESULT rc = i_saveSettings();
     5337    HRESULT hrc = i_saveSettings();
    53795338    alock.release();
    53805339
     
    54375396    i_onMachineRegistered(id, FALSE);
    54385397
    5439     return rc;
     5398    return hrc;
    54405399}
    54415400
     
    54535412    {
    54545413        ComObjPtr<Machine> pMachine;
    5455         HRESULT rc = i_findMachine(uuid,
    5456                                    false /* fPermitInaccessible */,
    5457                                    false /* aSetError */,
    5458                                    &pMachine);
    5459         if (SUCCEEDED(rc))
     5414        HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine);
     5415        if (SUCCEEDED(hrc))
    54605416        {
    54615417            AutoCaller machineCaller(pMachine);
     
    54905446    {
    54915447        ComObjPtr<Machine> pMachine;
    5492         HRESULT rc = i_findMachine(uuid,
    5493                                    false /* fPermitInaccessible */,
    5494                                    false /* aSetError */,
    5495                                    &pMachine);
    5496         if (SUCCEEDED(rc))
     5448        HRESULT hrc = i_findMachine(uuid, false /* fPermitInaccessible */, false /* aSetError */, &pMachine);
     5449        if (SUCCEEDED(hrc))
    54975450        {
    54985451            AutoCaller machineCaller(pMachine);
     
    55245477void VirtualBox::i_saveModifiedRegistries()
    55255478{
    5526     HRESULT rc = S_OK;
     5479    HRESULT hrc = S_OK;
    55275480    bool fNeedsGlobalSettings = false;
    55285481    uint64_t uOld;
     
    55545507                    continue;
    55555508                AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
    5556                 rc = pMachine->i_saveSettings(&fNeedsGlobalSettings, mlock,
    5557                                               Machine::SaveS_Force);           // caller said save, so stop arguing
     5509                hrc = pMachine->i_saveSettings(&fNeedsGlobalSettings, mlock,
     5510                                               Machine::SaveS_Force);           // caller said save, so stop arguing
    55585511            }
    55595512        }
     
    55725525    {
    55735526        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    5574         rc = i_saveSettings();
    5575     }
    5576     NOREF(rc); /* XXX */
     5527        hrc = i_saveSettings();
     5528    }
     5529    NOREF(hrc); /* XXX */
    55775530}
    55785531
     
    56615614    AssertReturn(pvUser, VERR_INVALID_POINTER);
    56625615
    5663     HRESULT hr = com::Initialize();
    5664     if (FAILED(hr))
     5616    HRESULT hrc = com::Initialize();
     5617    if (FAILED(hrc))
    56655618        return VERR_COM_UNEXPECTED;
    56665619
    5667     int rc = VINF_SUCCESS;
     5620    int vrc = VINF_SUCCESS;
    56685621
    56695622    try
     
    56875640        for (;;)
    56885641        {
    5689             rc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT);
    5690             if (rc == VERR_INTERRUPTED)
     5642            vrc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT);
     5643            if (vrc == VERR_INTERRUPTED)
    56915644            {
    5692                 LogFlow(("Event queue processing ended with rc=%Rrc\n", rc));
    5693                 rc = VINF_SUCCESS; /* Set success when exiting. */
     5645                LogFlow(("Event queue processing ended with vrc=%Rrc\n", vrc));
     5646                vrc = VINF_SUCCESS; /* Set success when exiting. */
    56945647                break;
    56955648            }
     
    57005653    catch (std::bad_alloc &ba)
    57015654    {
    5702         rc = VERR_NO_MEMORY;
     5655        vrc = VERR_NO_MEMORY;
    57035656        NOREF(ba);
    57045657    }
     
    57065659    com::Shutdown();
    57075660
    5708     LogFlowFuncLeaveRC(rc);
    5709     return rc;
     5661    LogFlowFuncLeaveRC(vrc);
     5662    return vrc;
    57105663}
    57115664
     
    57825735    ComObjPtr<DHCPServer> dhcpServer;
    57835736    dhcpServer.createObject();
    5784     HRESULT rc = dhcpServer->init(this, aName);
    5785     if (FAILED(rc)) return rc;
    5786 
    5787     rc = i_registerDHCPServer(dhcpServer, true);
    5788     if (FAILED(rc)) return rc;
     5737    HRESULT hrc = dhcpServer->init(this, aName);
     5738    if (FAILED(hrc)) return hrc;
     5739
     5740    hrc = i_registerDHCPServer(dhcpServer, true);
     5741    if (FAILED(hrc)) return hrc;
    57895742
    57905743    dhcpServer.queryInterfaceTo(aServer.asOutParam());
    57915744
    5792     return rc;
     5745    return hrc;
    57935746}
    57945747
     
    57965749                                                ComPtr<IDHCPServer> &aServer)
    57975750{
    5798     HRESULT rc = S_OK;
    57995751    ComPtr<DHCPServer> found;
    58005752
     
    58065758    {
    58075759        Bstr bstrNetworkName;
    5808         rc = (*it)->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
    5809         if (FAILED(rc)) return rc;
     5760        HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
     5761        if (FAILED(hrc)) return hrc;
    58105762
    58115763        if (Utf8Str(bstrNetworkName) == aName)
     
    58185770    if (!found)
    58195771        return E_INVALIDARG;
    5820 
    5821     rc = found.queryInterfaceTo(aServer.asOutParam());
    5822 
    5823     return rc;
     5772    return found.queryInterfaceTo(aServer.asOutParam());
    58245773}
    58255774
     
    58275776{
    58285777    IDHCPServer *aP = aServer;
    5829 
    5830     HRESULT rc = i_unregisterDHCPServer(static_cast<DHCPServer *>(aP));
    5831 
    5832     return rc;
     5778    return i_unregisterDHCPServer(static_cast<DHCPServer *>(aP));
    58335779}
    58345780
     
    58685814
    58695815    Bstr bstrNetworkName;
    5870     HRESULT rc = S_OK;
    5871     rc = aDHCPServer->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
    5872     if (FAILED(rc)) return rc;
     5816    HRESULT hrc = aDHCPServer->COMGETTER(NetworkName)(bstrNetworkName.asOutParam());
     5817    if (FAILED(hrc)) return hrc;
    58735818
    58745819    ComPtr<IDHCPServer> existing;
    5875     rc = findDHCPServerByNetworkName(Utf8Str(bstrNetworkName), existing);
    5876     if (SUCCEEDED(rc))
     5820    hrc = findDHCPServerByNetworkName(Utf8Str(bstrNetworkName), existing);
     5821    if (SUCCEEDED(hrc))
    58775822        return E_INVALIDARG;
    5878     rc = S_OK;
     5823    hrc = S_OK;
    58795824
    58805825    m->allDHCPServers.addChild(aDHCPServer);
     
    58865831    {
    58875832        // we acquired the lock on 'this' earlier to avoid lock order issues
    5888         rc = i_saveSettings();
    5889 
    5890         if (FAILED(rc))
     5833        hrc = i_saveSettings();
     5834
     5835        if (FAILED(hrc))
    58915836        {
    58925837            alock.acquire();
     
    58955840    }
    58965841
    5897     return rc;
     5842    return hrc;
    58985843}
    58995844
     
    59265871    alock.release();
    59275872
    5928     HRESULT rc = i_saveSettings();
     5873    HRESULT hrc = i_saveSettings();
    59295874
    59305875    // undo the changes if we failed to save them
    5931     if (FAILED(rc))
     5876    if (FAILED(hrc))
    59325877    {
    59335878        alock.acquire();
     
    59355880    }
    59365881
    5937     return rc;
     5882    return hrc;
    59385883}
    59395884
     
    59485893    ComObjPtr<NATNetwork> natNetwork;
    59495894    natNetwork.createObject();
    5950     HRESULT rc = natNetwork->init(this, aNetworkName);
    5951     if (FAILED(rc)) return rc;
    5952 
    5953     rc = i_registerNATNetwork(natNetwork, true);
    5954     if (FAILED(rc)) return rc;
     5895    HRESULT hrc = natNetwork->init(this, aNetworkName);
     5896    if (FAILED(hrc)) return hrc;
     5897
     5898    hrc = i_registerNATNetwork(natNetwork, true);
     5899    if (FAILED(hrc)) return hrc;
    59555900
    59565901    natNetwork.queryInterfaceTo(aNetwork.asOutParam());
     
    59585903    ::FireNATNetworkCreationDeletionEvent(m->pEventSource, aNetworkName, TRUE);
    59595904
    5960     return rc;
     5905    return hrc;
    59615906#else
    59625907    NOREF(aNetworkName);
     
    59715916#ifdef VBOX_WITH_NAT_SERVICE
    59725917
    5973     HRESULT rc = S_OK;
     5918    HRESULT hrc = S_OK;
    59745919    ComPtr<NATNetwork> found;
    59755920
     
    59815926    {
    59825927        Bstr bstrNATNetworkName;
    5983         rc = (*it)->COMGETTER(NetworkName)(bstrNATNetworkName.asOutParam());
    5984         if (FAILED(rc)) return rc;
     5928        hrc = (*it)->COMGETTER(NetworkName)(bstrNATNetworkName.asOutParam());
     5929        if (FAILED(hrc)) return hrc;
    59855930
    59865931        if (Utf8Str(bstrNATNetworkName) == aNetworkName)
     
    59945939        return E_INVALIDARG;
    59955940    found.queryInterfaceTo(aNetwork.asOutParam());
    5996     return rc;
     5941    return hrc;
    59975942#else
    59985943    NOREF(aNetworkName);
     
    60065951#ifdef VBOX_WITH_NAT_SERVICE
    60075952    Bstr name;
    6008     HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
    6009     if (FAILED(rc))
    6010         return rc;
     5953    HRESULT hrc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
     5954    if (FAILED(hrc))
     5955        return hrc;
    60115956    INATNetwork *p = aNetwork;
    60125957    NATNetwork *network = static_cast<NATNetwork *>(p);
    6013     rc = i_unregisterNATNetwork(network, true);
     5958    hrc = i_unregisterNATNetwork(network, true);
    60145959    ::FireNATNetworkCreationDeletionEvent(m->pEventSource, name.raw(), FALSE);
    6015     return rc;
     5960    return hrc;
    60165961#else
    60175962    NOREF(aNetwork);
     
    60425987
    60435988    Bstr name;
    6044     HRESULT rc;
    6045     rc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
    6046     AssertComRCReturnRC(rc);
     5989    HRESULT hrc;
     5990    hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
     5991    AssertComRCReturnRC(hrc);
    60475992
    60485993    /* returned value isn't 0 and aSaveSettings is true
     
    60535998        AssertComRCReturnRC(E_INVALIDARG);
    60545999
    6055     rc = S_OK;
     6000    hrc = S_OK;
    60566001
    60576002    sNatNetworkNameToRefCount[name] = 0;
     
    60626007    {
    60636008        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    6064         rc = i_saveSettings();
     6009        hrc = i_saveSettings();
    60656010        vboxLock.release();
    60666011
    6067         if (FAILED(rc))
     6012        if (FAILED(hrc))
    60686013            i_unregisterNATNetwork(aNATNetwork, false /* aSaveSettings */);
    60696014    }
    60706015
    6071     return rc;
     6016    return hrc;
    60726017#else
    60736018    NOREF(aNATNetwork);
     
    61036048
    61046049    Bstr name;
    6105     HRESULT rc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
     6050    HRESULT hrc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
    61066051    /* Hm, there're still running clients. */
    6107     if (FAILED(rc) || sNatNetworkNameToRefCount[name])
     6052    if (FAILED(hrc) || sNatNetworkNameToRefCount[name])
    61086053        AssertComRCReturnRC(E_INVALIDARG);
    61096054
     
    61136058    {
    61146059        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
    6115         rc = i_saveSettings();
     6060        hrc = i_saveSettings();
    61166061        vboxLock.release();
    61176062
    6118         if (FAILED(rc))
     6063        if (FAILED(hrc))
    61196064            i_registerNATNetwork(aNATNetwork, false /* aSaveSettings */);
    61206065    }
    61216066
    6122     return rc;
     6067    return hrc;
    61236068#else
    61246069    NOREF(aNATNetwork);
     
    63286273            err = GetLastError();
    63296274            hrc = HRESULT_FROM_WIN32(err);
    6330             AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr=%Rhrc (0x%x) err=%u\n",
     6275            AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n",
    63316276                                                   hrc, hrc, err));
    63326277            break;
     
    63456290                err = GetLastError();
    63466291                hrc = HRESULT_FROM_WIN32(err);
    6347                 AssertLogRelMsgFailed(("GetWindowsDirectory failed, hr=%Rhrc (0x%x) err=%u\n",
     6292                AssertLogRelMsgFailed(("GetWindowsDirectory failed, hrc=%Rhrc (0x%x) err=%u\n",
    63486293                                                   hrc, hrc, err));
    63496294                break;
     
    63596304                err = GetLastError();
    63606305                hrc = HRESULT_FROM_WIN32(err);
    6361                 AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hr=%Rhrc (0x%x) err=%u\n",
     6306                AssertLogRelMsgFailed(("EnumDeviceDrivers failed, hrc=%Rhrc (0x%x) err=%u\n",
    63626307                                                   hrc, hrc, err));
    63636308                break;
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