VirtualBox

Changeset 25149 in vbox for trunk/src


Ignore:
Timestamp:
Dec 2, 2009 2:34:47 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
55564
Message:

Main: cleanup: remove all CheckComRC* macros (no functional change)

Location:
trunk/src/VBox
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r25108 r25149  
    10311031                               hardDisk.asOutParam()));
    10321032        }
    1033         CheckComRCBreakRC (rc);
     1033        if (FAILED(rc)) break;
    10341034
    10351035        if (!port.isNull())

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r25099 r25149  
    147147    BOOL accessible = FALSE;
    148148    CHECK_ERROR(machine, COMGETTER(Accessible)(&accessible));
    149     CheckComRCReturnRC(rc);
     149    if (FAILED(rc)) return rc;
    150150
    151151    Bstr uuid;

  • trunk/src/VBox/Main/ApplianceImpl.cpp

    r25146 r25149  
    819819
    820820    rc = task->startThread();
    821     CheckComRCThrowRC(rc);
     821    if (FAILED(rc)) throw rc;
    822822
    823823    /* Don't destruct on success */
    … …  
    851851
    852852    rc = task->startThread();
    853     CheckComRCThrowRC(rc);
     853    if (FAILED(rc)) throw rc;
    854854
    855855    /* Don't destruct on success */
    … …  
    921921
    922922    AutoCaller autoCaller(this);
    923     CheckComRCReturnRC(autoCaller.rc());
     923    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    924924
    925925    AutoWriteLock appLock(this);
    … …  
    964964
    965965    AutoCaller autoCaller(this);
    966     CheckComRCReturnRC(autoCaller.rc());
     966    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    967967
    968968    AutoWriteLock appLock(this);
    … …  
    10881088
    10891089    AutoCaller autoCaller(this);
    1090     CheckComRCReturnRC(autoCaller.rc());
     1090    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10911091
    10921092    AutoWriteLock appLock(this);
    … …  
    11031103    bool fSessionOpen = false;
    11041104    rc = session.createInprocObject(CLSID_Session);
    1105     CheckComRCReturnRC(rc);
     1105    if (FAILED(rc)) return rc;
    11061106
    11071107    const OVFReader &reader = *m->pReader;
    … …  
    19761976
    19771977    AutoCaller autoCaller(this);
    1978     CheckComRCReturnRC(autoCaller.rc());
     1978    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19791979
    19801980    AutoWriteLock appLock(this);
    … …  
    21792179
    21802180        rc = task->startThread();
    2181         CheckComRCThrowRC(rc);
     2181        if (FAILED(rc)) throw rc;
    21822182
    21832183        /* Don't destruct on success */
    … …  
    22402240
    22412241    AutoCaller autoCaller(this);
    2242     CheckComRCReturnRC(autoCaller.rc());
     2242    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22432243
    22442244    AutoWriteLock appLock(this);
    … …  
    30823082
    30833083    AutoCaller autoCaller(this);
    3084     CheckComRCReturnRC(autoCaller.rc());
     3084    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30853085
    30863086    HRESULT rc = S_OK;
    … …  
    32593259
    32603260    AutoCaller autoCaller(this);
    3261     CheckComRCReturnRC(autoCaller.rc());
     3261    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    32623262
    32633263    AutoReadLock alock(this);
    … …  
    32793279
    32803280    AutoCaller autoCaller(this);
    3281     CheckComRCReturnRC(autoCaller.rc());
     3281    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    32823282
    32833283    AutoReadLock alock(this);
    … …  
    33373337
    33383338    AutoCaller autoCaller(this);
    3339     CheckComRCReturnRC(autoCaller.rc());
     3339    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33403340
    33413341    AutoReadLock alock(this);
    … …  
    33583358
    33593359    AutoCaller autoCaller(this);
    3360     CheckComRCReturnRC(autoCaller.rc());
     3360    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33613361
    33623362    AutoWriteLock alock(this);
    … …  
    34043404    //  - Appropriate handle errors like not supported file formats
    34053405    AutoCaller autoCaller(this);
    3406     CheckComRCReturnRC(autoCaller.rc());
     3406    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    34073407
    34083408    AutoWriteLock(this);
    … …  
    34163416    ComPtr<ISystemProperties> systemProps;
    34173417    rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
    3418     CheckComRCReturnRC(rc);
     3418    if (FAILED(rc)) return rc;
    34193419    Bstr bstrDefaultHardDiskLocation;
    34203420    rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
    3421     CheckComRCReturnRC(rc);
     3421    if (FAILED(rc)) return rc;
    34223422
    34233423    if (!m->pReader)
    … …  
    34383438            ComObjPtr<VirtualSystemDescription> pNewDesc;
    34393439            rc = pNewDesc.createObject();
    3440             CheckComRCThrowRC(rc);
     3440            if (FAILED(rc)) throw rc;
    34413441            rc = pNewDesc->init();
    3442             CheckComRCThrowRC(rc);
     3442            if (FAILED(rc)) throw rc;
    34433443
    34443444            /* Guest OS type */
    … …  
    35153515            ComPtr<IGuestOSType> pGuestOSType;
    35163516            rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
    3517             CheckComRCThrowRC(rc);
     3517            if (FAILED(rc)) throw rc;
    35183518
    35193519            /* CPU count */
    … …  
    35493549                ULONG memSizeVBox2;
    35503550                rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
    3551                 CheckComRCThrowRC(rc);
     3551                if (FAILED(rc)) throw rc;
    35523552                /* VBox stores that in MByte */
    35533553                ullMemSizeVBox = (uint64_t)memSizeVBox2;
    … …  
    35853585                NetworkAdapterType_T defaultAdapterVBox = NetworkAdapterType_Am79C970A;
    35863586                rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
    3587                 CheckComRCThrowRC(rc);
     3587                if (FAILED(rc)) throw rc;
    35883588
    35893589                EthernetAdaptersList::const_iterator itEA;
    … …  
    38513851
    38523852    AutoCaller autoCaller(this);
    3853     CheckComRCReturnRC(autoCaller.rc());
     3853    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    38543854
    38553855    AutoReadLock(this);
    … …  
    38823882
    38833883    AutoCaller autoCaller(this);
    3884     CheckComRCReturnRC(autoCaller.rc());
     3884    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    38853885
    38863886    AutoReadLock(this);
    … …  
    39163916
    39173917    AutoCaller autoCaller(this);
    3918     CheckComRCReturnRC(autoCaller.rc());
     3918    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    39193919
    39203920    AutoWriteLock(this);
    … …  
    39663966
    39673967    AutoCaller autoCaller(this);
    3968     CheckComRCReturnRC(autoCaller.rc());
     3968    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    39693969
    39703970    AutoReadLock alock(this);
    … …  
    40404040
    40414041    AutoCaller autoCaller(this);
    4042     CheckComRCReturnRC(autoCaller.rc());
     4042    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    40434043
    40444044    AutoReadLock alock(this);
    … …  
    40674067
    40684068    AutoCaller autoCaller(this);
    4069     CheckComRCReturnRC(autoCaller.rc());
     4069    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    40704070
    40714071    AutoReadLock alock(this);
    … …  
    41294129
    41304130    AutoCaller autoCaller(this);
    4131     CheckComRCReturnRC(autoCaller.rc());
     4131    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    41324132
    41334133    AutoReadLock alock(this);
    … …  
    41854185
    41864186    AutoCaller autoCaller(this);
    4187     CheckComRCReturnRC(autoCaller.rc());
     4187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    41884188
    41894189    AutoReadLock alock(this);
    … …  
    42344234
    42354235    AutoCaller autoCaller(this);
    4236     CheckComRCReturnRC(autoCaller.rc());
     4236    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    42374237
    42384238    AutoWriteLock alock(this);
    … …  
    42804280
    42814281    AutoCaller autoCaller(this);
    4282     CheckComRCReturnRC(autoCaller.rc());
     4282    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    42834283
    42844284    AutoWriteLock alock(this);
    … …  
    43924392
    43934393    AutoCaller autoCaller(this);
    4394     CheckComRCReturnRC(autoCaller.rc());
     4394    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    43954395
    43964396    AutoReadLock alock1(this);
    … …  
    44474447        // create a new virtual system
    44484448        rc = pNewDesc.createObject();
    4449         CheckComRCThrowRC(rc);
     4449        if (FAILED(rc)) throw rc;
    44504450        rc = pNewDesc->init();
    4451         CheckComRCThrowRC(rc);
     4451        if (FAILED(rc)) throw rc;
    44524452
    44534453        /* Guest OS type */
    … …  
    48244824        Appliance *pAppliance = static_cast<Appliance*>(aAppliance);
    48254825        AutoCaller autoCaller1(pAppliance);
    4826         CheckComRCReturnRC(autoCaller1.rc());
     4826        if (FAILED(autoCaller1.rc())) return autoCaller1.rc();
    48274827
    48284828        /* We return the new description to the caller */

  • trunk/src/VBox/Main/AudioAdapterImpl.cpp

    r22186 r25149  
    178178
    179179    AutoCaller autoCaller(this);
    180     CheckComRCReturnRC(autoCaller.rc());
     180    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    181181
    182182    AutoReadLock alock(this);
    … …  
    190190{
    191191    AutoCaller autoCaller(this);
    192     CheckComRCReturnRC(autoCaller.rc());
     192    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    193193
    194194    /* the machine needs to be mutable */
    195     Machine::AutoMutableStateDependency adep (mParent);
    196     CheckComRCReturnRC(adep.rc());
     195    Machine::AutoMutableStateDependency adep(mParent);
     196    if (FAILED(adep.rc())) return adep.rc();
    197197
    198198    AutoWriteLock alock(this);
    … …  
    212212
    213213    AutoCaller autoCaller(this);
    214     CheckComRCReturnRC(autoCaller.rc());
     214    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    215215
    216216    AutoReadLock alock(this);
    … …  
    224224{
    225225    AutoCaller autoCaller(this);
    226     CheckComRCReturnRC(autoCaller.rc());
     226    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    227227
    228228    /* the machine needs to be mutable */
    229     Machine::AutoMutableStateDependency adep (mParent);
    230     CheckComRCReturnRC(adep.rc());
     229    Machine::AutoMutableStateDependency adep(mParent);
     230    if (FAILED(adep.rc())) return adep.rc();
    231231
    232232    AutoWriteLock alock(this);
    … …  
    291291
    292292    AutoCaller autoCaller(this);
    293     CheckComRCReturnRC(autoCaller.rc());
     293    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    294294
    295295    AutoReadLock alock(this);
    … …  
    303303{
    304304    AutoCaller autoCaller(this);
    305     CheckComRCReturnRC(autoCaller.rc());
     305    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    306306
    307307    /* the machine needs to be mutable */
    308     Machine::AutoMutableStateDependency adep (mParent);
    309     CheckComRCReturnRC(adep.rc());
     308    Machine::AutoMutableStateDependency adep(mParent);
     309    if (FAILED(adep.rc())) return adep.rc();
    310310
    311311    AutoWriteLock alock(this);

  • trunk/src/VBox/Main/BIOSSettingsImpl.cpp

    r24000 r25149  
    160160
    161161    AutoCaller autoCaller(this);
    162     CheckComRCReturnRC(autoCaller.rc());
     162    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    163163
    164164    AutoReadLock alock(this);
    … …  
    172172{
    173173    AutoCaller autoCaller(this);
    174     CheckComRCReturnRC(autoCaller.rc());
    175 
    176     /* the machine needs to be mutable */
    177     Machine::AutoMutableStateDependency adep (mParent);
    178     CheckComRCReturnRC(adep.rc());
     174    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     175
     176    /* the machine needs to be mutable */
     177    Machine::AutoMutableStateDependency adep(mParent);
     178    if (FAILED(adep.rc())) return adep.rc();
    179179
    180180    AutoWriteLock alock(this);
    … …  
    192192
    193193    AutoCaller autoCaller(this);
    194     CheckComRCReturnRC(autoCaller.rc());
     194    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    195195
    196196    AutoReadLock alock(this);
    … …  
    204204{
    205205    AutoCaller autoCaller(this);
    206     CheckComRCReturnRC(autoCaller.rc());
    207 
    208     /* the machine needs to be mutable */
    209     Machine::AutoMutableStateDependency adep (mParent);
    210     CheckComRCReturnRC(adep.rc());
     206    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     207
     208    /* the machine needs to be mutable */
     209    Machine::AutoMutableStateDependency adep(mParent);
     210    if (FAILED(adep.rc())) return adep.rc();
    211211
    212212    AutoWriteLock alock(this);
    … …  
    224224
    225225    AutoCaller autoCaller(this);
    226     CheckComRCReturnRC(autoCaller.rc());
     226    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    227227
    228228    AutoReadLock alock(this);
    … …  
    236236{
    237237    AutoCaller autoCaller(this);
    238     CheckComRCReturnRC(autoCaller.rc());
    239 
    240     /* the machine needs to be mutable */
    241     Machine::AutoMutableStateDependency adep (mParent);
    242     CheckComRCReturnRC(adep.rc());
     238    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     239
     240    /* the machine needs to be mutable */
     241    Machine::AutoMutableStateDependency adep(mParent);
     242    if (FAILED(adep.rc())) return adep.rc();
    243243
    244244    AutoWriteLock alock(this);
    … …  
    256256
    257257    AutoCaller autoCaller(this);
    258     CheckComRCReturnRC(autoCaller.rc());
     258    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    259259
    260260    AutoReadLock alock(this);
    … …  
    271271
    272272    AutoCaller autoCaller(this);
    273     CheckComRCReturnRC(autoCaller.rc());
    274 
    275     /* the machine needs to be mutable */
    276     Machine::AutoMutableStateDependency adep (mParent);
    277     CheckComRCReturnRC(adep.rc());
     273    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     274
     275    /* the machine needs to be mutable */
     276    Machine::AutoMutableStateDependency adep(mParent);
     277    if (FAILED(adep.rc())) return adep.rc();
    278278
    279279    AutoWriteLock alock(this);
    … …  
    291291
    292292    AutoCaller autoCaller(this);
    293     CheckComRCReturnRC(autoCaller.rc());
     293    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    294294
    295295    AutoReadLock alock(this);
    … …  
    302302{
    303303    AutoCaller autoCaller(this);
    304     CheckComRCReturnRC(autoCaller.rc());
    305 
    306     /* the machine needs to be mutable */
    307     Machine::AutoMutableStateDependency adep (mParent);
    308     CheckComRCReturnRC(adep.rc());
     304    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     305
     306    /* the machine needs to be mutable */
     307    Machine::AutoMutableStateDependency adep(mParent);
     308    if (FAILED(adep.rc())) return adep.rc();
    309309
    310310    AutoWriteLock alock(this);
    … …  
    322322
    323323    AutoCaller autoCaller(this);
    324     CheckComRCReturnRC(autoCaller.rc());
     324    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    325325
    326326    AutoReadLock alock(this);
    … …  
    334334{
    335335    AutoCaller autoCaller(this);
    336     CheckComRCReturnRC(autoCaller.rc());
    337 
    338     /* the machine needs to be mutable */
    339     Machine::AutoMutableStateDependency adep (mParent);
    340     CheckComRCReturnRC(adep.rc());
     336    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     337
     338    /* the machine needs to be mutable */
     339    Machine::AutoMutableStateDependency adep(mParent);
     340    if (FAILED(adep.rc())) return adep.rc();
    341341
    342342    AutoWriteLock alock(this);
    … …  
    354354
    355355    AutoCaller autoCaller(this);
    356     CheckComRCReturnRC(autoCaller.rc());
     356    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    357357
    358358    AutoReadLock alock(this);
    … …  
    366366{
    367367    AutoCaller autoCaller(this);
    368     CheckComRCReturnRC(autoCaller.rc());
    369 
    370     /* the machine needs to be mutable */
    371     Machine::AutoMutableStateDependency adep (mParent);
    372     CheckComRCReturnRC(adep.rc());
     368    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     369
     370    /* the machine needs to be mutable */
     371    Machine::AutoMutableStateDependency adep(mParent);
     372    if (FAILED(adep.rc())) return adep.rc();
    373373
    374374    AutoWriteLock alock(this);
    … …  
    386386
    387387    AutoCaller autoCaller(this);
    388     CheckComRCReturnRC(autoCaller.rc());
     388    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    389389
    390390    AutoReadLock alock(this);
    … …  
    398398{
    399399    AutoCaller autoCaller(this);
    400     CheckComRCReturnRC(autoCaller.rc());
    401 
    402     /* the machine needs to be mutable */
    403     Machine::AutoMutableStateDependency adep (mParent);
    404     CheckComRCReturnRC(adep.rc());
     400    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     401
     402    /* the machine needs to be mutable */
     403    Machine::AutoMutableStateDependency adep(mParent);
     404    if (FAILED(adep.rc())) return adep.rc();
    405405
    406406    AutoWriteLock alock(this);
    … …  
    418418
    419419    AutoCaller autoCaller(this);
    420     CheckComRCReturnRC(autoCaller.rc());
     420    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    421421
    422422    AutoReadLock alock(this);
    … …  
    430430{
    431431    AutoCaller autoCaller(this);
    432     CheckComRCReturnRC(autoCaller.rc());
    433 
    434     /* the machine needs to be mutable */
    435     Machine::AutoMutableStateDependency adep (mParent);
    436     CheckComRCReturnRC(adep.rc());
     432    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     433
     434    /* the machine needs to be mutable */
     435    Machine::AutoMutableStateDependency adep(mParent);
     436    if (FAILED(adep.rc())) return adep.rc();
    437437
    438438    AutoWriteLock alock(this);

  • trunk/src/VBox/Main/ConsoleImpl.cpp

    r24989 r25149  
    14051405
    14061406    AutoCaller autoCaller(this);
    1407     CheckComRCReturnRC(autoCaller.rc());
     1407    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14081408
    14091409    /* mMachine is constant during life time, no need to lock */
    … …  
    14221422
    14231423    AutoCaller autoCaller(this);
    1424     CheckComRCReturnRC(autoCaller.rc());
     1424    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14251425
    14261426    AutoReadLock alock(this);
    … …  
    14371437
    14381438    AutoCaller autoCaller(this);
    1439     CheckComRCReturnRC(autoCaller.rc());
     1439    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14401440
    14411441    /* mGuest is constant during life time, no need to lock */
    … …  
    14501450
    14511451    AutoCaller autoCaller(this);
    1452     CheckComRCReturnRC(autoCaller.rc());
     1452    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14531453
    14541454    /* mKeyboard is constant during life time, no need to lock */
    … …  
    14631463
    14641464    AutoCaller autoCaller(this);
    1465     CheckComRCReturnRC(autoCaller.rc());
     1465    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14661466
    14671467    /* mMouse is constant during life time, no need to lock */
    … …  
    14761476
    14771477    AutoCaller autoCaller(this);
    1478     CheckComRCReturnRC(autoCaller.rc());
     1478    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14791479
    14801480    /* mDisplay is constant during life time, no need to lock */
    … …  
    14891489
    14901490    AutoCaller autoCaller(this);
    1491     CheckComRCReturnRC(autoCaller.rc());
     1491    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14921492
    14931493    /* we need a write lock because of the lazy mDebugger initialization*/
    … …  
    15111511
    15121512    AutoCaller autoCaller(this);
    1513     CheckComRCReturnRC(autoCaller.rc());
     1513    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15141514
    15151515    AutoReadLock alock(this);
    … …  
    15261526
    15271527    AutoCaller autoCaller(this);
    1528     CheckComRCReturnRC(autoCaller.rc());
     1528    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15291529
    15301530    AutoReadLock alock(this);
    … …  
    15411541
    15421542    AutoCaller autoCaller(this);
    1543     CheckComRCReturnRC(autoCaller.rc());
     1543    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15441544
    15451545    /* mDisplay is constant during life time, no need to lock */
    … …  
    15551555
    15561556    AutoCaller autoCaller(this);
    1557     CheckComRCReturnRC(autoCaller.rc());
     1557    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15581558
    15591559    /* loadDataFromSavedState() needs a write lock */
    … …  
    15621562    /* Read console data stored in the saved state file (if not yet done) */
    15631563    HRESULT rc = loadDataFromSavedState();
    1564     CheckComRCReturnRC(rc);
     1564    if (FAILED(rc)) return rc;
    15651565
    15661566    SafeIfaceArray<ISharedFolder> sf(mSharedFolders);
    … …  
    15941594
    15951595    AutoCaller autoCaller(this);
    1596     CheckComRCReturnRC(autoCaller.rc());
     1596    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15971597
    15981598    AutoWriteLock alock(this);
    … …  
    16761676
    16771677    AutoCaller autoCaller(this);
    1678     CheckComRCReturnRC(autoCaller.rc());
     1678    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16791679
    16801680    AutoWriteLock alock(this);
    … …  
    16911691    /* protect mpVM */
    16921692    AutoVMCaller autoVMCaller(this);
    1693     CheckComRCReturnRC(autoVMCaller.rc());
     1693    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    16941694
    16951695    /* leave the lock before a VMR3* call (EMT will call us back)! */
    … …  
    17131713
    17141714    AutoCaller autoCaller(this);
    1715     CheckComRCReturnRC(autoCaller.rc());
     1715    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17161716
    17171717    AutoWriteLock alock(this);
    … …  
    17371737    /* protect mpVM */
    17381738    AutoVMCaller autoVMCaller(this);
    1739     CheckComRCReturnRC(autoVMCaller.rc());
     1739    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    17401740
    17411741    LogFlowThisFunc(("Sending PAUSE request...\n"));
    … …  
    17601760
    17611761    AutoCaller autoCaller(this);
    1762     CheckComRCReturnRC(autoCaller.rc());
     1762    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17631763
    17641764    AutoWriteLock alock(this);
    … …  
    17711771    /* protect mpVM */
    17721772    AutoVMCaller autoVMCaller(this);
    1773     CheckComRCReturnRC(autoVMCaller.rc());
     1773    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    17741774
    17751775    LogFlowThisFunc(("Sending RESUME request...\n"));
    … …  
    17991799
    18001800    AutoCaller autoCaller(this);
    1801     CheckComRCReturnRC(autoCaller.rc());
     1801    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18021802
    18031803    AutoWriteLock alock(this);
    … …  
    18131813    /* protect mpVM */
    18141814    AutoVMCaller autoVMCaller(this);
    1815     CheckComRCReturnRC(autoVMCaller.rc());
     1815    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    18161816
    18171817    PPDMIBASE pBase;
    … …  
    18571857    /* protect mpVM */
    18581858    AutoVMCaller autoVMCaller(this);
    1859     CheckComRCReturnRC(autoVMCaller.rc());
     1859    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    18601860
    18611861    PPDMIBASE pBase;
    … …  
    19041904    /* protect mpVM */
    19051905    AutoVMCaller autoVMCaller(this);
    1906     CheckComRCReturnRC(autoVMCaller.rc());
     1906    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    19071907
    19081908    PPDMIBASE pBase;
    … …  
    19281928
    19291929    AutoCaller autoCaller(this);
    1930     CheckComRCReturnRC(autoCaller.rc());
     1930    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19311931
    19321932    AutoWriteLock alock(this);
    … …  
    19391939    /* protect mpVM */
    19401940    AutoVMCaller autoVMCaller(this);
    1941     CheckComRCReturnRC(autoVMCaller.rc());
     1941    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    19421942
    19431943    PPDMIBASE pBase;
    … …  
    19691969
    19701970    AutoCaller autoCaller(this);
    1971     CheckComRCReturnRC(autoCaller.rc());
     1971    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19721972
    19731973    AutoWriteLock alock(this);
    … …  
    19871987    {
    19881988        HRESULT rc = Pause();
    1989         CheckComRCReturnRC(rc);
     1989        if (FAILED(rc)) return rc;
    19901990    }
    19911991
    … …  
    20272027         */
    20282028        rc = mControl->BeginSavingState(progress, stateFilePath.asOutParam());
    2029         CheckComRCBreakRC(rc);
     2029        if (FAILED(rc)) break;
    20302030
    20312031        fBeganSavingState = true;
    … …  
    21072107
    21082108    AutoCaller autoCaller(this);
    2109     CheckComRCReturnRC(autoCaller.rc());
     2109    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21102110
    21112111    AutoWriteLock alock(this);
    … …  
    21252125{
    21262126    AutoCaller autoCaller(this);
    2127     CheckComRCReturnRC(autoCaller.rc());
     2127    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21282128
    21292129    AutoWriteLock alock(this);
    … …  
    21372137
    21382138    rc = mControl->SetRemoveSavedState(aRemove);
    2139     CheckComRCReturnRC(rc);
     2139    if (FAILED(rc)) return rc;
    21402140
    21412141    /*
    … …  
    21642164
    21652165    AutoCaller autoCaller(this);
    2166     CheckComRCReturnRC(autoCaller.rc());
     2166    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21672167
    21682168    /*
    … …  
    22482248#ifdef VBOX_WITH_USB
    22492249    AutoCaller autoCaller(this);
    2250     CheckComRCReturnRC(autoCaller.rc());
     2250    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22512251
    22522252    AutoWriteLock alock(this);
    … …  
    22602260    /* protect mpVM */
    22612261    AutoVMCaller autoVMCaller(this);
    2262     CheckComRCReturnRC(autoVMCaller.rc());
     2262    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    22632263
    22642264    /* Don't proceed unless we've found the usb controller. */
    … …  
    22752275    /* Request the device capture */
    22762276    HRESULT rc = mControl->CaptureUSBDevice(aId);
    2277     CheckComRCReturnRC(rc);
     2277    if (FAILED(rc)) return rc;
    22782278
    22792279    return rc;
    … …  
    22912291
    22922292    AutoCaller autoCaller(this);
    2293     CheckComRCReturnRC(autoCaller.rc());
     2293    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22942294
    22952295    AutoWriteLock alock(this);
    … …  
    23562356    SafeIfaceArray<IUSBDevice> devsvec;
    23572357    HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
    2358     CheckComRCReturnRC(rc);
     2358    if (FAILED(rc)) return rc;
    23592359
    23602360    for (size_t i = 0; i < devsvec.size(); ++i)
    … …  
    23622362        Bstr address;
    23632363        rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
    2364         CheckComRCReturnRC(rc);
     2364        if (FAILED(rc)) return rc;
    23652365        if (address == aAddress)
    23662366        {
    … …  
    23912391    SafeIfaceArray<IUSBDevice> devsvec;
    23922392    HRESULT rc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
    2393     CheckComRCReturnRC(rc);
     2393    if (FAILED(rc)) return rc;
    23942394
    23952395    for (size_t i = 0; i < devsvec.size(); ++i)
    … …  
    23972397        Bstr id;
    23982398        rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
    2399         CheckComRCReturnRC(rc);
     2399        if (FAILED(rc)) return rc;
    24002400        if (id == aId)
    24012401        {
    … …  
    24232423
    24242424    AutoCaller autoCaller(this);
    2425     CheckComRCReturnRC(autoCaller.rc());
     2425    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    24262426
    24272427    AutoWriteLock alock(this);
    … …  
    24502450    sharedFolder.createObject();
    24512451    rc = sharedFolder->init(this, aName, aHostPath, aWritable);
    2452     CheckComRCReturnRC(rc);
     2452    if (FAILED(rc)) return rc;
    24532453
    24542454    /* protect mpVM (if not NULL) */
    … …  
    24652465        {
    24662466            rc = removeSharedFolder(aName);
    2467             CheckComRCReturnRC(rc);
     2467            if (FAILED(rc)) return rc;
    24682468        }
    24692469
    24702470        /* second, create the given folder */
    24712471        rc = createSharedFolder(aName, SharedFolderData(aHostPath, aWritable));
    2472         CheckComRCReturnRC(rc);
     2472        if (FAILED(rc)) return rc;
    24732473    }
    24742474
    … …  
    24902490
    24912491    AutoCaller autoCaller(this);
    2492     CheckComRCReturnRC(autoCaller.rc());
     2492    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    24932493
    24942494    AutoWriteLock alock(this);
    … …  
    25102510    ComObjPtr<SharedFolder> sharedFolder;
    25112511    HRESULT rc = findSharedFolder(aName, sharedFolder, true /* aSetError */);
    2512     CheckComRCReturnRC(rc);
     2512    if (FAILED(rc)) return rc;
    25132513
    25142514    /* protect mpVM (if not NULL) */
    … …  
    25222522        /* first, remove the given folder */
    25232523        rc = removeSharedFolder(aName);
    2524         CheckComRCReturnRC(rc);
     2524        if (FAILED(rc)) return rc;
    25252525
    25262526        /* first, remove the machine or the global folder if there is any */
    … …  
    25572557
    25582558    AutoCaller autoCaller(this);
    2559     CheckComRCReturnRC(autoCaller.rc());
     2559    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25602560
    25612561    AutoWriteLock alock(this);
    … …  
    26862686
    26872687    AutoCaller autoCaller(this);
    2688     CheckComRCReturnRC(autoCaller.rc());
     2688    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    26892689
    26902690    AutoWriteLock alock(this);
    … …  
    26972697    MachineState_T machineState = MachineState_Null;
    26982698    HRESULT rc = mControl->DeleteSnapshot(this, aId, &machineState, aProgress);
    2699     CheckComRCReturnRC(rc);
     2699    if (FAILED(rc)) return rc;
    27002700
    27012701    setMachineStateLocally(machineState);
    … …  
    27062706{
    27072707    AutoCaller autoCaller(this);
    2708     CheckComRCReturnRC(autoCaller.rc());
     2708    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27092709
    27102710    AutoWriteLock alock(this);
    … …  
    27172717    MachineState_T machineState = MachineState_Null;
    27182718    HRESULT rc = mControl->RestoreSnapshot(this, aSnapshot, &machineState, aProgress);
    2719     CheckComRCReturnRC(rc);
     2719    if (FAILED(rc)) return rc;
    27202720
    27212721    setMachineStateLocally(machineState);
    … …  
    27282728
    27292729    AutoCaller autoCaller(this);
    2730     CheckComRCReturnRC(autoCaller.rc());
     2730    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27312731
    27322732#if 0 /** @todo r=bird,r=pritesh: must check that the interface id match correct or we might screw up with old code! */
    … …  
    27772777
    27782778    AutoCaller autoCaller(this);
    2779     CheckComRCReturnRC(autoCaller.rc());
     2779    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27802780
    27812781    AutoWriteLock alock(this);
    … …  
    30363036    /* protect mpVM */
    30373037    AutoVMCaller autoVMCaller(pThis);
    3038     CheckComRCReturnRC(autoVMCaller.rc());
     3038    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    30393039
    30403040    PVM pVM = pThis->mpVM;
    … …  
    32693269    /* protect mpVM */
    32703270    AutoVMCaller autoVMCaller(this);
    3271     CheckComRCReturnRC(autoVMCaller.rc());
     3271    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    32723272
    32733273    /* Get the properties we need from the adapter */
    … …  
    34083408    /* protect mpVM */
    34093409    AutoVMCaller autoVMCaller(this);
    3410     CheckComRCReturnRC(autoVMCaller.rc());
     3410    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    34113411
    34123412    /*
    … …  
    34823482    /* protect mpVM */
    34833483    AutoVMCaller autoVMCaller(pThis);
    3484     CheckComRCReturnRC(autoVMCaller.rc());
     3484    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    34853485
    34863486    PVM pVM = pThis->mpVM;
    … …  
    35823582    /* protect mpVM */
    35833583    AutoVMCaller autoVMCaller(this);
    3584     CheckComRCReturnRC(autoVMCaller.rc());
     3584    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    35853585
    35863586    /* nothing to do so far */
    … …  
    36203620    /* protect mpVM */
    36213621    AutoVMCaller autoVMCaller(this);
    3622     CheckComRCReturnRC(autoVMCaller.rc());
     3622    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    36233623
    36243624    /* nothing to do so far */
    … …  
    36583658    /* protect mpVM */
    36593659    AutoVMCaller autoVMCaller(this);
    3660     CheckComRCReturnRC(autoVMCaller.rc());
     3660    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    36613661
    36623662    /* nothing to do so far */
    … …  
    36963696    /* protect mpVM */
    36973697    AutoVMCaller autoVMCaller(this);
    3698     CheckComRCReturnRC(autoVMCaller.rc());
     3698    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    36993699
    37003700    rc = doMediumChange(aMediumAttachment, !!aForce);
    … …  
    38223822//    /* protect mpVM */
    38233823//    AutoVMCaller autoVMCaller(this);
    3824 //    CheckComRCReturnRC(autoVMCaller.rc());
     3824//    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    38253825
    38263826    /* notify console callbacks on success */
    … …  
    40434043    /* protect mpVM (if not NULL) */
    40444044    AutoVMCallerWeak autoVMCaller(this);
    4045     CheckComRCReturnRC(autoVMCaller.rc());
     4045    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    40464046
    40474047    /* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
    … …  
    41184118    /* protect mpVM (if not NULL) */
    41194119    AutoVMCallerWeak autoVMCaller(this);
    4120     CheckComRCReturnRC(autoVMCaller.rc());
     4120    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    41214121
    41224122    /* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
    … …  
    41984198    /* protect mpVM (if not NULL) */
    41994199    AutoVMCallerWeak autoVMCaller(this);
    4200     CheckComRCReturnRC(autoVMCaller.rc());
     4200    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    42014201
    42024202    /* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
    … …  
    45764576    Bstr logFolder;
    45774577    hrc = aMachine->COMGETTER(LogFolder)(logFolder.asOutParam());
    4578     CheckComRCReturnRC(hrc);
     4578    if (FAILED(hrc)) return hrc;
    45794579
    45804580    Utf8Str logDir = logFolder;
    … …  
    47154715
    47164716    AutoCaller autoCaller(this);
    4717     CheckComRCReturnRC(autoCaller.rc());
     4717    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    47184718
    47194719    AutoWriteLock alock(this);
    … …  
    47744774    /* Read console data stored in the saved state file (if not yet done) */
    47754775    rc = loadDataFromSavedState();
    4776     CheckComRCReturnRC(rc);
     4776    if (FAILED(rc)) return rc;
    47774777
    47784778    /* Check all types of shared folders and compose a single list */
    … …  
    48034803    {
    48044804        rc = mMachine->COMGETTER(StateFilePath)(savedStateFile.asOutParam());
    4805         CheckComRCReturnRC(rc);
     4805        if (FAILED(rc)) return rc;
    48064806        ComAssertRet(!!savedStateFile, E_FAIL);
    48074807        int vrc = SSMR3ValidateFile(Utf8Str(savedStateFile).c_str(), false /* fChecksumIt */);
    … …  
    48154815    BOOL fTeleporterEnabled;
    48164816    rc = mMachine->COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
    4817     CheckComRCReturnRC(rc);
     4817    if (FAILED(rc)) return rc;
    48184818#if 0 /** @todo we should save it afterwards, but that isn't necessarily a good idea. Find a better place for this (VBoxSVC).  */
    48194819    if (fTeleporterEnabled)
    48204820    {
    48214821        rc = mMachine->COMSETTER(TeleporterEnabled)(FALSE);
    4822         CheckComRCReturnRC(rc);
     4822        if (FAILED(rc)) return rc;
    48234823    }
    48244824#endif
    … …  
    48374837                               progressDesc,
    48384838                               fTeleporterEnabled /* aCancelable */);
    4839     CheckComRCReturnRC(rc);
     4839    if (FAILED(rc)) return rc;
    48404840
    48414841    /* setup task object and thread to carry out the operation
    … …  
    48634863    ComPtr<ISnapshot> pCurrentSnapshot;
    48644864    rc = mMachine->COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam());
    4865     CheckComRCReturnRC(rc);
     4865    if (FAILED(rc)) return rc;
    48664866
    48674867    BOOL fCurrentSnapshotIsOnline = false;
    … …  
    48694869    {
    48704870        rc = pCurrentSnapshot->COMGETTER(Online)(&fCurrentSnapshotIsOnline);
    4871         CheckComRCReturnRC(rc);
     4871        if (FAILED(rc)) return rc;
    48724872    }
    48734873
    … …  
    48784878        com::SafeIfaceArray<IMediumAttachment> atts;
    48794879        rc = mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
    4880         CheckComRCReturnRC(rc);
     4880        if (FAILED(rc)) return rc;
    48814881
    48824882        for (size_t i = 0;
    … …  
    48914891                ComPtr<IMedium> medium;
    48924892                rc = atts[i]->COMGETTER(Medium)(medium.asOutParam());
    4893                 CheckComRCReturnRC(rc);
     4893                if (FAILED(rc)) return rc;
    48944894
    48954895                /* save for later use on the powerup thread */
    … …  
    48994899                BOOL autoReset = FALSE;
    49004900                rc = medium->COMGETTER(AutoReset)(&autoReset);
    4901                 CheckComRCReturnRC(rc);
     4901                if (FAILED(rc)) return rc;
    49024902
    49034903                if (autoReset)
    … …  
    49054905                    ComPtr<IProgress> resetProgress;
    49064906                    rc = medium->Reset(resetProgress.asOutParam());
    4907                     CheckComRCReturnRC(rc);
     4907                    if (FAILED(rc)) return rc;
    49084908
    49094909                    /* save for later use on the powerup thread */
    … …  
    49174917
    49184918    rc = consoleInitReleaseLog(mMachine);
    4919     CheckComRCReturnRC(rc);
     4919    if (FAILED(rc)) return rc;
    49204920
    49214921    /* pass the progress object to the caller if requested */
    … …  
    54235423
    54245424            rc = folder->COMGETTER(Name)(name.asOutParam());
    5425             CheckComRCBreakRC(rc);
     5425            if (FAILED(rc)) break;
    54265426            rc = folder->COMGETTER(HostPath)(hostPath.asOutParam());
    5427             CheckComRCBreakRC(rc);
     5427            if (FAILED(rc)) break;
    54285428            rc = folder->COMGETTER(Writable)(&writable);
    54295429
    … …  
    59775977    /* protect mpVM */
    59785978    AutoVMCaller autoVMCaller(this);
    5979     CheckComRCReturnRC(autoVMCaller.rc());
     5979    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    59805980
    59815981    LogFlowThisFunc(("Proxying USB device '%s' {%RTuuid}...\n",
    … …  
    60966096    /* protect mpVM */
    60976097    AutoVMCaller autoVMCaller(this);
    6098     CheckComRCReturnRC(autoVMCaller.rc());
     6098    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
    60996099
    61006100    /* if the device is attached, then there must at least one USB hub. */
    … …  
    64276427        ComPtr<INetworkAdapter> networkAdapter;
    64286428        rc = mMachine->GetNetworkAdapter(slot, networkAdapter.asOutParam());
    6429         CheckComRCBreakRC(rc);
     6429        if (FAILED(rc)) break;
    64306430
    64316431        BOOL enabled = FALSE;
    … …  
    68406840        {
    68416841            rc = console->mControl->LockMedia();
    6842             CheckComRCThrowRC(rc);
     6842            if (FAILED(rc)) throw rc;
    68436843        }
    68446844
    … …  
    69586958                    {
    69596959                        rc = console->createSharedFolder((*it).first, (*it).second);
    6960                         CheckComRCBreakRC(rc);
     6960                        if (FAILED(rc)) break;
    69616961                    }
     6962                    if (FAILED(rc)) break;
    69626963
    69636964                    /* enter the lock again */
    69646965                    alock.enter();
    6965 
    6966                     CheckComRCBreakRC(rc);
    69676966                }
    69686967
    … …  
    69716970                 */
    69726971                rc = console->captureUSBDevices(pVM);
    6973                 CheckComRCBreakRC(rc);
     6972                if (FAILED(rc)) break;
    69746973
    69756974                /* leave the lock before a lengthy operation */

  • trunk/src/VBox/Main/ConsoleImplTeleporter.cpp

    r24989 r25149  
    610610{
    611611    AutoCaller autoCaller(this);
    612     CheckComRCReturnRC(autoCaller.rc());
     612    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    613613
    614614    /*
    … …  
    906906
    907907    AutoCaller autoCaller(this);
    908     CheckComRCReturnRC(autoCaller.rc());
     908    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    909909
    910910    AutoWriteLock autoLock(this);
    … …  
    932932    ComObjPtr<Progress> ptrProgress;
    933933    HRESULT hrc = ptrProgress.createObject();
    934     CheckComRCReturnRC(hrc);
     934    if (FAILED(hrc)) return hrc;
    935935    hrc = ptrProgress->init(static_cast<IConsole *>(this), Bstr(tr("Teleporter")), TRUE /*aCancelable*/);
    936     CheckComRCReturnRC(hrc);
     936    if (FAILED(hrc)) return hrc;
    937937
    938938    TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpVM, ptrProgress, mMachineState);

  • trunk/src/VBox/Main/ConsoleVRDPServer.cpp

    r25030 r25149  
    765765
    766766            ULONG port = *(uint32_t *)pvBuffer;
    767            
     767
    768768            server->mVRDPBindPort = port;
    769769
    … …  
    21722172            return E_POINTER;                                             \
    21732173                                                                          \
    2174         AutoCaller autoCaller(this);                                     \
    2175         CheckComRCReturnRC(autoCaller.rc());                             \
     2174        AutoCaller autoCaller(this);                                      \
     2175        if (FAILED(autoCaller.rc())) return autoCaller.rc();              \
    21762176                                                                          \
    21772177        /* todo: Not sure if a AutoReadLock would be sufficient. */       \
    2178         AutoWriteLock alock(this);                                       \
     2178        AutoWriteLock alock(this);                                        \
    21792179                                                                          \
    21802180        uint32_t value;                                                   \
    … …  
    21952195            return E_POINTER;                                             \
    21962196                                                                          \
    2197         AutoCaller autoCaller(this);                                     \
    2198         CheckComRCReturnRC(autoCaller.rc());                             \
     2197        AutoCaller autoCaller(this);                                      \
     2198        if (FAILED(autoCaller.rc())) return autoCaller.rc();              \
    21992199                                                                          \
    22002200        /* todo: Not sure if a AutoReadLock would be sufficient. */       \
    2201         AutoWriteLock alock(this);                                       \
     2201        AutoWriteLock alock(this);                                        \
    22022202                                                                          \
    22032203        _aType value;                                                     \
    … …  
    22182218            return E_POINTER;                                             \
    22192219                                                                          \
    2220         AutoCaller autoCaller(this);                                     \
    2221         CheckComRCReturnRC(autoCaller.rc());                             \
     2220        AutoCaller autoCaller(this);                                      \
     2221        if (FAILED(autoCaller.rc())) return autoCaller.rc();              \
    22222222                                                                          \
    22232223        /* todo: Not sure if a AutoReadLock would be sufficient. */       \
    2224         AutoWriteLock alock(this);                                       \
     2224        AutoWriteLock alock(this);                                        \
    22252225                                                                          \
    22262226        uint32_t cbOut = 0;                                               \
    … …  
    22322232        {                                                                 \
    22332233            Bstr str("");                                                 \
    2234             str.cloneTo(a##_aName);                                      \
     2234            str.cloneTo(a##_aName);                                       \
    22352235            return S_OK;                                                  \
    22362236        }                                                                 \
    … …  
    22512251        Bstr str(pchBuffer);                                              \
    22522252                                                                          \
    2253         str.cloneTo(a##_aName);                                          \
     2253        str.cloneTo(a##_aName);                                           \
    22542254                                                                          \
    22552255        RTMemTmpFree (pchBuffer);                                         \

  • trunk/src/VBox/Main/DHCPServerImpl.cpp

    r23319 r25149  
    115115{
    116116    AutoCaller autoCaller(this);
    117     CheckComRCReturnRC(autoCaller.rc());
     117    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    118118
    119119    AutoReadLock alock(this);
    … …  
    134134
    135135    AutoCaller autoCaller(this);
    136     CheckComRCReturnRC(autoCaller.rc());
     136    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    137137
    138138    mName.cloneTo(aName);
    … …  
    146146
    147147    AutoCaller autoCaller(this);
    148     CheckComRCReturnRC(autoCaller.rc());
     148    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    149149
    150150    *aEnabled = m.enabled;
    … …  
    156156{
    157157    AutoCaller autoCaller(this);
    158     CheckComRCReturnRC(autoCaller.rc());
     158    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    159159
    160160    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    173173
    174174    AutoCaller autoCaller(this);
    175     CheckComRCReturnRC(autoCaller.rc());
     175    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    176176
    177177    m.IPAddress.cloneTo(aIPAddress);
    … …  
    185185
    186186    AutoCaller autoCaller(this);
    187     CheckComRCReturnRC(autoCaller.rc());
     187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    188188
    189189    m.networkMask.cloneTo(aNetworkMask);
    … …  
    197197
    198198    AutoCaller autoCaller(this);
    199     CheckComRCReturnRC(autoCaller.rc());
     199    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    200200
    201201    m.lowerIP.cloneTo(aIPAddress);
    … …  
    209209
    210210    AutoCaller autoCaller(this);
    211     CheckComRCReturnRC(autoCaller.rc());
     211    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    212212
    213213    m.upperIP.cloneTo(aIPAddress);
    … …  
    224224
    225225    AutoCaller autoCaller(this);
    226     CheckComRCReturnRC(autoCaller.rc());
     226    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    227227
    228228    /* VirtualBox::saveSettings() needs a write lock */

  • trunk/src/VBox/Main/DisplayImpl.cpp

    r25126 r25149  
    224224                return;
    225225            }
    226            
     226
    227227            pCtx->pu8PNG = (uint8_t *)pNew;
    228228            pCtx->cbAllocated = cbNew;
    … …  
    373373                }
    374374
    375                 png_destroy_write_struct(&png_ptr, info_ptr ? &info_ptr 
     375                png_destroy_write_struct(&png_ptr, info_ptr ? &info_ptr
    376376                                                            : (png_infopp)NULL);
    377377            }
    … …  
    12471247}
    12481248#endif /* VBOX_WITH_OLD_VBVA_LOCK */
    1249    
     1249
    12501250/**
    12511251 * @thread EMT
    … …  
    19401940
    19411941    AutoCaller autoCaller(this);
    1942     CheckComRCReturnRC(autoCaller.rc());
     1942    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19431943
    19441944    AutoWriteLock alock(this);
    … …  
    19621962
    19631963    AutoCaller autoCaller(this);
    1964     CheckComRCReturnRC(autoCaller.rc());
     1964    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19651965
    19661966    AutoWriteLock alock(this);
    … …  
    19851985
    19861986    AutoCaller autoCaller(this);
    1987     CheckComRCReturnRC(autoCaller.rc());
     1987    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19881988
    19891989    AutoWriteLock alock(this);
    … …  
    20122012
    20132013    AutoCaller autoCaller(this);
    2014     CheckComRCReturnRC(autoCaller.rc());
     2014    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20152015
    20162016    AutoWriteLock alock(this);
    … …  
    20492049
    20502050    AutoCaller autoCaller(this);
    2051     CheckComRCReturnRC(autoCaller.rc());
     2051    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20522052
    20532053    AutoWriteLock alock(this);
    … …  
    20712071{
    20722072    AutoCaller autoCaller(this);
    2073     CheckComRCReturnRC(autoCaller.rc());
     2073    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20742074
    20752075    AutoWriteLock alock(this);
    … …  
    21212121{
    21222122    AutoCaller autoCaller(this);
    2123     CheckComRCReturnRC(autoCaller.rc());
     2123    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21242124
    21252125    AutoWriteLock alock(this);
    … …  
    22182218
    22192219    AutoCaller autoCaller(this);
    2220     CheckComRCReturnRC(autoCaller.rc());
     2220    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22212221
    22222222    AutoWriteLock alock(this);
    … …  
    22242224    CHECK_CONSOLE_DRV (mpDrv);
    22252225
    2226     Console::SafeVMPtr pVM (mParent);
    2227     CheckComRCReturnRC(pVM.rc());
     2226    Console::SafeVMPtr pVM(mParent);
     2227    if (FAILED(pVM.rc())) return pVM.rc();
    22282228
    22292229    HRESULT rc = S_OK;
    … …  
    22682268
    22692269    AutoCaller autoCaller(this);
    2270     CheckComRCReturnRC(autoCaller.rc());
     2270    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22712271
    22722272    AutoWriteLock alock(this);
    … …  
    22742274    CHECK_CONSOLE_DRV (mpDrv);
    22752275
    2276     Console::SafeVMPtr pVM (mParent);
    2277     CheckComRCReturnRC(pVM.rc());
     2276    Console::SafeVMPtr pVM(mParent);
     2277    if (FAILED(pVM.rc())) return pVM.rc();
    22782278
    22792279    HRESULT rc = S_OK;
    … …  
    23612361
    23622362    AutoCaller autoCaller(this);
    2363     CheckComRCReturnRC(autoCaller.rc());
     2363    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    23642364
    23652365    AutoWriteLock alock(this);
    … …  
    23672367    CHECK_CONSOLE_DRV (mpDrv);
    23682368
    2369     Console::SafeVMPtr pVM (mParent);
    2370     CheckComRCReturnRC(pVM.rc());
     2369    Console::SafeVMPtr pVM(mParent);
     2370    if (FAILED(pVM.rc())) return pVM.rc();
    23712371
    23722372    /*
    … …  
    24272427
    24282428    AutoCaller autoCaller(this);
    2429     CheckComRCReturnRC(autoCaller.rc());
     2429    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    24302430
    24312431    AutoWriteLock alock(this);
    … …  
    24332433    CHECK_CONSOLE_DRV (mpDrv);
    24342434
    2435     Console::SafeVMPtr pVM (mParent);
    2436     CheckComRCReturnRC(pVM.rc());
     2435    Console::SafeVMPtr pVM(mParent);
     2436    if (FAILED(pVM.rc())) return pVM.rc();
    24372437
    24382438    HRESULT rc = S_OK;
    … …  
    24812481    //  milliseconds).
    24822482    AutoCaller autoCaller(this);
    2483     CheckComRCReturnRC(autoCaller.rc());
     2483    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    24842484
    24852485    /* this is only valid for external framebuffers */
    … …  
    25172517    //  milliseconds).
    25182518    AutoCaller autoCaller(this);
    2519     CheckComRCReturnRC(autoCaller.rc());
     2519    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25202520
    25212521    /* this is only valid for external framebuffers */
    … …  
    26462646
    26472647    AutoCaller autoCaller(that);
    2648     CheckComRCReturnRC(autoCaller.rc());
     2648    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    26492649
    26502650    AutoWriteLock alock(that);

  • trunk/src/VBox/Main/GuestImpl.cpp

    r21878 r25149  
    121121
    122122    AutoCaller autoCaller(this);
    123     CheckComRCReturnRC(autoCaller.rc());
     123    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    124124
    125125    AutoReadLock alock(this);
    … …  
    139139
    140140    AutoCaller autoCaller(this);
    141     CheckComRCReturnRC(autoCaller.rc());
     141    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    142142
    143143    AutoReadLock alock(this);
    … …  
    153153
    154154    AutoCaller autoCaller(this);
    155     CheckComRCReturnRC(autoCaller.rc());
     155    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    156156
    157157    AutoReadLock alock(this);
    … …  
    167167
    168168    AutoCaller autoCaller(this);
    169     CheckComRCReturnRC(autoCaller.rc());
     169    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    170170
    171171    AutoReadLock alock(this);
    … …  
    181181
    182182    AutoCaller autoCaller(this);
    183     CheckComRCReturnRC(autoCaller.rc());
     183    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    184184
    185185    AutoReadLock alock(this);
    … …  
    195195
    196196    AutoCaller autoCaller(this);
    197     CheckComRCReturnRC(autoCaller.rc());
     197    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    198198
    199199    AutoReadLock alock(this);
    … …  
    207207{
    208208    AutoCaller autoCaller(this);
    209     CheckComRCReturnRC(autoCaller.rc());
     209    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    210210
    211211    AutoWriteLock alock(this);
    … …  
    229229
    230230    AutoCaller autoCaller(this);
    231     CheckComRCReturnRC(autoCaller.rc());
     231    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    232232
    233233    AutoReadLock alock(this);
    … …  
    241241{
    242242    AutoCaller autoCaller(this);
    243     CheckComRCReturnRC(autoCaller.rc());
     243    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    244244
    245245    AutoWriteLock alock(this);
    … …  
    266266
    267267    AutoCaller autoCaller(this);
    268     CheckComRCReturnRC(autoCaller.rc());
     268    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    269269
    270270    /* forward the information to the VMM device */

  • trunk/src/VBox/Main/GuestOSTypeImpl.cpp

    r21878 r25149  
    131131
    132132    AutoCaller autoCaller(this);
    133     CheckComRCReturnRC(autoCaller.rc());
     133    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    134134
    135135    /* mFamilyID is constant during life time, no need to lock */
    … …  
    144144
    145145    AutoCaller autoCaller(this);
    146     CheckComRCReturnRC(autoCaller.rc());
     146    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    147147
    148148    /* mFamilyDescription is constant during life time, no need to lock */
    … …  
    157157
    158158    AutoCaller autoCaller(this);
    159     CheckComRCReturnRC(autoCaller.rc());
     159    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    160160
    161161    /* mID is constant during life time, no need to lock */
    … …  
    170170
    171171    AutoCaller autoCaller(this);
    172     CheckComRCReturnRC(autoCaller.rc());
     172    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    173173
    174174    /* mDescription is constant during life time, no need to lock */
    … …  
    183183
    184184    AutoCaller autoCaller(this);
    185     CheckComRCReturnRC(autoCaller.rc());
     185    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    186186
    187187    /* mIs64Bit is constant during life time, no need to lock */
    … …  
    196196
    197197    AutoCaller autoCaller(this);
    198     CheckComRCReturnRC(autoCaller.rc());
     198    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    199199
    200200    /* mRecommendedIOAPIC is constant during life time, no need to lock */
    … …  
    209209
    210210    AutoCaller autoCaller(this);
    211     CheckComRCReturnRC(autoCaller.rc());
     211    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    212212
    213213    /* mRecommendedVirtEx is constant during life time, no need to lock */
    … …  
    222222
    223223    AutoCaller autoCaller(this);
    224     CheckComRCReturnRC(autoCaller.rc());
     224    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    225225
    226226    /* mRAMSize is constant during life time, no need to lock */
    … …  
    235235
    236236    AutoCaller autoCaller(this);
    237     CheckComRCReturnRC(autoCaller.rc());
     237    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    238238
    239239    /* mVRAMSize is constant during life time, no need to lock */
    … …  
    248248
    249249    AutoCaller autoCaller(this);
    250     CheckComRCReturnRC(autoCaller.rc());
     250    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    251251
    252252    /* mHDDSize is constant during life time, no need to lock */
    … …  
    261261
    262262    AutoCaller autoCaller(this);
    263     CheckComRCReturnRC(autoCaller.rc());
     263    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    264264
    265265    /* mNetworkAdapterType is constant during life time, no need to lock */

  • trunk/src/VBox/Main/HostImpl.cpp

    r24989 r25149  
    386386
    387387    AutoCaller autoCaller(this);
    388     CheckComRCReturnRC(autoCaller.rc());
     388    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    389389
    390390    AutoWriteLock alock(this);
    … …  
    510510
    511511    AutoCaller autoCaller(this);
    512     CheckComRCReturnRC(autoCaller.rc());
     512    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    513513
    514514    AutoWriteLock alock(this);
    … …  
    628628
    629629    AutoCaller autoCaller(this);
    630     CheckComRCReturnRC(autoCaller.rc());
     630    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    631631
    632632    AutoWriteLock alock(this);
    … …  
    909909
    910910    AutoCaller autoCaller(this);
    911     CheckComRCReturnRC(autoCaller.rc());
     911    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    912912
    913913    AutoWriteLock alock(this);
    914914
    915915    MultiResult rc = checkUSBProxyService();
    916     CheckComRCReturnRC(rc);
     916    if (FAILED(rc)) return rc;
    917917
    918918    return m->pUSBProxyService->getDeviceCollection(ComSafeArrayOutArg(aUSBDevices));
    … …  
    936936
    937937    AutoCaller autoCaller(this);
    938     CheckComRCReturnRC(autoCaller.rc());
     938    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    939939
    940940    AutoMultiWriteLock2 alock(this->lockHandle(), &m->treeLock);
    941941
    942942    MultiResult rc = checkUSBProxyService();
    943     CheckComRCReturnRC(rc);
     943    if (FAILED(rc)) return rc;
    944944
    945945    SafeIfaceArray<IHostUSBDeviceFilter> collection(m->llUSBDeviceFilters);
    … …  
    10361036    CheckComArgOutPointerValid(aSupported);
    10371037    AutoCaller autoCaller(this);
    1038     CheckComRCReturnRC(autoCaller.rc());
     1038    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10391039
    10401040    AutoReadLock alock(this);
    … …  
    12221222    CheckComArgOutPointerValid(aSupported);
    12231223    AutoCaller autoCaller(this);
    1224     CheckComRCReturnRC(autoCaller.rc());
     1224    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12251225
    12261226    AutoReadLock alock(this);
    … …  
    12381238
    12391239    AutoCaller autoCaller(this);
    1240     CheckComRCReturnRC(autoCaller.rc());
     1240    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12411241
    12421242    AutoWriteLock alock(this);
    … …  
    12551255
    12561256    AutoCaller autoCaller(this);
    1257     CheckComRCReturnRC(autoCaller.rc());
     1257    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12581258
    12591259    AutoWriteLock alock(this);
    … …  
    12841284
    12851285    AutoCaller autoCaller(this);
    1286     CheckComRCReturnRC(autoCaller.rc());
     1286    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12871287
    12881288    AutoWriteLock alock(this);
    … …  
    13131313    /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
    13141314    AutoCaller autoCaller(this);
    1315     CheckComRCReturnRC(autoCaller.rc());
     1315    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13161316
    13171317    AutoMultiWriteLock2 alock(this->lockHandle(), &m->treeLock);
    13181318
    13191319    MultiResult rc = checkUSBProxyService();
    1320     CheckComRCReturnRC(rc);
     1320    if (FAILED(rc)) return rc;
    13211321
    13221322    ComObjPtr<HostUSBDeviceFilter> pFilter;
    … …  
    13731373    /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
    13741374    AutoCaller autoCaller(this);
    1375     CheckComRCReturnRC(autoCaller.rc());
     1375    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13761376
    13771377    AutoMultiWriteLock2 alock(this->lockHandle(), &m->treeLock);
    13781378
    13791379    MultiResult rc = checkUSBProxyService();
    1380     CheckComRCReturnRC(rc);
     1380    if (FAILED(rc)) return rc;
    13811381
    13821382    if (!m->llUSBDeviceFilters.size())
    … …  
    14301430    SafeIfaceArray<IMedium> drivevec;
    14311431    HRESULT rc = COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(drivevec));
    1432     CheckComRCReturnRC(rc);
     1432    if (FAILED(rc)) return rc;
    14331433
    14341434    for (size_t i = 0; i < drivevec.size(); ++i)
    … …  
    14371437        Bstr name, location;
    14381438        rc = drive->COMGETTER(Name)(name.asOutParam());
    1439         CheckComRCReturnRC(rc);
     1439        if (FAILED(rc)) return rc;
    14401440        rc = drive->COMGETTER(Location)(location.asOutParam());
    1441         CheckComRCReturnRC(rc);
     1441        if (FAILED(rc)) return rc;
    14421442        if (name == aName || location == aName)
    14431443            return drive.queryInterfaceTo(aDrive);
    … …  
    14571457    SafeIfaceArray<IMedium> drivevec;
    14581458    HRESULT rc = COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(drivevec));
    1459     CheckComRCReturnRC(rc);
     1459    if (FAILED(rc)) return rc;
    14601460
    14611461    for (size_t i = 0; i < drivevec.size(); ++i)
    … …  
    14641464        Bstr name;
    14651465        rc = drive->COMGETTER(Name)(name.asOutParam());
    1466         CheckComRCReturnRC(rc);
     1466        if (FAILED(rc)) return rc;
    14671467        if (name == aName)
    14681468            return drive.queryInterfaceTo(aDrive);
    … …  
    15911591    SafeIfaceArray<IHostUSBDevice> devsvec;
    15921592    HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
    1593     CheckComRCReturnRC(rc);
     1593    if (FAILED(rc)) return rc;
    15941594
    15951595    for (size_t i = 0; i < devsvec.size(); ++i)
    … …  
    15971597        Bstr address;
    15981598        rc = devsvec[i]->COMGETTER(Address) (address.asOutParam());
    1599         CheckComRCReturnRC(rc);
     1599        if (FAILED(rc)) return rc;
    16001600        if (address == aAddress)
    16011601        {
    … …  
    16261626    SafeIfaceArray<IHostUSBDevice> devsvec;
    16271627    HRESULT rc = COMGETTER(USBDevices) (ComSafeArrayAsOutParam(devsvec));
    1628     CheckComRCReturnRC(rc);
     1628    if (FAILED(rc)) return rc;
    16291629
    16301630    for (size_t i = 0; i < devsvec.size(); ++i)
    … …  
    16321632        Bstr id;
    16331633        rc = devsvec[i]->COMGETTER(Id) (id.asOutParam());
    1634         CheckComRCReturnRC(rc);
     1634        if (FAILED(rc)) return rc;
    16351635        if (id == aId)
    16361636        {
    … …  
    16581658#ifdef VBOX_WITH_USB
    16591659    AutoCaller autoCaller(this);
    1660     CheckComRCReturnRC(autoCaller.rc());
     1660    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16611661
    16621662    AutoMultiWriteLock2 alock(this->lockHandle(), &m->treeLock);
    … …  
    16711671        pFilter.createObject();
    16721672        rc = pFilter->init(this, f);
    1673         CheckComRCBreakRC (rc);
     1673        if (FAILED(rc)) break;
    16741674
    16751675        m->llUSBDeviceFilters.push_back(pFilter);
    … …  
    16931693#ifdef VBOX_WITH_USB
    16941694    AutoCaller autoCaller(this);
    1695     CheckComRCReturnRC(autoCaller.rc());
     1695    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16961696
    16971697    AutoReadLock alock(&m->treeLock);
    … …  
    17241724{
    17251725    AutoCaller autoCaller(this);
    1726     CheckComRCReturnRC(autoCaller.rc());
     1726    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17271727
    17281728    AutoWriteLock alock(&m->treeLock);
    … …  
    17361736{
    17371737    AutoCaller autoCaller(this);
    1738     CheckComRCReturnRC(autoCaller.rc());
     1738    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17391739
    17401740    AutoWriteLock alock(&m->treeLock);
    … …  
    17661766{
    17671767    AutoCaller autoCaller(this);
    1768     CheckComRCReturnRC(autoCaller.rc());
     1768    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17691769
    17701770    AutoWriteLock alock(this);
    … …  
    23272327{
    23282328    AutoCaller autoCaller(this);
    2329     CheckComRCReturnRC(autoCaller.rc());
     2329    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    23302330
    23312331    AutoWriteLock alock(this);

  • trunk/src/VBox/Main/HostNetworkInterfaceImpl.cpp

    r21878 r25149  
    167167
    168168    AutoCaller autoCaller(this);
    169     CheckComRCReturnRC(autoCaller.rc());
     169    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    170170
    171171    mInterfaceName.cloneTo(aInterfaceName);
    … …  
    185185
    186186    AutoCaller autoCaller(this);
    187     CheckComRCReturnRC(autoCaller.rc());
     187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    188188
    189189    mGuid.toUtf16().cloneTo(aGuid);
    … …  
    197197
    198198    AutoCaller autoCaller(this);
    199     CheckComRCReturnRC(autoCaller.rc());
     199    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    200200
    201201    *aDhcpEnabled = m.dhcpEnabled;
    … …  
    216216
    217217    AutoCaller autoCaller(this);
    218     CheckComRCReturnRC(autoCaller.rc());
     218    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    219219
    220220    if (m.IPAddress == 0)
    … …  
    251251
    252252    AutoCaller autoCaller(this);
    253     CheckComRCReturnRC(autoCaller.rc());
     253    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    254254
    255255    if (m.networkMask == 0)
    … …  
    298298
    299299    AutoCaller autoCaller(this);
    300     CheckComRCReturnRC(autoCaller.rc());
     300    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    301301
    302302    m.IPV6Address.cloneTo(aIPV6Address);
    … …  
    316316
    317317    AutoCaller autoCaller(this);
    318     CheckComRCReturnRC(autoCaller.rc());
     318    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    319319
    320320    *aIPV6NetworkMaskPrefixLength = m.IPV6NetworkMaskPrefixLength;
    … …  
    334334
    335335    AutoCaller autoCaller(this);
    336     CheckComRCReturnRC(autoCaller.rc());
     336    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    337337
    338338    m.hardwareAddress.cloneTo(aHardwareAddress);
    … …  
    352352
    353353    AutoCaller autoCaller(this);
    354     CheckComRCReturnRC(autoCaller.rc());
     354    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    355355
    356356    *aType = m.mediumType;
    … …  
    370370
    371371    AutoCaller autoCaller(this);
    372     CheckComRCReturnRC(autoCaller.rc());
     372    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    373373
    374374    *aStatus = m.status;
    … …  
    388388
    389389    AutoCaller autoCaller(this);
    390     CheckComRCReturnRC(autoCaller.rc());
     390    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    391391
    392392    *aType = mIfType;
    … …  
    399399{
    400400    AutoCaller autoCaller(this);
    401     CheckComRCReturnRC(autoCaller.rc());
     401    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    402402
    403403    Utf8Str utf8Name("HostInterfaceNetworking-");
    … …  
    415415#else
    416416    AutoCaller autoCaller(this);
    417     CheckComRCReturnRC(autoCaller.rc());
     417    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    418418
    419419    if (Bstr(aIPAddress).isEmpty())
    … …  
    482482
    483483    AutoCaller autoCaller(this);
    484     CheckComRCReturnRC(autoCaller.rc());
     484    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    485485
    486486    int rc = S_OK;
    … …  
    517517#else
    518518    AutoCaller autoCaller(this);
    519     CheckComRCReturnRC(autoCaller.rc());
     519    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    520520
    521521    int rc = NetIfEnableDynamicIpConfig(mVBox, this);
    … …  
    535535#else
    536536    AutoCaller autoCaller(this);
    537     CheckComRCReturnRC(autoCaller.rc());
     537    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    538538
    539539    int rc = NetIfDhcpRediscover(mVBox, this);
    … …  
    551551    HRESULT hrc;
    552552    AutoCaller autoCaller(this);
    553     CheckComRCReturnRC(autoCaller.rc());
     553    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    554554    mVBox = pVBox;
    555555

  • trunk/src/VBox/Main/KeyboardImpl.cpp

    r22277 r25149  
    135135
    136136    AutoCaller autoCaller(this);
    137     CheckComRCReturnRC(autoCaller.rc());
     137    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    138138
    139139    AutoWriteLock alock(this);
    … …  
    170170
    171171    AutoCaller autoCaller(this);
    172     CheckComRCReturnRC(autoCaller.rc());
     172    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    173173
    174174    AutoWriteLock alock(this);
    … …  
    284284    if (!CFGMR3AreValuesValid (pCfgHandle, "Object\0"))
    285285        return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
    286     AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER, 
     286    AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
    287287                    ("Configuration error: Not possible to attach anything to this driver!\n"),
    288288                    VERR_PDM_DRVINS_NO_ATTACH);
    … …  
    358358    NULL,
    359359    /* pfnDetach */
    360     NULL, 
     360    NULL,
    361361    /* pfnPowerOff */
    362     NULL, 
     362    NULL,
    363363    /* pfnSoftReset */
    364364    NULL,

  • trunk/src/VBox/Main/MachineDebuggerImpl.cpp

    r24301 r25149  
    127127
    128128    AutoCaller autoCaller(this);
    129     CheckComRCReturnRC(autoCaller.rc());
     129    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    130130
    131131    /** @todo */
    … …  
    142142{
    143143    AutoCaller autoCaller(this);
    144     CheckComRCReturnRC(autoCaller.rc());
     144    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    145145
    146146    /** @todo */
    … …  
    159159
    160160    AutoCaller autoCaller(this);
    161     CheckComRCReturnRC(autoCaller.rc());
     161    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    162162
    163163    AutoReadLock alock(this);
    … …  
    184184
    185185    AutoCaller autoCaller(this);
    186     CheckComRCReturnRC(autoCaller.rc());
     186    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    187187
    188188    AutoWriteLock alock(this);
    … …  
    196196
    197197    Console::SafeVMPtr pVM (mParent);
    198     CheckComRCReturnRC(pVM.rc());
     198    if (FAILED(pVM.rc())) return pVM.rc();
    199199
    200200    EMRAWMODE rawModeFlag = aEnable ? EMRAW_RING3_DISABLE : EMRAW_RING3_ENABLE;
    … …  
    219219
    220220    AutoCaller autoCaller(this);
    221     CheckComRCReturnRC(autoCaller.rc());
     221    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    222222
    223223    AutoReadLock alock(this);
    … …  
    244244
    245245    AutoCaller autoCaller(this);
    246     CheckComRCReturnRC(autoCaller.rc());
     246    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    247247
    248248    AutoWriteLock alock(this);
    … …  
    256256
    257257    Console::SafeVMPtr pVM (mParent);
    258     CheckComRCReturnRC(pVM.rc());
     258    if (FAILED(pVM.rc())) return pVM.rc();
    259259
    260260    EMRAWMODE rawModeFlag = aEnable ? EMRAW_RING0_DISABLE : EMRAW_RING0_ENABLE;
    … …  
    279279
    280280    AutoCaller autoCaller(this);
    281     CheckComRCReturnRC(autoCaller.rc());
     281    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    282282
    283283    AutoReadLock alock(this);
    … …  
    304304
    305305    AutoCaller autoCaller(this);
    306     CheckComRCReturnRC(autoCaller.rc());
     306    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    307307
    308308    AutoWriteLock alock(this);
    … …  
    315315    }
    316316
    317     Console::SafeVMPtr pVM (mParent);
    318     CheckComRCReturnRC(pVM.rc());
     317    Console::SafeVMPtr pVM(mParent);
     318    if (FAILED(pVM.rc())) return pVM.rc();
    319319
    320320    PATMR3AllowPatching (pVM, aEnable);
    … …  
    334334
    335335    AutoCaller autoCaller(this);
    336     CheckComRCReturnRC(autoCaller.rc());
     336    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    337337
    338338    AutoReadLock alock(this);
    … …  
    359359
    360360    AutoCaller autoCaller(this);
    361     CheckComRCReturnRC(autoCaller.rc());
     361    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    362362
    363363    AutoWriteLock alock(this);
    … …  
    370370    }
    371371
    372     Console::SafeVMPtr pVM (mParent);
    373     CheckComRCReturnRC(pVM.rc());
     372    Console::SafeVMPtr pVM(mParent);
     373    if (FAILED(pVM.rc())) return pVM.rc();
    374374
    375375    int vrc;
    … …  
    398398
    399399    AutoCaller autoCaller(this);
    400     CheckComRCReturnRC(autoCaller.rc());
     400    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    401401
    402402#ifdef LOG_ENABLED
    … …  
    423423
    424424    AutoCaller autoCaller(this);
    425     CheckComRCReturnRC(autoCaller.rc());
     425    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    426426
    427427    AutoWriteLock alock(this);
    … …  
    434434    }
    435435
    436     Console::SafeVMPtr pVM (mParent);
    437     CheckComRCReturnRC(pVM.rc());
     436    Console::SafeVMPtr pVM(mParent);
     437    if (FAILED(pVM.rc())) return pVM.rc();
    438438
    439439#ifdef LOG_ENABLED
    … …  
    459459
    460460    AutoCaller autoCaller(this);
    461     CheckComRCReturnRC(autoCaller.rc());
     461    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    462462
    463463    AutoReadLock alock(this);
    … …  
    484484
    485485    AutoCaller autoCaller(this);
    486     CheckComRCReturnRC(autoCaller.rc());
     486    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    487487
    488488    AutoReadLock alock(this);
    … …  
    509509
    510510    AutoCaller autoCaller(this);
    511     CheckComRCReturnRC(autoCaller.rc());
     511    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    512512
    513513    AutoReadLock alock(this);
    … …  
    534534
    535535    AutoCaller autoCaller(this);
    536     CheckComRCReturnRC(autoCaller.rc());
     536    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    537537
    538538    AutoReadLock alock(this);
    … …  
    562562
    563563    AutoCaller autoCaller(this);
    564     CheckComRCReturnRC(autoCaller.rc());
     564    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    565565
    566566    AutoReadLock alock(this);
    … …  
    588588
    589589    AutoCaller autoCaller(this);
    590     CheckComRCReturnRC(autoCaller.rc());
     590    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    591591
    592592    AutoWriteLock alock(this);
    … …  
    599599    }
    600600
    601     Console::SafeVMPtr pVM (mParent);
    602     CheckComRCReturnRC(pVM.rc());
     601    Console::SafeVMPtr pVM(mParent);
     602    if (FAILED(pVM.rc())) return pVM.rc();
    603603
    604604    int vrc = TMR3SetWarpDrive (pVM, aPct);
    … …  
    625625
    626626    AutoCaller autoCaller(this);
    627     CheckComRCReturnRC(autoCaller.rc());
    628 
    629     AutoReadLock alock(this);
    630 
    631     Console::SafeVMPtr pVM (mParent);
    632     CheckComRCReturnRC(pVM.rc());
     627    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     628
     629    AutoReadLock alock(this);
     630
     631    Console::SafeVMPtr pVM(mParent);
     632    if (FAILED(pVM.rc())) return pVM.rc();
    633633
    634634    *aVm = (uintptr_t)pVM.raw();
    … …  
    722722
    723723    AutoCaller autoCaller(this);
    724     CheckComRCReturnRC(autoCaller.rc());
     724    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    725725
    726726    AutoWriteLock alock(this);
    727727
    728     Console::SafeVMPtr pVM (mParent);
    729     CheckComRCReturnRC(pVM.rc());
     728    Console::SafeVMPtr pVM(mParent);
     729    if (FAILED(pVM.rc())) return pVM.rc();
    730730
    731731    HWACCMR3InjectNMI(pVM);

  • trunk/src/VBox/Main/MachineImpl.cpp

    r24991 r25149  
    701701
    702702    AutoLimitedCaller autoCaller(this);
    703     CheckComRCReturnRC(autoCaller.rc());
     703    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    704704
    705705    /* mParent is constant during life time, no need to lock */
    … …  
    714714
    715715    AutoLimitedCaller autoCaller(this);
    716     CheckComRCReturnRC(autoCaller.rc());
     716    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    717717
    718718    LogFlowThisFunc(("ENTER\n"));
    … …  
    768768
    769769    AutoLimitedCaller autoCaller(this);
    770     CheckComRCReturnRC(autoCaller.rc());
     770    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    771771
    772772    AutoReadLock alock(this);
    … …  
    800800
    801801    AutoCaller autoCaller(this);
    802     CheckComRCReturnRC(autoCaller.rc());
     802    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    803803
    804804    AutoReadLock alock(this);
    … …  
    818818
    819819    AutoCaller autoCaller(this);
    820     CheckComRCReturnRC(autoCaller.rc());
     820    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    821821
    822822    AutoWriteLock alock(this);
    823823
    824824    HRESULT rc = checkStateDependency(MutableStateDep);
    825     CheckComRCReturnRC(rc);
     825    if (FAILED(rc)) return rc;
    826826
    827827    mUserData.backup();
    … …  
    836836
    837837    AutoCaller autoCaller(this);
    838     CheckComRCReturnRC(autoCaller.rc());
     838    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    839839
    840840    AutoReadLock alock(this);
    … …  
    848848{
    849849    AutoCaller autoCaller(this);
    850     CheckComRCReturnRC(autoCaller.rc());
     850    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    851851
    852852    AutoWriteLock alock(this);
    853853
    854854    HRESULT rc = checkStateDependency(MutableStateDep);
    855     CheckComRCReturnRC(rc);
     855    if (FAILED(rc)) return rc;
    856856
    857857    mUserData.backup();
    … …  
    866866
    867867    AutoLimitedCaller autoCaller(this);
    868     CheckComRCReturnRC(autoCaller.rc());
     868    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    869869
    870870    AutoReadLock alock(this);
    … …  
    880880
    881881    AutoCaller autoCaller(this);
    882     CheckComRCReturnRC(autoCaller.rc());
     882    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    883883
    884884    AutoReadLock alock(this);
    … …  
    894894
    895895    AutoCaller autoCaller(this);
    896     CheckComRCReturnRC(autoCaller.rc());
     896    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    897897
    898898    /* look up the object by Id to check it is valid */
    … …  
    900900    HRESULT rc = mParent->GetGuestOSType (aOSTypeId,
    901901                                          guestOSType.asOutParam());
    902     CheckComRCReturnRC(rc);
     902    if (FAILED(rc)) return rc;
    903903
    904904    /* when setting, always use the "etalon" value for consistency -- lookup
    … …  
    906906    Bstr osTypeId;
    907907    rc = guestOSType->COMGETTER(Id) (osTypeId.asOutParam());
    908     CheckComRCReturnRC(rc);
     908    if (FAILED(rc)) return rc;
    909909
    910910    AutoWriteLock alock(this);
    911911
    912912    rc = checkStateDependency(MutableStateDep);
    913     CheckComRCReturnRC(rc);
     913    if (FAILED(rc)) return rc;
    914914
    915915    mUserData.backup();
    … …  
    925925
    926926    AutoCaller autoCaller(this);
    927     CheckComRCReturnRC(autoCaller.rc());
     927    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    928928
    929929    AutoReadLock alock(this);
    … …  
    937937{
    938938    AutoCaller autoCaller(this);
    939     CheckComRCReturnRC(autoCaller.rc());
     939    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    940940    AutoWriteLock alock(this);
    941941
    942942    int rc = checkStateDependency(MutableStateDep);
    943     CheckComRCReturnRC(rc);
     943    if (FAILED(rc)) return rc;
    944944
    945945    mHWData.backup();
    … …  
    955955
    956956    AutoCaller autoCaller(this);
    957     CheckComRCReturnRC(autoCaller.rc());
     957    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    958958
    959959    AutoReadLock alock(this);
    … …  
    974974
    975975    AutoCaller autoCaller(this);
    976     CheckComRCReturnRC(autoCaller.rc());
     976    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    977977
    978978    AutoWriteLock alock(this);
    979979
    980980    HRESULT rc = checkStateDependency(MutableStateDep);
    981     CheckComRCReturnRC(rc);
     981    if (FAILED(rc)) return rc;
    982982
    983983    mHWData.backup();
    … …  
    992992
    993993    AutoCaller autoCaller(this);
    994     CheckComRCReturnRC(autoCaller.rc());
     994    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    995995
    996996    AutoReadLock alock(this);
    … …  
    10111011
    10121012    AutoCaller autoCaller(this);
    1013     CheckComRCReturnRC(autoCaller.rc());
     1013    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10141014
    10151015    AutoWriteLock alock(this);
    10161016
    10171017    HRESULT rc = checkStateDependency(MutableStateDep);
    1018     CheckComRCReturnRC(rc);
     1018    if (FAILED(rc)) return rc;
    10191019
    10201020    mHWData.backup();
    … …  
    10331033
    10341034    AutoCaller autoCaller(this);
    1035     CheckComRCReturnRC(autoCaller.rc());
     1035    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10361036
    10371037    AutoReadLock alock(this);
    … …  
    10531053
    10541054    AutoCaller autoCaller(this);
    1055     CheckComRCReturnRC(autoCaller.rc());
     1055    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10561056
    10571057    AutoWriteLock alock(this);
    10581058
    10591059    HRESULT rc = checkStateDependency(MutableStateDep);
    1060     CheckComRCReturnRC(rc);
     1060    if (FAILED(rc)) return rc;
    10611061
    10621062    mHWData.backup();
    … …  
    10721072
    10731073    AutoCaller autoCaller(this);
    1074     CheckComRCReturnRC(autoCaller.rc());
     1074    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10751075
    10761076    AutoReadLock alock(this);
    … …  
    10921092
    10931093    AutoCaller autoCaller(this);
    1094     CheckComRCReturnRC(autoCaller.rc());
     1094    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10951095
    10961096    AutoWriteLock alock(this);
    10971097
    10981098    HRESULT rc = checkStateDependency(MutableStateDep);
    1099     CheckComRCReturnRC(rc);
     1099    if (FAILED(rc)) return rc;
    11001100
    11011101    mHWData.backup();
    … …  
    11111111
    11121112    AutoCaller autoCaller(this);
    1113     CheckComRCReturnRC(autoCaller.rc());
     1113    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11141114
    11151115    AutoReadLock alock(this);
    … …  
    11301130
    11311131    AutoCaller autoCaller(this);
    1132     CheckComRCReturnRC(autoCaller.rc());
     1132    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11331133
    11341134    AutoWriteLock alock(this);
    11351135
    11361136    HRESULT rc = checkStateDependency(MutableStateDep);
    1137     CheckComRCReturnRC(rc);
     1137    if (FAILED(rc)) return rc;
    11381138
    11391139    mHWData.backup();
    … …  
    11501150
    11511151    AutoCaller autoCaller(this);
    1152     CheckComRCReturnRC(autoCaller.rc());
     1152    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11531153
    11541154    AutoReadLock alock(this);
    … …  
    11691169
    11701170    AutoCaller autoCaller(this);
    1171     CheckComRCReturnRC(autoCaller.rc());
     1171    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11721172
    11731173    AutoWriteLock alock(this);
    11741174
    11751175    HRESULT rc = checkStateDependency(MutableStateDep);
    1176     CheckComRCReturnRC(rc);
     1176    if (FAILED(rc)) return rc;
    11771177
    11781178    mHWData.backup();
    … …  
    11891189
    11901190    AutoCaller autoCaller(this);
    1191     CheckComRCReturnRC(autoCaller.rc());
     1191    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11921192
    11931193    AutoReadLock alock(this);
    … …  
    12021202{
    12031203    AutoCaller autoCaller(this);
    1204     CheckComRCReturnRC(autoCaller.rc());
     1204    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12051205
    12061206    AutoWriteLock alock(this);
    12071207
    12081208    HRESULT rc = checkStateDependency(MutableStateDep);
    1209     CheckComRCReturnRC(rc);
     1209    if (FAILED(rc)) return rc;
    12101210
    12111211    mHWData.backup();
    … …  
    12221222
    12231223    AutoCaller autoCaller(this);
    1224     CheckComRCReturnRC(autoCaller.rc());
     1224    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12251225
    12261226    AutoReadLock alock(this);
    … …  
    12341234{
    12351235    AutoCaller autoCaller(this);
    1236     CheckComRCReturnRC(autoCaller.rc());
     1236    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12371237
    12381238    AutoWriteLock alock(this);
    12391239
    12401240    HRESULT rc = checkStateDependency(MutableStateDep);
    1241     CheckComRCReturnRC(rc);
     1241    if (FAILED(rc)) return rc;
    12421242
    12431243    /** @todo check validity! */
    … …  
    12561256
    12571257    AutoCaller autoCaller(this);
    1258     CheckComRCReturnRC(autoCaller.rc());
     1258    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12591259
    12601260    AutoReadLock alock(this);
    … …  
    12681268{
    12691269    AutoCaller autoCaller(this);
    1270     CheckComRCReturnRC(autoCaller.rc());
     1270    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12711271
    12721272    AutoWriteLock alock(this);
    12731273
    12741274    HRESULT rc = checkStateDependency(MutableStateDep);
    1275     CheckComRCReturnRC(rc);
     1275    if (FAILED(rc)) return rc;
    12761276
    12771277    /** @todo check validity! */
    … …  
    12891289
    12901290    AutoCaller autoCaller(this);
    1291     CheckComRCReturnRC(autoCaller.rc());
     1291    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12921292
    12931293    AutoReadLock alock(this);
    … …  
    13071307
    13081308    AutoCaller autoCaller(this);
    1309     CheckComRCReturnRC(autoCaller.rc());
     1309    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13101310
    13111311    AutoWriteLock alock(this);
    13121312
    13131313    HRESULT rc = checkStateDependency(MutableStateDep);
    1314     CheckComRCReturnRC(rc);
     1314    if (FAILED(rc)) return rc;
    13151315
    13161316    mHWData.backup();
    … …  
    13261326
    13271327    AutoCaller autoCaller(this);
    1328     CheckComRCReturnRC(autoCaller.rc());
     1328    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13291329
    13301330    /* mBIOSSettings is constant during life time, no need to lock */
    … …  
    13401340
    13411341    AutoCaller autoCaller(this);
    1342     CheckComRCReturnRC(autoCaller.rc());
     1342    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13431343
    13441344    AutoReadLock alock(this);
    … …  
    13631363{
    13641364    AutoCaller autoCaller(this);
    1365     CheckComRCReturnRC(autoCaller.rc());
     1365    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13661366
    13671367    AutoWriteLock alock(this);
    13681368
    13691369    HRESULT rc = checkStateDependency(MutableStateDep);
    1370     CheckComRCReturnRC(rc);
     1370    if (FAILED(rc)) return rc;
    13711371
    13721372    switch(property)
    … …  
    13941394
    13951395    AutoCaller autoCaller(this);
    1396     CheckComRCReturnRC(autoCaller.rc());
     1396    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13971397
    13981398    AutoReadLock alock(this);
    … …  
    14491449{
    14501450    AutoCaller autoCaller(this);
    1451     CheckComRCReturnRC(autoCaller.rc());
     1451    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14521452
    14531453    AutoWriteLock alock(this);
    14541454
    14551455    HRESULT rc = checkStateDependency(MutableStateDep);
    1456     CheckComRCReturnRC(rc);
     1456    if (FAILED(rc)) return rc;
    14571457
    14581458    switch(aId)
    … …  
    15071507{
    15081508    AutoCaller autoCaller(this);
    1509     CheckComRCReturnRC(autoCaller.rc());
     1509    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15101510
    15111511    AutoWriteLock alock(this);
    15121512
    15131513    HRESULT rc = checkStateDependency(MutableStateDep);
    1514     CheckComRCReturnRC(rc);
     1514    if (FAILED(rc)) return rc;
    15151515
    15161516    switch(aId)
    … …  
    15591559{
    15601560    AutoCaller autoCaller(this);
    1561     CheckComRCReturnRC(autoCaller.rc());
     1561    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15621562
    15631563    AutoWriteLock alock(this);
    15641564
    15651565    HRESULT rc = checkStateDependency(MutableStateDep);
    1566     CheckComRCReturnRC(rc);
     1566    if (FAILED(rc)) return rc;
    15671567
    15681568    /* Invalidate all standard leafs. */
    … …  
    15831583
    15841584    AutoCaller autoCaller(this);
    1585     CheckComRCReturnRC(autoCaller.rc());
     1585    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15861586
    15871587    AutoReadLock alock(this);
    … …  
    16141614{
    16151615    AutoCaller autoCaller(this);
    1616     CheckComRCReturnRC(autoCaller.rc());
     1616    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16171617
    16181618    AutoWriteLock alock(this);
    16191619
    16201620    HRESULT rc = checkStateDependency(MutableStateDep);
    1621     CheckComRCReturnRC(rc);
     1621    if (FAILED(rc)) return rc;
    16221622
    16231623    switch(property)
    … …  
    16541654
    16551655    AutoCaller autoCaller(this);
    1656     CheckComRCReturnRC(autoCaller.rc());
     1656    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16571657
    16581658    AutoReadLock alock(this);
    … …  
    16741674
    16751675    AutoCaller autoCaller(this);
    1676     CheckComRCReturnRC(autoCaller.rc());
     1676    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16771677
    16781678    AutoWriteLock alock(this);
    16791679
    16801680    HRESULT rc = checkStateDependency(MutableStateDep);
    1681     CheckComRCReturnRC(rc);
     1681    if (FAILED(rc)) return rc;
    16821682
    16831683    if (!mData->mCurrentSnapshot.isNull())
    … …  
    17211721
    17221722    AutoCaller autoCaller(this);
    1723     CheckComRCReturnRC(autoCaller.rc());
     1723    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17241724
    17251725    AutoReadLock alock(this);
    … …  
    17381738
    17391739    AutoCaller autoCaller(this);
    1740     CheckComRCReturnRC(autoCaller.rc());
     1740    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17411741
    17421742    AutoReadLock alock(this);
    … …  
    17581758
    17591759    AutoCaller autoCaller(this);
    1760     CheckComRCReturnRC(autoCaller.rc());
     1760    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17611761
    17621762    AutoReadLock alock(this);
    … …  
    17721772
    17731773    AutoCaller autoCaller(this);
    1774     CheckComRCReturnRC(autoCaller.rc());
     1774    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17751775
    17761776    MultiResult rc = mParent->host()->checkUSBProxyService();
    1777     CheckComRCReturnRC(rc);
     1777    if (FAILED(rc)) return rc;
    17781778
    17791779    AutoReadLock alock(this);
    … …  
    17941794
    17951795    AutoLimitedCaller autoCaller(this);
    1796     CheckComRCReturnRC(autoCaller.rc());
     1796    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17971797
    17981798    AutoReadLock alock(this);
    … …  
    18071807
    18081808    AutoCaller autoCaller(this);
    1809     CheckComRCReturnRC(autoCaller.rc());
     1809    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18101810
    18111811    AutoWriteLock alock(this);
    18121812
    18131813    HRESULT rc = checkStateDependency(MutableStateDep);
    1814     CheckComRCReturnRC(rc);
     1814    if (FAILED(rc)) return rc;
    18151815
    18161816    if (mData->mInitMode == Init_New)
    … …  
    18301830
    18311831    AutoCaller autoCaller(this);
    1832     CheckComRCReturnRC(autoCaller.rc());
     1832    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18331833
    18341834    AutoReadLock alock(this);
    … …  
    18441844
    18451845    AutoCaller autoCaller(this);
    1846     CheckComRCReturnRC(autoCaller.rc());
     1846    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18471847
    18481848    AutoReadLock alock(this);
    … …  
    18611861
    18621862    AutoCaller autoCaller(this);
    1863     CheckComRCReturnRC(autoCaller.rc());
     1863    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18641864
    18651865    AutoReadLock alock(this);
    … …  
    18761876
    18771877    AutoCaller autoCaller(this);
    1878     CheckComRCReturnRC(autoCaller.rc());
     1878    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18791879
    18801880    AutoReadLock alock(this);
    … …  
    18901890
    18911891    AutoCaller autoCaller(this);
    1892     CheckComRCReturnRC(autoCaller.rc());
     1892    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18931893
    18941894    AutoReadLock alock(this);
    … …  
    19041904
    19051905    AutoCaller autoCaller(this);
    1906     CheckComRCReturnRC(autoCaller.rc());
     1906    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19071907
    19081908    AutoReadLock alock(this);
    … …  
    19381938
    19391939    AutoCaller autoCaller(this);
    1940     CheckComRCReturnRC(autoCaller.rc());
     1940    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19411941
    19421942    AutoReadLock alock(this);
    … …  
    19521952
    19531953    AutoCaller autoCaller(this);
    1954     CheckComRCReturnRC(autoCaller.rc());
     1954    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19551955
    19561956    AutoReadLock alock(this);
    … …  
    19681968
    19691969    AutoCaller autoCaller(this);
    1970     CheckComRCReturnRC(autoCaller.rc());
     1970    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19711971
    19721972    AutoReadLock alock(this);
    … …  
    19881988
    19891989    AutoCaller autoCaller(this);
    1990     CheckComRCReturnRC(autoCaller.rc());
     1990    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19911991
    19921992    AutoReadLock alock(this);
    … …  
    20032003
    20042004    AutoCaller autoCaller(this);
    2005     CheckComRCReturnRC(autoCaller.rc());
     2005    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20062006
    20072007    AutoReadLock alock(this);
    … …  
    20162016{
    20172017    AutoCaller autoCaller(this);
    2018     CheckComRCReturnRC(autoCaller.rc());
     2018    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20192019
    20202020    AutoWriteLock alock(this);
    20212021
    20222022    HRESULT rc = checkStateDependency(MutableStateDep);
    2023     CheckComRCReturnRC(rc);
     2023    if (FAILED(rc)) return rc;
    20242024
    20252025    mHWData.backup();
    … …  
    20352035
    20362036    AutoCaller autoCaller(this);
    2037     CheckComRCReturnRC(autoCaller.rc());
     2037    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20382038
    20392039    AutoReadLock alock(this);
    … …  
    20562056    CheckComArgNotNull(aPatterns);
    20572057    AutoCaller autoCaller(this);
    2058     CheckComRCReturnRC(autoCaller.rc());
     2058    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20592059
    20602060    AutoWriteLock alock(this);
    20612061
    20622062    HRESULT rc = checkStateDependency(MutableStateDep);
    2063     CheckComRCReturnRC(rc);
     2063    if (FAILED(rc)) return rc;
    20642064
    20652065    try
    … …  
    20812081
    20822082    AutoCaller autoCaller(this);
    2083     CheckComRCReturnRC(autoCaller.rc());
     2083    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20842084
    20852085    AutoReadLock alock(this);
    … …  
    20972097
    20982098    AutoCaller autoCaller(this);
    2099     CheckComRCReturnRC(autoCaller.rc());
     2099    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21002100
    21012101    AutoReadLock alock(this);
    … …  
    21102110{
    21112111    AutoCaller autoCaller(this);
    2112     CheckComRCReturnRC(autoCaller.rc());
     2112    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21132113
    21142114    AutoWriteLock alock(this);
    … …  
    21412141
    21422142    AutoCaller autoCaller(this);
    2143     CheckComRCReturnRC(autoCaller.rc());
     2143    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21442144
    21452145    AutoReadLock alock(this);
    … …  
    21572157
    21582158    AutoCaller autoCaller(this);
    2159     CheckComRCReturnRC(autoCaller.rc());
     2159    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21602160
    21612161    AutoWriteLock alock(this);
    21622162
    21632163    HRESULT rc = checkStateDependency(MutableStateDep);
    2164     CheckComRCReturnRC(rc);
     2164    if (FAILED(rc)) return rc;
    21652165
    21662166    mUserData.backup();
    … …  
    21762176
    21772177    AutoCaller autoCaller(this);
    2178     CheckComRCReturnRC(autoCaller.rc());
     2178    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21792179
    21802180    AutoReadLock alock(this);
    … …  
    21892189{
    21902190    AutoCaller autoCaller(this);
    2191     CheckComRCReturnRC(autoCaller.rc());
     2191    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21922192
    21932193    AutoWriteLock alock(this);
    21942194
    21952195    HRESULT rc = checkStateDependency(MutableStateDep);
    2196     CheckComRCReturnRC(rc);
     2196    if (FAILED(rc)) return rc;
    21972197
    21982198    mUserData.backup();
    … …  
    22082208
    22092209    AutoCaller autoCaller(this);
    2210     CheckComRCReturnRC(autoCaller.rc());
     2210    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22112211
    22122212    AutoReadLock alock(this);
    … …  
    22212221{
    22222222    AutoCaller autoCaller(this);
    2223     CheckComRCReturnRC(autoCaller.rc());
     2223    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22242224
    22252225    AutoWriteLock alock(this);
    22262226
    22272227    HRESULT rc = checkStateDependency(MutableStateDep);
    2228     CheckComRCReturnRC(rc);
     2228    if (FAILED(rc)) return rc;
    22292229
    22302230    mUserData.backup();
    … …  
    22502250
    22512251    AutoCaller autoCaller(this);
    2252     CheckComRCReturnRC(autoCaller.rc());
     2252    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22532253
    22542254    AutoWriteLock alock(this);
    22552255
    22562256    HRESULT rc = checkStateDependency(MutableStateDep);
    2257     CheckComRCReturnRC(rc);
     2257    if (FAILED(rc)) return rc;
    22582258
    22592259    mHWData.backup();
    … …  
    22712271
    22722272    AutoCaller autoCaller(this);
    2273     CheckComRCReturnRC(autoCaller.rc());
     2273    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22742274
    22752275    AutoReadLock alock(this);
    … …  
    22932293
    22942294    AutoCaller autoCaller(this);
    2295     CheckComRCReturnRC(autoCaller.rc());
     2295    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22962296
    22972297    /* VirtualBox::findHardDisk() and the corresponding other methods for
    … …  
    23022302
    23032303    HRESULT rc = checkStateDependency(MutableStateDep);
    2304     CheckComRCReturnRC(rc);
     2304    if (FAILED(rc)) return rc;
    23052305
    23062306    /// @todo NEWMEDIA implicit machine registration
    … …  
    23192319    ComObjPtr<StorageController> ctl;
    23202320    rc = getStorageControllerByName(aControllerName, ctl, true /* aSetError */);
    2321     CheckComRCReturnRC(rc);
     2321    if (FAILED(rc)) return rc;
    23222322
    23232323    /* check that the port and device are not out of range. */
    … …  
    23252325    ULONG devicesPerPort;
    23262326    rc = ctl->COMGETTER(PortCount)(&portCount);
    2327     CheckComRCReturnRC(rc);
     2327    if (FAILED(rc)) return rc;
    23282328    rc = ctl->COMGETTER(MaxDevicesPerPortCount)(&devicesPerPort);
    2329     CheckComRCReturnRC(rc);
     2329    if (FAILED(rc)) return rc;
    23302330
    23312331    if (   (aControllerPort < 0)
    … …  
    23712371            /* find a hard disk by UUID */
    23722372            rc = mParent->findHardDisk(&uuid, NULL, true /* aSetError */, &medium);
    2373             CheckComRCReturnRC(rc);
     2373            if (FAILED(rc)) return rc;
    23742374            break;
    23752375
    … …  
    23982398                    /* find a DVD image by UUID */
    23992399                    rc = mParent->findDVDImage(&uuid, NULL, true /* aSetError */, &medium);
    2400                     CheckComRCReturnRC(rc);
     2400                    if (FAILED(rc)) return rc;
    24012401                }
    24022402            }
    … …  
    24312431                    /* find a floppy image by UUID */
    24322432                    rc = mParent->findFloppyImage(&uuid, NULL, true /* aSetError */, &medium);
    2433                     CheckComRCReturnRC(rc);
     2433                    if (FAILED(rc)) return rc;
    24342434                }
    24352435            }
    … …  
    24472447
    24482448    AutoCaller mediumCaller(medium);
    2449     CheckComRCReturnRC(mediumCaller.rc());
     2449    if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
    24502450
    24512451    AutoWriteLock mediumLock(medium);
    … …  
    25592559                    medium = (*foundIt)->getMedium();
    25602560                    mediumCaller.attach(medium);
    2561                     CheckComRCReturnRC(mediumCaller.rc());
     2561                    if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
    25622562                    mediumLock.attach(medium);
    25632563                    /* not implicit, doesn't require association with this VM */
    … …  
    26332633                medium = base;
    26342634                mediumCaller.attach(medium);
    2635                 CheckComRCReturnRC(mediumCaller.rc());
     2635                if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
    26362636                mediumLock.attach(medium);
    26372637            }
    … …  
    26442644                        BstrFmt("%ls"RTPATH_SLASH_STR,
    26452645                                 mUserData->mSnapshotFolderFull.raw()).raw());
    2646         CheckComRCReturnRC(rc);
     2646        if (FAILED(rc)) return rc;
    26472647
    26482648        /* make sure the hard disk is not modified before createDiffStorage() */
    26492649        rc = medium->LockRead(NULL);
    2650         CheckComRCReturnRC(rc);
     2650        if (FAILED(rc)) return rc;
    26512651
    26522652        /* will leave the lock before the potentially lengthy operation, so
    … …  
    26672667        medium->UnlockRead(NULL);
    26682668
    2669         CheckComRCReturnRC(rc);
     2669        if (FAILED(rc)) return rc;
    26702670
    26712671        /* use the created diff for the actual attachment */
    26722672        medium = diff;
    26732673        mediumCaller.attach(medium);
    2674         CheckComRCReturnRC(mediumCaller.rc());
     2674        if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
    26752675        mediumLock.attach(medium);
    26762676    }
    … …  
    26802680    attachment.createObject();
    26812681    rc = attachment->init(this, medium, aControllerName, aControllerPort, aDevice, aType, indirect);
    2682     CheckComRCReturnRC(rc);
     2682    if (FAILED(rc)) return rc;
    26832683
    26842684    if (associate && !medium.isNull())
    … …  
    26882688        /* here we can fail because of Deleting, or being in process of
    26892689         * creating a Diff */
    2690         CheckComRCReturnRC(rc);
     2690        if (FAILED(rc)) return rc;
    26912691    }
    26922692
    … …  
    27072707
    27082708    AutoCaller autoCaller(this);
    2709     CheckComRCReturnRC(autoCaller.rc());
     2709    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27102710
    27112711    AutoWriteLock alock(this);
    27122712
    27132713    HRESULT rc = checkStateDependency(MutableStateDep);
    2714     CheckComRCReturnRC(rc);
     2714    if (FAILED(rc)) return rc;
    27152715
    27162716    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
    … …  
    27562756        setMachineState(oldState);
    27572757
    2758         CheckComRCReturnRC(rc);
     2758        if (FAILED(rc)) return rc;
    27592759    }
    27602760
    … …  
    27822782
    27832783    AutoCaller autoCaller(this);
    2784     CheckComRCReturnRC(autoCaller.rc());
     2784    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27852785
    27862786    AutoWriteLock alock(this);
    27872787
    27882788    HRESULT rc = checkStateDependency(MutableStateDep);
    2789     CheckComRCReturnRC(rc);
     2789    if (FAILED(rc)) return rc;
    27902790
    27912791    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
    … …  
    28332833
    28342834    AutoCaller autoCaller(this);
    2835     CheckComRCReturnRC(autoCaller.rc());
     2835    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    28362836
    28372837    AutoWriteLock alock(this);
    … …  
    28792879                    rc = mParent->findDVDImage(&uuid, NULL, true /* aDoSetError */, &medium);
    28802880            }
    2881             CheckComRCReturnRC(rc);
     2881            if (FAILED(rc)) return rc;
    28822882            break;
    28832883        case DeviceType_Floppy:
    … …  
    29042904                    rc = mParent->findFloppyImage(&uuid, NULL, true /* aDoSetError */, &medium);
    29052905            }
    2906             CheckComRCReturnRC(rc);
     2906            if (FAILED(rc)) return rc;
    29072907            break;
    29082908        default:
    … …  
    29692969
    29702970    AutoCaller autoCaller(this);
    2971     CheckComRCReturnRC(autoCaller.rc());
     2971    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    29722972
    29732973    AutoReadLock alock(this);
    … …  
    29952995
    29962996    AutoCaller autoCaller(this);
    2997     CheckComRCReturnRC(autoCaller.rc());
     2997    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    29982998
    29992999    AutoReadLock alock(this);
    … …  
    30103010
    30113011    AutoCaller autoCaller(this);
    3012     CheckComRCReturnRC(autoCaller.rc());
     3012    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30133013
    30143014    AutoReadLock alock(this);
    … …  
    30253025
    30263026    AutoCaller autoCaller(this);
    3027     CheckComRCReturnRC(autoCaller.rc());
     3027    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30283028
    30293029    AutoReadLock alock(this);
    … …  
    30393039        return E_POINTER;
    30403040
    3041     AutoCaller autoCaller (this);
    3042     CheckComRCReturnRC (autoCaller.rc());
     3041    AutoCaller autoCaller(this);
     3042    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30433043
    30443044    AutoReadLock alock (this);
    … …  
    30673067    CheckComArgOutPointerValid(aValue);
    30683068
    3069     AutoCaller autoCaller (this);
    3070     CheckComRCReturnRC (autoCaller.rc());
     3069    AutoCaller autoCaller(this);
     3070    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30713071
    30723072    /* start with nothing found */
    … …  
    30943094
    30953095    AutoCaller autoCaller(this);
    3096     CheckComRCReturnRC (autoCaller.rc());
     3096    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30973097
    30983098    Utf8Str strKey(aKey);
    … …  
    31503150        {
    31513151            HRESULT rc = checkStateDependency(MutableStateDep);
    3152             CheckComRCReturnRC (rc);
     3152            if (FAILED(rc)) return rc;
    31533153        }
    31543154
    … …  
    31613161        /* save settings on success */
    31623162        HRESULT rc = saveSettings();
    3163         CheckComRCReturnRC (rc);
     3163        if (FAILED(rc)) return rc;
    31643164    }
    31653165
    … …  
    31743174{
    31753175    AutoCaller autoCaller(this);
    3176     CheckComRCReturnRC(autoCaller.rc());
     3176    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    31773177
    31783178    /* saveSettings() needs mParent lock */
    … …  
    31823182     * the VM is saved */
    31833183    HRESULT rc = checkStateDependency(MutableStateDep);
    3184     CheckComRCReturnRC(rc);
     3184    if (FAILED(rc)) return rc;
    31853185
    31863186    /* the settings file path may never be null */
    … …  
    31943194{
    31953195    AutoCaller autoCaller(this);
    3196     CheckComRCReturnRC(autoCaller.rc());
     3196    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    31973197
    31983198    AutoWriteLock alock(this);
    31993199
    32003200    HRESULT rc = checkStateDependency(MutableStateDep);
    3201     CheckComRCReturnRC(rc);
     3201    if (FAILED(rc)) return rc;
    32023202
    32033203    /*
    … …  
    32133213{
    32143214    AutoCaller autoCaller(this);
    3215     CheckComRCReturnRC(autoCaller.rc());
     3215    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    32163216
    32173217    AutoWriteLock alock(this);
    32183218
    32193219    HRESULT rc = checkStateDependency(MutableStateDep);
    3220     CheckComRCReturnRC(rc);
     3220    if (FAILED(rc)) return rc;
    32213221
    32223222    if (mData->mRegistered)
    … …  
    32873287
    32883288    AutoCaller autoCaller(this);
    3289     CheckComRCReturnRC(autoCaller.rc());
     3289    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    32903290
    32913291    AutoReadLock alock(this);
    … …  
    33063306
    33073307    AutoCaller autoCaller(this);
    3308     CheckComRCReturnRC(autoCaller.rc());
     3308    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33093309
    33103310    AutoReadLock alock(this);
    … …  
    33323332
    33333333    AutoCaller autoCaller(this);
    3334     CheckComRCReturnRC(autoCaller.rc());
     3334    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33353335
    33363336    AutoWriteLock alock(this);
    33373337
    33383338    HRESULT rc = checkStateDependency(MutableStateDep);
    3339     CheckComRCReturnRC(rc);
     3339    if (FAILED(rc)) return rc;
    33403340
    33413341    ComObjPtr<SharedFolder> sharedFolder;
    … …  
    33483348    sharedFolder.createObject();
    33493349    rc = sharedFolder->init(getMachine(), aName, aHostPath, aWritable);
    3350     CheckComRCReturnRC(rc);
     3350    if (FAILED(rc)) return rc;
    33513351
    33523352    mHWData.backup();
    … …  
    33653365
    33663366    AutoCaller autoCaller(this);
    3367     CheckComRCReturnRC(autoCaller.rc());
     3367    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33683368
    33693369    AutoWriteLock alock(this);
    33703370
    33713371    HRESULT rc = checkStateDependency(MutableStateDep);
    3372     CheckComRCReturnRC(rc);
     3372    if (FAILED(rc)) return rc;
    33733373
    33743374    ComObjPtr<SharedFolder> sharedFolder;
    33753375    rc = findSharedFolder (aName, sharedFolder, true /* aSetError */);
    3376     CheckComRCReturnRC(rc);
     3376    if (FAILED(rc)) return rc;
    33773377
    33783378    mHWData.backup();
    … …  
    34573457
    34583458    AutoCaller autoCaller(this);
    3459     CheckComRCReturnRC(autoCaller.rc());
     3459    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    34603460
    34613461    AutoReadLock alock(this);
    … …  
    35433543
    35443544        AutoCaller autoCaller(this);
    3545         CheckComRCReturnRC(autoCaller.rc());
     3545        if (FAILED(autoCaller.rc())) return autoCaller.rc();
    35463546
    35473547        AutoWriteLock alock(this);
    35483548
    35493549        rc = checkStateDependency(MutableStateDep);
    3550         CheckComRCReturnRC(rc);
     3550        if (FAILED(rc)) return rc;
    35513551
    35523552        rc = S_OK;
    … …  
    36763676
    36773677    AutoCaller autoCaller(this);
    3678     CheckComRCReturnRC(autoCaller.rc());
     3678    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    36793679
    36803680    AutoReadLock alock(this);
    … …  
    37563756
    37573757    HRESULT rc = getMediumAttachmentsOfController(aName, atts);
    3758     CheckComRCReturnRC(rc);
     3758    if (FAILED(rc)) return rc;
    37593759
    37603760    SafeIfaceArray<IMediumAttachment> attachments(atts);
    … …  
    37763776
    37773777    AutoCaller autoCaller(this);
    3778     CheckComRCReturnRC(autoCaller.rc());
     3778    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    37793779
    37803780    AutoReadLock alock(this);
    … …  
    38093809
    38103810    AutoCaller autoCaller(this);
    3811     CheckComRCReturnRC(autoCaller.rc());
     3811    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    38123812
    38133813    AutoWriteLock alock(this);
    38143814
    38153815    HRESULT rc = checkStateDependency(MutableStateDep);
    3816     CheckComRCReturnRC(rc);
     3816    if (FAILED(rc)) return rc;
    38173817
    38183818    /* try to find one with the name first. */
    … …  
    38423842
    38433843    rc = ctrl->init(this, aName, aConnectionType, ulInstance);
    3844     CheckComRCReturnRC(rc);
     3844    if (FAILED(rc)) return rc;
    38453845
    38463846    mStorageControllers.backup();
    … …  
    38623862
    38633863    AutoCaller autoCaller(this);
    3864     CheckComRCReturnRC(autoCaller.rc());
     3864    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    38653865
    38663866    AutoReadLock alock(this);
    … …  
    38793879{
    38803880    AutoCaller autoCaller(this);
    3881     CheckComRCReturnRC(autoCaller.rc());
     3881    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    38823882
    38833883    AutoReadLock alock(this);
    … …  
    39043904
    39053905    AutoCaller autoCaller(this);
    3906     CheckComRCReturnRC(autoCaller.rc());
     3906    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    39073907
    39083908    AutoWriteLock alock(this);
    39093909
    39103910    HRESULT rc = checkStateDependency(MutableStateDep);
    3911     CheckComRCReturnRC(rc);
     3911    if (FAILED(rc)) return rc;
    39123912
    39133913    ComObjPtr<StorageController> ctrl;
    39143914    rc = getStorageControllerByName (aName, ctrl, true /* aSetError */);
    3915     CheckComRCReturnRC(rc);
     3915    if (FAILED(rc)) return rc;
    39163916
    39173917    /* We can remove the controller only if there is no device attached. */
    … …  
    40694069
    40704070    AutoCaller autoCaller(this);
    4071     CheckComRCReturnRC(autoCaller.rc());
     4071    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    40724072
    40734073    AutoReadLock alock(this);
    … …  
    41024102
    41034103    AutoCaller autoCaller(this);
    4104     CheckComRCReturnRC(autoCaller.rc());
     4104    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    41054105
    41064106    AutoReadLock alock(this);
    … …  
    41604160
    41614161    AutoCaller autoCaller(this);
    4162     CheckComRCReturnRC(autoCaller.rc());
     4162    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    41634163
    41644164    AutoReadLock alock(this);
    … …  
    41934193
    41944194    AutoCaller autoCaller(this);
    4195     CheckComRCReturnRC(autoCaller.rc());
     4195    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    41964196
    41974197    AutoReadLock alock(this);
    … …  
    43464346
    43474347    AutoCaller autoCaller(this);
    4348     CheckComRCReturnRC(autoCaller.rc());
     4348    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    43494349
    43504350    AutoWriteLock alock(this);
    … …  
    45764576
    45774577    AutoCaller autoCaller(this);
    4578     CheckComRCReturnRC(autoCaller.rc());
     4578    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    45794579
    45804580    AutoWriteLock alock(this);
    … …  
    48154815
    48164816    AutoCaller autoCaller(this);
    4817     CheckComRCReturnRC(autoCaller.rc());
     4817    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    48184818
    48194819    AutoWriteLock alock(this);
    … …  
    51815181    {
    51825182        rc = saveSettings();
    5183         CheckComRCReturnRC(rc);
     5183        if (FAILED(rc)) return rc;
    51845184    }
    51855185
    … …  
    52315231
    52325232    HRESULT rc = checkStateDependency(aDepType);
    5233     CheckComRCReturnRC(rc);
     5233    if (FAILED(rc)) return rc;
    52345234
    52355235    {
    … …  
    57255725        rc = mParent->GetGuestOSType(mUserData->mOSTypeId,
    57265726                                     guestOSType.asOutParam());
    5727         CheckComRCThrowRC(rc);
     5727        if (FAILED(rc)) throw rc;
    57285728
    57295729        // stateFile (optional)
    … …  
    57445744        /* snapshotFolder (optional) */
    57455745        rc = COMSETTER(SnapshotFolder)(Bstr(mData->m_pMachineConfigFile->strSnapshotFolder));
    5746         CheckComRCThrowRC(rc);
     5746        if (FAILED(rc)) throw rc;
    57475747
    57485748        /* currentStateModified (optional, default is true) */
    … …  
    57755775                              mData->m_pMachineConfigFile->uuidCurrentSnapshot,
    57765776                              NULL);        // no parent == first snapshot
    5777             CheckComRCThrowRC(rc);
     5777            if (FAILED(rc)) throw rc;
    57785778        }
    57795779
    57805780        /* Hardware node (required) */
    57815781        rc = loadHardware(mData->m_pMachineConfigFile->hardwareMachine);
    5782         CheckComRCThrowRC(rc);
     5782        if (FAILED(rc)) throw rc;
    57835783
    57845784        /* Load storage controllers */
    57855785        rc = loadStorageControllers(mData->m_pMachineConfigFile->storageMachine, aRegistered);
    5786         CheckComRCThrowRC(rc);
     5786        if (FAILED(rc)) throw rc;
    57875787
    57885788        /*
    … …  
    58585858                                data.uuid,
    58595859                                strStateFile);
    5860     CheckComRCReturnRC(rc);
     5860    if (FAILED(rc)) return rc;
    58615861
    58625862    /* create a snapshot object */
    … …  
    58715871                         pSnapshotMachine,
    58725872                         aParentSnapshot);
    5873     CheckComRCReturnRC (rc);
     5873    if (FAILED(rc)) return rc;
    58745874
    58755875    /* memorize the first snapshot if necessary */
    … …  
    58935893                          aCurSnapshotId,
    58945894                          pSnapshot);       // parent = the one we created above
    5895         CheckComRCReturnRC(rc);
     5895        if (FAILED(rc)) return rc;
    58965896    }
    58975897
    … …  
    59895989        /* RemoteDisplay */
    59905990        rc = mVRDPServer->loadSettings(data.vrdpSettings);
    5991         CheckComRCReturnRC (rc);
     5991        if (FAILED(rc)) return rc;
    59925992#endif
    59935993
    59945994        /* BIOS */
    59955995        rc = mBIOSSettings->loadSettings(data.biosSettings);
    5996         CheckComRCReturnRC (rc);
     5996        if (FAILED(rc)) return rc;
    59975997
    59985998        /* USB Controller */
    59995999        rc = mUSBController->loadSettings(data.usbController);
    6000         CheckComRCReturnRC (rc);
     6000        if (FAILED(rc)) return rc;
    60016001
    60026002        // network adapters
    … …  
    60106010            AssertBreak(nic.ulSlot < RT_ELEMENTS(mNetworkAdapters));
    60116011            rc = mNetworkAdapters[nic.ulSlot]->loadSettings(nic);
    6012             CheckComRCReturnRC (rc);
     6012            if (FAILED(rc)) return rc;
    60136013        }
    60146014
    … …  
    60226022            AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
    60236023            rc = mSerialPorts[s.ulSlot]->loadSettings(s);
    6024             CheckComRCReturnRC (rc);
     6024            if (FAILED(rc)) return rc;
    60256025        }
    60266026
    … …  
    60346034            AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
    60356035            rc = mParallelPorts[p.ulSlot]->loadSettings(p);
    6036             CheckComRCReturnRC (rc);
     6036            if (FAILED(rc)) return rc;
    60376037        }
    60386038
    60396039        /* AudioAdapter */
    60406040        rc = mAudioAdapter->loadSettings(data.audioAdapter);
    6041         CheckComRCReturnRC (rc);
     6041        if (FAILED(rc)) return rc;
    60426042
    60436043        for (settings::SharedFoldersList::const_iterator it = data.llSharedFolders.begin();
    … …  
    60476047            const settings::SharedFolder &sf = *it;
    60486048            rc = CreateSharedFolder(Bstr(sf.strName), Bstr(sf.strHostPath), sf.fWritable);
    6049             CheckComRCReturnRC (rc);
     6049            if (FAILED(rc)) return rc;
    60506050        }
    60516051
    … …  
    61186118                        ctlData.storageBus,
    61196119                        ctlData.ulInstance);
    6120         CheckComRCReturnRC (rc);
     6120        if (FAILED(rc)) return rc;
    61216121
    61226122        mStorageControllers->push_back(pCtl);
    61236123
    61246124        rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
    6125         CheckComRCReturnRC (rc);
     6125        if (FAILED(rc)) return rc;
    61266126
    61276127        rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
    6128         CheckComRCReturnRC (rc);
     6128        if (FAILED(rc)) return rc;
    61296129
    61306130        /* Set IDE emulation settings (only for AHCI controller). */
    … …  
    61446144                                aRegistered,
    61456145                                aSnapshotId);
    6146         CheckComRCReturnRC (rc);
     6146        if (FAILED(rc)) return rc;
    61476147    }
    61486148
    … …  
    63496349                               dev.lDevice,
    63506350                               dev.deviceType);
    6351         CheckComRCBreakRC(rc);
     6351        if (FAILED(rc)) break;
    63526352
    63536353        /* associate the medium with this machine and snapshot */
    … …  
    64816481{
    64826482    AutoCaller autoCaller(this);
    6483     CheckComRCReturnRC(autoCaller.rc());
     6483    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    64846484
    64856485    AutoReadLock alock(this);
    … …  
    66666666        }
    66676667
    6668         CheckComRCReturnRC(rc);
     6668        if (FAILED(rc)) return rc;
    66696669    }
    66706670
    … …  
    67706770    bool isNew = false;
    67716771    rc = prepareSaveSettings(isRenamed, isNew);
    6772     CheckComRCReturnRC(rc);
     6772    if (FAILED(rc)) return rc;
    67736773
    67746774    try
    … …  
    68166816
    68176817        rc = saveHardware(mData->m_pMachineConfigFile->hardwareMachine);
    6818         CheckComRCThrowRC(rc);
     6818        if (FAILED(rc)) throw rc;
    68196819
    68206820        rc = saveStorageControllers(mData->m_pMachineConfigFile->storageMachine);
    6821         CheckComRCThrowRC(rc);
     6821        if (FAILED(rc)) throw rc;
    68226822
    68236823        // save snapshots
    68246824        rc = saveAllSnapshots();
    6825         CheckComRCThrowRC(rc);
     6825        if (FAILED(rc)) throw rc;
    68266826
    68276827        // now spit it all out
    … …  
    68826882
    68836883            rc = mData->mFirstSnapshot->saveSnapshot(snap, false /*aAttrsOnly*/);
    6884             CheckComRCThrowRC(rc);
     6884            if (FAILED(rc)) throw rc;
    68856885        }
    68866886
    … …  
    69696969        /* VRDP settings (optional) */
    69706970        rc = mVRDPServer->saveSettings(data.vrdpSettings);
    6971         CheckComRCThrowRC(rc);
     6971        if (FAILED(rc)) throw rc;
    69726972#endif
    69736973
    69746974        /* BIOS (required) */
    69756975        rc = mBIOSSettings->saveSettings(data.biosSettings);
    6976         CheckComRCThrowRC(rc);
     6976        if (FAILED(rc)) throw rc;
    69776977
    69786978        /* USB Controller (required) */
    69796979        rc = mUSBController->saveSettings(data.usbController);
    6980         CheckComRCThrowRC(rc);
     6980        if (FAILED(rc)) throw rc;
    69816981
    69826982        /* Network adapters (required) */
    … …  
    69896989            nic.ulSlot = slot;
    69906990            rc = mNetworkAdapters[slot]->saveSettings(nic);
    6991             CheckComRCThrowRC(rc);
     6991            if (FAILED(rc)) throw rc;
    69926992
    69936993            data.llNetworkAdapters.push_back(nic);
    … …  
    70037003            s.ulSlot = slot;
    70047004            rc = mSerialPorts[slot]->saveSettings(s);
    7005             CheckComRCReturnRC (rc);
     7005            if (FAILED(rc)) return rc;
    70067006
    70077007            data.llSerialPorts.push_back(s);
    … …  
    70177017            p.ulSlot = slot;
    70187018            rc = mParallelPorts[slot]->saveSettings(p);
    7019             CheckComRCReturnRC (rc);
     7019            if (FAILED(rc)) return rc;
    70207020
    70217021            data.llParallelPorts.push_back(p);
    … …  
    70247024        /* Audio adapter */
    70257025        rc = mAudioAdapter->saveSettings(data.audioAdapter);
    7026         CheckComRCReturnRC (rc);
     7026        if (FAILED(rc)) return rc;
    70277027
    70287028        /* Shared folders */
    … …  
    71387138
    71397139    HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->name()), atts);
    7140     CheckComRCReturnRC (rc);
     7140    if (FAILED(rc)) return rc;
    71417141
    71427142    data.llAttachedDevices.clear();
    … …  
    71857185        return S_OK;
    71867186
    7187     AutoCaller autoCaller (this);
     7187    AutoCaller autoCaller(this);
    71887188    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
    71897189
    … …  
    73047304                    Assert(pHD);
    73057305                    rc = pHD->LockRead (NULL);
    7306                     CheckComRCThrowRC(rc);
     7306                    if (FAILED(rc)) throw rc;
    73077307                    lockedMedia.push_back(pHD);
    73087308                }
    … …  
    73637363                            BstrFmt("%ls"RTPATH_SLASH_STR,
    73647364                                    mUserData->mSnapshotFolderFull.raw()).raw());
    7365             CheckComRCThrowRC(rc);
     7365            if (FAILED(rc)) throw rc;
    73667366
    73677367            /* leave the lock before the potentially lengthy operation */
    … …  
    73887388            }
    73897389
     7390            if (FAILED(rc)) throw rc;
     7391
    73907392            alock.enter();
    7391 
    7392             CheckComRCThrowRC(rc);
    73937393
    73947394            rc = diff->attachTo(mData->mUuid);
    … …  
    74057405                                  DeviceType_HardDisk,
    74067406                                  true /* aImplicit */);
    7407             CheckComRCThrowRC(rc);
     7407            if (FAILED(rc)) throw rc;
    74087408
    74097409            mMediaData->mAttachments.push_back(attachment);
    … …  
    89058905    /* if captureDeviceForVM() fails, it must have set extended error info */
    89068906    MultiResult rc = mParent->host()->checkUSBProxyService();
    8907     CheckComRCReturnRC(rc);
     8907    if (FAILED(rc)) return rc;
    89088908
    89098909    USBProxyService *service = mParent->host()->usbProxyService();
    … …  
    90149014     *  informs us it is closed right after we've been uninitialized -- it's ok.
    90159015     */
    9016     CheckComRCReturnRC(autoCaller.rc());
     9016    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    90179017
    90189018    /* get IInternalSessionControl interface */
    … …  
    93449344         */
    93459345        AutoCaller autoCaller(this);
    9346         CheckComRCReturnRC(autoCaller.rc());
     9346        if (FAILED(autoCaller.rc())) return autoCaller.rc();
    93479347
    93489348        AutoWriteLock alock(this);
    … …  
    97409740    /* This notification may happen after the machine object has been
    97419741     * uninitialized (the session was closed), so don't assert. */
    9742     CheckComRCReturnRC(autoCaller.rc());
     9742    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    97439743
    97449744    ComPtr<IInternalSessionControl> directControl;
    … …  
    97729772    /* This notification may happen after the machine object has been
    97739773     * uninitialized (the session was closed), so don't assert. */
    9774     CheckComRCReturnRC(autoCaller.rc());
     9774    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    97759775
    97769776    ComPtr<IInternalSessionControl> directControl;
    … …  
    99039903                {
    99049904                    rc = medium->RefreshState(&mediumState);
    9905                     CheckComRCThrowRC(rc);
     9905                    if (FAILED(rc)) throw rc;
    99069906
    99079907                    if (mediumState == MediumState_Inaccessible)
    … …  
    99099909                        Bstr error;
    99109910                        rc = medium->COMGETTER(LastAccessError)(error.asOutParam());
    9911                         CheckComRCThrowRC(rc);
     9911                        if (FAILED(rc)) throw rc;
    99129912
    99139913                        Bstr loc;
    99149914                        rc = medium->COMGETTER(Location)(loc.asOutParam());
    9915                         CheckComRCThrowRC(rc);
     9915                        if (FAILED(rc)) throw rc;
    99169916
    99179917                        /* collect multiple errors */
    … …  
    99359935                        /* HardDisk and Floppy medium must be locked for writing */
    99369936                        rc = medium->LockWrite(NULL);
    9937                         CheckComRCThrowRC(rc);
     9937                        if (FAILED(rc)) throw rc;
    99389938                    }
    99399939                    else
    … …  
    99419941                        /* DVD medium must be locked for reading */
    99429942                        rc = medium->LockRead(NULL);
    9943                         CheckComRCThrowRC(rc);
     9943                        if (FAILED(rc)) throw rc;
    99449944                    }
    99459945
    … …  
    99539953                {
    99549954                    rc = medium->LockRead(NULL);
    9955                     CheckComRCThrowRC(rc);
     9955                    if (FAILED(rc)) throw rc;
    99569956
    99579957                    mData->mSession.mLockedMedia.push_back(
    … …  
    99689968        }
    99699969
     9970        /* @todo r=dj is this correct? first restoring the eik and then throwing? */
    99709971        eik.restore();
    9971         CheckComRCThrowRC((HRESULT)mrc);
     9972        HRESULT rc2 = (HRESULT)mrc;
     9973        if (FAILED(rc2)) throw rc2;
    99729974    }
    99739975    catch (HRESULT aRC)

  • trunk/src/VBox/Main/MediumAttachmentImpl.cpp

    r24989 r25149  
    180180
    181181    AutoCaller autoCaller(this);
    182     CheckComRCReturnRC(autoCaller.rc());
     182    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    183183
    184184    AutoReadLock alock(this);
    … …  
    197197
    198198    AutoCaller autoCaller(this);
    199     CheckComRCReturnRC(autoCaller.rc());
     199    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    200200
    201201    /* m->controller is constant during life time, no need to lock */
    … …  
    213213
    214214    AutoCaller autoCaller(this);
    215     CheckComRCReturnRC(autoCaller.rc());
     215    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    216216
    217217    /* m->port is constant during life time, no need to lock */
    … …  
    229229
    230230    AutoCaller autoCaller(this);
    231     CheckComRCReturnRC(autoCaller.rc());
     231    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    232232
    233233    /* m->device is constant during life time, no need to lock */
    … …  
    245245
    246246    AutoCaller autoCaller(this);
    247     CheckComRCReturnRC(autoCaller.rc());
     247    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    248248
    249249    /* m->type is constant during life time, no need to lock */
    … …  
    261261
    262262    AutoCaller autoCaller(this);
    263     CheckComRCReturnRC(autoCaller.rc());
     263    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    264264
    265265    AutoReadLock lock(this);

  • trunk/src/VBox/Main/MediumFormatImpl.cpp

    r24000 r25149  
    175175    CheckComArgOutPointerValid(aId);
    176176
    177     AutoCaller autoCaller (this);
    178     CheckComRCReturnRC (autoCaller.rc());
     177    AutoCaller autoCaller(this);
     178    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    179179
    180180    /* this is const, no need to lock */
    … …  
    188188    CheckComArgOutPointerValid(aName);
    189189
    190     AutoCaller autoCaller (this);
    191     CheckComRCReturnRC (autoCaller.rc());
     190    AutoCaller autoCaller(this);
     191    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    192192
    193193    /* this is const, no need to lock */
    … …  
    203203        return E_POINTER;
    204204
    205     AutoCaller autoCaller (this);
    206     CheckComRCReturnRC (autoCaller.rc());
     205    AutoCaller autoCaller(this);
     206    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    207207
    208208    /* this is const, no need to lock */
    … …  
    221221    CheckComArgOutPointerValid(aCaps);
    222222
    223     AutoCaller autoCaller (this);
    224     CheckComRCReturnRC (autoCaller.rc());
     223    AutoCaller autoCaller(this);
     224    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    225225
    226226    /* m.capabilities is const, no need to lock */
    … …  
    249249    CheckComArgSafeArrayNotNull(aDefaults);
    250250
    251     AutoCaller autoCaller (this);
    252     CheckComRCReturnRC (autoCaller.rc());
     251    AutoCaller autoCaller(this);
     252    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    253253
    254254    /* this is const, no need to lock */

  • trunk/src/VBox/Main/MediumImpl.cpp

    r24989 r25149  
    405405    {
    406406        HRESULT rc = aMedium->addCaller();
    407         CheckComRCReturnRC(rc);
     407        if (FAILED(rc)) return rc;
    408408
    409409        AutoWriteLock alock(aMedium);
    … …  
    423423        MediumState_T m;
    424424        rc = aMedium->RefreshState(&m);
    425         CheckComRCReturnRC(rc);
     425        if (FAILED(rc)) return rc;
    426426        /* go to Deleting */
    427427        switch (m)
    … …  
    443443            {
    444444                rc = aMedium->mParent->addCaller();
    445                 CheckComRCReturnRC(rc);
     445                if (FAILED(rc)) return rc;
    446446
    447447                mParent = aMedium->mParent;
    … …  
    457457                ComObjPtr<Medium> pMedium = *it;
    458458                rc = pMedium->addCaller();
    459                 CheckComRCReturnRC(rc);
     459                if (FAILED(rc)) return rc;
    460460
    461461                rc = pMedium->LockWrite(NULL);
    … …  
    476476    {
    477477        HRESULT rc = aMedium->addCaller();
    478         CheckComRCReturnRC(rc);
     478        if (FAILED(rc)) return rc;
    479479
    480480        AutoWriteLock alock(aMedium);
    … …  
    506506    {
    507507        HRESULT rc = aMedium->addCaller();
    508         CheckComRCReturnRC(rc);
     508        if (FAILED(rc)) return rc;
    509509
    510510        AutoWriteLock alock(aMedium);
    … …  
    662662    {
    663663        HRESULT rc = aMedium->addCaller();
    664         CheckComRCReturnRC(rc);
     664        if (FAILED(rc)) return rc;
    665665
    666666        push_front(aMedium);
    … …  
    686686            {
    687687                rc = (*it)->RefreshState(&mediumState);
    688                 CheckComRCReturnRC(rc);
     688                if (FAILED(rc)) return rc;
    689689
    690690                if (mediumState == MediumState_Inaccessible)
    … …  
    692692                    Bstr error;
    693693                    rc = (*it)->COMGETTER(LastAccessError)(error.asOutParam());
    694                     CheckComRCReturnRC(rc);
     694                    if (FAILED(rc)) return rc;
    695695
    696696                    Bstr loc;
    697697                    rc = (*it)->COMGETTER(Location)(loc.asOutParam());
    698                     CheckComRCReturnRC(rc);
     698                    if (FAILED(rc)) return rc;
    699699
    700700                    /* collect multiple errors */
    … …  
    712712
    713713            rc = (*it)->LockRead(&mediumState);
    714             CheckComRCReturnRC(rc);
     714            if (FAILED(rc)) return rc;
    715715        }
    716716
    717717        eik.restore();
    718         CheckComRCReturnRC((HRESULT)mrc);
     718        HRESULT rc2 = (HRESULT)mrc;
     719        if (FAILED(rc2)) return rc2;
    719720
    720721        return S_OK;
    … …  
    740741            {
    741742                rc = (*it)->RefreshState(&mediumState);
    742                 CheckComRCReturnRC(rc);
     743                if (FAILED(rc)) return rc;
    743744
    744745                if (mediumState == MediumState_Inaccessible)
    … …  
    746747                    Bstr error;
    747748                    rc = (*it)->COMGETTER(LastAccessError)(error.asOutParam());
    748                     CheckComRCReturnRC(rc);
     749                    if (FAILED(rc)) return rc;
    749750
    750751                    Bstr loc;
    751752                    rc = (*it)->COMGETTER(Location)(loc.asOutParam());
    752                     CheckComRCReturnRC(rc);
     753                    if (FAILED(rc)) return rc;
    753754
    754755                    /* collect multiple errors */
    … …  
    772773
    773774        eik.restore();
    774         CheckComRCReturnRC((HRESULT) mrc);
     775        HRESULT rc2 = (HRESULT)mrc;
     776        if (FAILED(rc2)) return rc2;
    775777
    776778        return S_OK;
    … …  
    900902
    901903    rc = setFormat(aFormat);
    902     CheckComRCReturnRC(rc);
     904    if (FAILED(rc)) return rc;
    903905
    904906    if (m->formatObj->capabilities() & MediumFormatCapabilities_File)
    905907    {
    906908        rc = setLocation(aLocation);
    907         CheckComRCReturnRC(rc);
     909        if (FAILED(rc)) return rc;
    908910    }
    909911    else
    910912    {
    911913        rc = setLocation(aLocation);
    912         CheckComRCReturnRC(rc);
     914        if (FAILED(rc)) return rc;
    913915
    914916        /// @todo later we may want to use a pfnComposeLocation backend info
    … …  
    10061008    else
    10071009        rc = setLocation(aLocation, "RAW");
    1008     CheckComRCReturnRC(rc);
     1010    if (FAILED(rc)) return rc;
    10091011
    10101012    /* save the new uuid values, will be used by queryInfo() */
    … …  
    11031105        AssertReturn(!data.strFormat.isEmpty(), E_FAIL);
    11041106        rc = setFormat(Bstr(data.strFormat));
    1105         CheckComRCReturnRC(rc);
     1107        if (FAILED(rc)) return rc;
    11061108    }
    11071109    else
    … …  
    11121114        else
    11131115            rc = setFormat(Bstr("RAW"));
    1114         CheckComRCReturnRC(rc);
     1116        if (FAILED(rc)) return rc;
    11151117    }
    11161118
    … …  
    11381140    /* required */
    11391141    rc = setLocation(data.strLocation);
    1140     CheckComRCReturnRC(rc);
     1142    if (FAILED(rc)) return rc;
    11411143
    11421144    if (aDeviceType == DeviceType_HardDisk)
    … …  
    11641166    /* load all children */
    11651167    for (settings::MediaList::const_iterator it = data.llChildren.begin();
    1166          it != data.llChildren.end(); ++ it)
     1168         it != data.llChildren.end();
     1169         ++it)
    11671170    {
    11681171        const settings::Medium &med = *it;
    … …  
    11741177                       aDeviceType,
    11751178                       med);              // child data
    1176         CheckComRCBreakRC(rc);
     1179        if (FAILED(rc)) break;
    11771180
    11781181        rc = mVirtualBox->registerHardDisk(pHD, false /* aSaveRegistry */);
    1179         CheckComRCBreakRC(rc);
     1182        if (FAILED(rc)) break;
    11801183    }
    11811184
    … …  
    12391242    m->hostDrive = true;
    12401243    HRESULT rc = setFormat(Bstr("RAW"));
    1241     CheckComRCReturnRC(rc);
     1244    if (FAILED(rc)) return rc;
    12421245    rc = setLocation(aLocation);
    1243     CheckComRCReturnRC(rc);
     1246    if (FAILED(rc)) return rc;
    12441247    m->strDescription = aDescription;
    12451248
    … …  
    13171320
    13181321    AutoCaller autoCaller(this);
    1319     CheckComRCReturnRC(autoCaller.rc());
     1322    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13201323
    13211324    AutoReadLock alock(this);
    … …  
    13311334
    13321335    AutoCaller autoCaller(this);
    1333     CheckComRCReturnRC(autoCaller.rc());
     1336    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13341337
    13351338    AutoReadLock alock(this);
    … …  
    13481351
    13491352    AutoCaller autoCaller(this);
    1350     CheckComRCReturnRC(autoCaller.rc());
     1353    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13511354
    13521355    AutoWriteLock alock(this);
    … …  
    13641367
    13651368    AutoCaller autoCaller(this);
    1366     CheckComRCReturnRC(autoCaller.rc());
     1369    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13671370
    13681371    AutoReadLock alock(this);
    … …  
    13781381
    13791382    AutoCaller autoCaller(this);
    1380     CheckComRCReturnRC(autoCaller.rc());
     1383    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13811384
    13821385    AutoReadLock alock(this);
    … …  
    13921395
    13931396    AutoCaller autoCaller(this);
    1394     CheckComRCReturnRC(autoCaller.rc());
     1397    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13951398
    13961399    AutoWriteLock alock(this);
    … …  
    14131416
    14141417    AutoCaller autoCaller(this);
    1415     CheckComRCReturnRC(autoCaller.rc());
     1418    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14161419
    14171420    AutoReadLock alock(this);
    … …  
    14271430
    14281431    AutoCaller autoCaller(this);
    1429     CheckComRCReturnRC(autoCaller.rc());
     1432    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14301433
    14311434    AutoReadLock alock(this);
    … …  
    14411444
    14421445    AutoCaller autoCaller(this);
    1443     CheckComRCReturnRC(autoCaller.rc());
     1446    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14441447
    14451448    AutoReadLock alock(this);
    … …  
    14551458
    14561459    AutoCaller autoCaller(this);
    1457     CheckComRCReturnRC(autoCaller.rc());
     1460    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14581461
    14591462    AutoReadLock alock(this);
    … …  
    14701473
    14711474    AutoCaller autoCaller(this);
    1472     CheckComRCReturnRC(autoCaller.rc());
     1475    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14731476
    14741477    /* no need to lock, m->format is const */
    … …  
    14841487
    14851488    AutoCaller autoCaller(this);
    1486     CheckComRCReturnRC(autoCaller.rc());
     1489    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14871490
    14881491    AutoReadLock alock(this);
    … …  
    14961499{
    14971500    AutoCaller autoCaller(this);
    1498     CheckComRCReturnRC(autoCaller.rc());
     1501    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14991502
    15001503    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    15671570
    15681571    AutoCaller autoCaller(this);
    1569     CheckComRCReturnRC(autoCaller.rc());
     1572    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15701573
    15711574    /* we access mParent */
    … …  
    15831586
    15841587    AutoCaller autoCaller(this);
    1585     CheckComRCReturnRC(autoCaller.rc());
     1588    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15861589
    15871590    /* we access children */
    … …  
    16121615
    16131616    AutoCaller autoCaller(this);
    1614     CheckComRCReturnRC(autoCaller.rc());
     1617    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16151618
    16161619    /* isRadOnly() will do locking */
    … …  
    16271630    {
    16281631        AutoCaller autoCaller(this);
    1629         CheckComRCReturnRC(autoCaller.rc());
     1632        if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16301633
    16311634        AutoReadLock alock(this);
    … …  
    16561659
    16571660    AutoCaller autoCaller(this);
    1658     CheckComRCReturnRC(autoCaller.rc());
     1661    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16591662
    16601663    AutoReadLock alock(this);
    … …  
    16711674{
    16721675    AutoCaller autoCaller(this);
    1673     CheckComRCReturnRC(autoCaller.rc());
     1676    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16741677
    16751678    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    16951698
    16961699    AutoCaller autoCaller(this);
    1697     CheckComRCReturnRC(autoCaller.rc());
     1700    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16981701
    16991702    AutoReadLock alock(this);
    … …  
    17131716
    17141717    AutoCaller autoCaller(this);
    1715     CheckComRCReturnRC(autoCaller.rc());
     1718    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17161719
    17171720    AutoReadLock alock(this);
    … …  
    17411744
    17421745    AutoCaller autoCaller(this);
    1743     CheckComRCReturnRC(autoCaller.rc());
     1746    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17441747
    17451748    /* queryInfo() locks this for writing. */
    … …  
    17731776
    17741777    AutoCaller autoCaller(this);
    1775     CheckComRCReturnRC(autoCaller.rc());
     1778    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17761779
    17771780    AutoReadLock alock(this);
    … …  
    18241827{
    18251828    AutoCaller autoCaller(this);
    1826     CheckComRCReturnRC(autoCaller.rc());
     1829    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18271830
    18281831    AutoWriteLock alock(this);
    … …  
    18791882{
    18801883    AutoCaller autoCaller(this);
    1881     CheckComRCReturnRC(autoCaller.rc());
     1884    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18821885
    18831886    AutoWriteLock alock(this);
    … …  
    19231926{
    19241927    AutoCaller autoCaller(this);
    1925     CheckComRCReturnRC(autoCaller.rc());
     1928    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19261929
    19271930    AutoWriteLock alock(this);
    … …  
    19701973{
    19711974    AutoCaller autoCaller(this);
    1972     CheckComRCReturnRC(autoCaller.rc());
     1975    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19731976
    19741977    AutoWriteLock alock(this);
    … …  
    20042007{
    20052008    AutoMayUninitSpan mayUninitSpan(this);
    2006     CheckComRCReturnRC(mayUninitSpan.rc());
     2009    if (FAILED(mayUninitSpan.rc())) return mayUninitSpan.rc();
    20072010
    20082011    if (mayUninitSpan.alreadyInProgress())
    … …  
    20392042    /* perform extra media-dependent close checks */
    20402043    HRESULT rc = canClose();
    2041     CheckComRCReturnRC(rc);
     2044    if (FAILED(rc)) return rc;
    20422045
    20432046    if (wasCreated)
    … …  
    20472050         * failure to do so) */
    20482051        rc = unregisterWithVirtualBox();
    2049         CheckComRCReturnRC(rc);
     2052        if (FAILED(rc)) return rc;
    20502053    }
    20512054
    … …  
    20622065
    20632066    AutoCaller autoCaller(this);
    2064     CheckComRCReturnRC(autoCaller.rc());
     2067    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20652068
    20662069    AutoReadLock alock(this);
    … …  
    20842087
    20852088    AutoCaller autoCaller(this);
    2086     CheckComRCReturnRC(autoCaller.rc());
     2089    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20872090
    20882091    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    21222125
    21232126    AutoCaller autoCaller(this);
    2124     CheckComRCReturnRC(autoCaller.rc());
     2127    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21252128
    21262129    AutoReadLock alock(this);
    … …  
    21582161
    21592162    AutoCaller autoCaller(this);
    2160     CheckComRCReturnRC(autoCaller.rc());
     2163    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21612164
    21622165    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    22022205
    22032206    AutoCaller autoCaller(this);
    2204     CheckComRCReturnRC(autoCaller.rc());
     2207    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22052208
    22062209    AutoWriteLock alock(this);
    … …  
    22342237          : BstrFmt(tr("Creating dynamic hard disk storage unit '%s'"), m->strLocationFull.raw()),
    22352238        TRUE /* aCancelable */);
    2236     CheckComRCReturnRC(rc);
     2239    if (FAILED(rc)) return rc;
    22372240
    22382241    /* setup task object and thread to carry out the operation
    … …  
    22462249
    22472250    rc = task->startThread();
    2248     CheckComRCReturnRC(rc);
     2251    if (FAILED(rc)) return rc;
    22492252
    22502253    /* go to Creating state on success */
    … …  
    22652268
    22662269    AutoCaller autoCaller(this);
    2267     CheckComRCReturnRC(autoCaller.rc());
     2270    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22682271
    22692272    ComObjPtr <Progress> progress;
    … …  
    22872290
    22882291    AutoCaller autoCaller(this);
    2289     CheckComRCReturnRC(autoCaller.rc());
     2292    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22902293
    22912294    ComObjPtr<Medium> diff;
    22922295    HRESULT rc = mVirtualBox->cast(aTarget, diff);
    2293     CheckComRCReturnRC(rc);
     2296    if (FAILED(rc)) return rc;
    22942297
    22952298    AutoWriteLock alock(this);
    … …  
    23032306     * created */
    23042307    rc = LockRead(NULL);
    2305     CheckComRCReturnRC(rc);
     2308    if (FAILED(rc)) return rc;
    23062309
    23072310    ComObjPtr <Progress> progress;
    … …  
    23262329{
    23272330    AutoCaller autoCaller(this);
    2328     CheckComRCReturnRC(autoCaller.rc());
     2331    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    23292332
    23302333    ReturnComNotImplemented();
    … …  
    23402343
    23412344    AutoCaller autoCaller(this);
    2342     CheckComRCReturnRC(autoCaller.rc());
     2345    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    23432346
    23442347    ComObjPtr <Medium> target;
    23452348    HRESULT rc = mVirtualBox->cast(aTarget, target);
    2346     CheckComRCReturnRC(rc);
     2349    if (FAILED(rc)) return rc;
    23472350    ComObjPtr <Medium> parent;
    23482351    if (aParent)
    23492352    {
    23502353        rc = mVirtualBox->cast(aParent, parent);
    2351         CheckComRCReturnRC(rc);
     2354        if (FAILED(rc)) return rc;
    23522355    }
    23532356
    … …  
    23742377        {
    23752378            rc = srcChain->addImage(hd);
    2376             CheckComRCThrowRC(rc);
     2379            if (FAILED(rc)) throw rc;
    23772380        }
    23782381        rc = srcChain->lockImagesRead();
    2379         CheckComRCThrowRC(rc);
     2382        if (FAILED(rc)) throw rc;
    23802383
    23812384        /* Build the parent chain and lock images in the proper order. */
    … …  
    23892392        {
    23902393            rc = parentChain->addImage(hd);
    2391             CheckComRCThrowRC(rc);
     2394            if (FAILED(rc)) throw rc;
    23922395        }
    23932396        if (target->m->state == MediumState_Created)
    … …  
    23962399             * contains the target image, and it gets locked for writing. */
    23972400            rc = parentChain->addImage(target);
    2398             CheckComRCThrowRC(rc);
     2401            if (FAILED(rc)) throw rc;
    23992402            rc = parentChain->lockImagesReadAndLastWrite();
    2400             CheckComRCThrowRC(rc);
     2403            if (FAILED(rc)) throw rc;
    24012404        }
    24022405        else
    24032406        {
    24042407            rc = parentChain->lockImagesRead();
    2405             CheckComRCThrowRC(rc);
     2408            if (FAILED(rc)) throw rc;
    24062409        }
    24072410
    … …  
    24112414                    target->m->strLocationFull.raw()),
    24122415            TRUE /* aCancelable */);
    2413         CheckComRCThrowRC(rc);
     2416        if (FAILED(rc)) throw rc;
    24142417
    24152418        /* setup task object and thread to carry out the operation
    … …  
    24242427
    24252428        rc = task->startThread();
    2426         CheckComRCThrowRC(rc);
     2429        if (FAILED(rc)) throw rc;
    24272430
    24282431        if (target->m->state == MediumState_NotCreated)
    … …  
    24542457
    24552458    AutoCaller autoCaller(this);
    2456     CheckComRCReturnRC(autoCaller.rc());
     2459    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    24572460
    24582461    AutoWriteLock alock(this);
    … …  
    24762479        {
    24772480            rc = imgChain->addImage(hd);
    2478             CheckComRCThrowRC(rc);
     2481            if (FAILED(rc)) throw rc;
    24792482        }
    24802483        rc = imgChain->lockImagesReadAndLastWrite();
    2481         CheckComRCThrowRC(rc);
     2484        if (FAILED(rc)) throw rc;
    24822485
    24832486        progress.createObject();
    … …  
    24852488             BstrFmt(tr("Compacting hard disk '%s'"), m->strLocationFull.raw()),
    24862489             TRUE /* aCancelable */);
    2487         CheckComRCThrowRC(rc);
     2490        if (FAILED(rc)) throw rc;
    24882491
    24892492        /* setup task object and thread to carry out the operation
    … …  
    24962499
    24972500        rc = task->startThread();
    2498         CheckComRCThrowRC(rc);
     2501        if (FAILED(rc)) throw rc;
    24992502
    25002503        /* task is now owned (or already deleted) by taskThread() so release it */
    … …  
    25202523
    25212524    AutoCaller autoCaller(this);
    2522     CheckComRCReturnRC(autoCaller.rc());
     2525    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25232526
    25242527    NOREF(aLogicalSize);
    … …  
    25322535
    25332536    AutoCaller autoCaller(this);
    2534     CheckComRCReturnRC(autoCaller.rc());
     2537    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25352538
    25362539    AutoWriteLock alock(this);
    … …  
    25442547
    25452548    HRESULT rc = canClose();
    2546     CheckComRCReturnRC(rc);
     2549    if (FAILED(rc)) return rc;
    25472550
    25482551    rc = LockWrite(NULL);
    2549     CheckComRCReturnRC(rc);
     2552    if (FAILED(rc)) return rc;
    25502553
    25512554    ComObjPtr <Progress> progress;
    … …  
    25582561                     m->strLocationFull.raw()),
    25592562            FALSE /* aCancelable */);
    2560         CheckComRCThrowRC(rc);
     2563        if (FAILED(rc)) throw rc;
    25612564
    25622565        /* setup task object and thread to carry out the operation
    … …  
    25672570
    25682571        rc = task->startThread();
    2569         CheckComRCThrowRC(rc);
     2572        if (FAILED(rc)) throw rc;
    25702573
    25712574        /* task is now owned (or already deleted) by taskThread() so release it */
    … …  
    26152618
    26162619    AutoCaller autoCaller(this);
    2617     CheckComRCReturnRC(autoCaller.rc());
     2620    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    26182621
    26192622    AutoWriteLock alock(this);
    … …  
    30093012{
    30103013    AutoCaller autoCaller(this);
    3011     CheckComRCReturnRC(autoCaller.rc());
     3014    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    30123015
    30133016    AutoReadLock alock(this);
    … …  
    36803683    else
    36813684        rc = LockWrite(NULL);
    3682     CheckComRCReturnRC(rc);
     3685    if (FAILED(rc)) return rc;
    36833686
    36843687    /* Copies of the input state fields which are not read-only,
    … …  
    39273930    else
    39283931        rc = UnlockWrite(NULL);
    3929     CheckComRCReturnRC(rc);
     3932    if (FAILED(rc)) return rc;
    39303933
    39313934    return rc;
    … …  
    40884091
    40894092    HRESULT rc = canClose();
    4090     CheckComRCReturnRC(rc);
     4093    if (FAILED(rc)) return rc;
    40914094
    40924095    /* go to Deleting state before leaving the lock */
    … …  
    41094112    m->state = MediumState_Created;
    41104113
    4111     CheckComRCReturnRC(rc);
     4114    if (FAILED(rc)) return rc;
    41124115
    41134116    ComObjPtr <Progress> progress;
    … …  
    41264129                         m->strLocationFull.raw()),
    41274130                FALSE /* aCancelable */);
    4128             CheckComRCReturnRC(rc);
     4131            if (FAILED(rc)) return rc;
    41294132        }
    41304133    }
    … …  
    41434146    {
    41444147        rc = task->startThread();
    4145         CheckComRCReturnRC(rc);
     4148        if (FAILED(rc)) return rc;
    41464149
    41474150        /* go to Deleting state before leaving the lock */
    … …  
    42054208
    42064209    AutoCaller autoCaller(this);
    4207     CheckComRCReturnRC(autoCaller.rc());
     4210    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    42084211
    42094212    AutoCaller targetCaller(aTarget);
    4210     CheckComRCReturnRC(targetCaller.rc());
     4213    if (FAILED(targetCaller.rc())) return targetCaller.rc();
    42114214
    42124215    AutoMultiWriteLock2 alock(this, aTarget);
    … …  
    42644267                         aTarget->m->strLocationFull.raw()),
    42654268                TRUE /* aCancelable */);
    4266             CheckComRCReturnRC(rc);
     4269            if (FAILED(rc)) return rc;
    42674270        }
    42684271    }
    … …  
    42914294    {
    42924295        rc = task->startThread();
    4293         CheckComRCReturnRC(rc);
     4296        if (FAILED(rc)) return rc;
    42944297
    42954298        /* go to Creating state before leaving the lock */
    … …  
    43974400            else
    43984401                rc = chain->addIntermediate(last);
    4399             CheckComRCReturnRC(rc);
     4402            if (FAILED(rc)) return rc;
    44004403
    44014404            if (last == first)
    … …  
    44894492
    44904493    AutoCaller autoCaller(this);
    4491     CheckComRCReturnRC(autoCaller.rc());
     4494    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    44924495
    44934496    HRESULT rc = S_OK;
    … …  
    45114514                        aChain->target()->getName().raw()),
    45124515                TRUE /* aCancelable */);
    4513             CheckComRCReturnRC(rc);
     4516            if (FAILED(rc)) return rc;
    45144517        }
    45154518    }
    … …  
    45354538    {
    45364539        rc = task->startThread();
    4537         CheckComRCReturnRC(rc);
     4540        if (FAILED(rc)) return rc;
    45384541    }
    45394542
    … …  
    49384941                    /* ensure the directory exists */
    49394942                    rc = VirtualBox::ensureFilePathExists(location);
    4940                     CheckComRCThrowRC(rc);
     4943                    if (FAILED(rc)) throw rc;
    49414944
    49424945                    PDMMEDIAGEOMETRY geo = { 0 }; /* auto-detect */
    … …  
    50555058                    /* ensure the target directory exists */
    50565059                    rc = VirtualBox::ensureFilePathExists(targetLocation);
    5057                     CheckComRCThrowRC(rc);
     5060                    if (FAILED(rc)) throw rc;
    50585061
    50595062                    /** @todo add VD_IMAGE_FLAGS_DIFF to the image flags, to
    … …  
    55255528                    /* ensure the target directory exists */
    55265529                    rc = VirtualBox::ensureFilePathExists(targetLocation);
    5527                     CheckComRCThrowRC(rc);
     5530                    if (FAILED(rc)) throw rc;
    55285531
    55295532                    PVBOXHDD targetHdd;

  • trunk/src/VBox/Main/MouseImpl.cpp

    r22810 r25149  
    139139
    140140    AutoCaller autoCaller(this);
    141     CheckComRCReturnRC(autoCaller.rc());
     141    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    142142
    143143    AutoWriteLock alock(this);
    … …  
    169169
    170170    AutoCaller autoCaller(this);
    171     CheckComRCReturnRC(autoCaller.rc());
     171    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    172172
    173173    AutoWriteLock alock(this);
    … …  
    203203
    204204    AutoCaller autoCaller(this);
    205     CheckComRCReturnRC(autoCaller.rc());
     205    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    206206
    207207    AutoWriteLock alock(this);
    … …  
    266266
    267267    AutoCaller autoCaller(this);
    268     CheckComRCReturnRC(autoCaller.rc());
     268    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    269269
    270270    AutoWriteLock alock(this);
    … …  
    413413    if (!CFGMR3AreValuesValid(pCfgHandle, "Object\0"))
    414414        return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
    415     AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER, 
     415    AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
    416416                    ("Configuration error: Not possible to attach anything to this driver!\n"),
    417417                    VERR_PDM_DRVINS_NO_ATTACH);
    … …  
    485485    NULL,
    486486    /* pfnDetach */
    487     NULL, 
     487    NULL,
    488488    /* pfnPowerOff */
    489     NULL, 
     489    NULL,
    490490    /* pfnSoftReset */
    491491    NULL,

  • trunk/src/VBox/Main/NetworkAdapterImpl.cpp

    r25098 r25149  
    181181
    182182    AutoCaller autoCaller(this);
    183     CheckComRCReturnRC(autoCaller.rc());
     183    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    184184
    185185    AutoReadLock alock(this);
    … …  
    193193{
    194194    AutoCaller autoCaller(this);
    195     CheckComRCReturnRC(autoCaller.rc());
    196 
    197     /* the machine needs to be mutable */
    198     Machine::AutoMutableStateDependency adep (mParent);
    199     CheckComRCReturnRC(adep.rc());
     195    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     196
     197    /* the machine needs to be mutable */
     198    Machine::AutoMutableStateDependency adep(mParent);
     199    if (FAILED(adep.rc())) return adep.rc();
    200200
    201201    AutoWriteLock alock(this);
    … …  
    240240
    241241    AutoCaller autoCaller(this);
    242     CheckComRCReturnRC(autoCaller.rc());
     242    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    243243
    244244    AutoReadLock alock(this);
    … …  
    254254
    255255    AutoCaller autoCaller(this);
    256     CheckComRCReturnRC(autoCaller.rc());
     256    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    257257
    258258    AutoReadLock alock(this);
    … …  
    266266{
    267267    AutoCaller autoCaller(this);
    268     CheckComRCReturnRC(autoCaller.rc());
    269 
    270     /* the machine needs to be mutable */
    271     Machine::AutoMutableStateDependency adep (mParent);
    272     CheckComRCReturnRC(adep.rc());
     268    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     269
     270    /* the machine needs to be mutable */
     271    Machine::AutoMutableStateDependency adep(mParent);
     272    if (FAILED(adep.rc())) return adep.rc();
    273273
    274274    AutoWriteLock alock(this);
    … …  
    293293
    294294    AutoCaller autoCaller(this);
    295     CheckComRCReturnRC(autoCaller.rc());
     295    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    296296
    297297    AutoReadLock alock(this);
    … …  
    307307{
    308308    AutoCaller autoCaller(this);
    309     CheckComRCReturnRC(autoCaller.rc());
    310 
    311     /* the machine needs to be mutable */
    312     Machine::AutoMutableStateDependency adep (mParent);
    313     CheckComRCReturnRC(adep.rc());
     309    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     310
     311    /* the machine needs to be mutable */
     312    Machine::AutoMutableStateDependency adep(mParent);
     313    if (FAILED(adep.rc())) return adep.rc();
    314314
    315315    AutoWriteLock alock(this);
    … …  
    390390
    391391    AutoCaller autoCaller(this);
    392     CheckComRCReturnRC(autoCaller.rc());
     392    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    393393
    394394    AutoReadLock alock(this);
    … …  
    404404
    405405    AutoCaller autoCaller(this);
    406     CheckComRCReturnRC(autoCaller.rc());
     406    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    407407
    408408    AutoReadLock alock(this);
    … …  
    420420
    421421    AutoCaller autoCaller(this);
    422     CheckComRCReturnRC(autoCaller.rc());
    423 
    424     /* the machine needs to be mutable */
    425     Machine::AutoMutableStateDependency adep (mParent);
    426     CheckComRCReturnRC(adep.rc());
     422    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     423
     424    /* the machine needs to be mutable */
     425    Machine::AutoMutableStateDependency adep(mParent);
     426    if (FAILED(adep.rc())) return adep.rc();
    427427
    428428    AutoWriteLock alock(this);
    … …  
    447447
    448448    AutoCaller autoCaller(this);
    449     CheckComRCReturnRC(autoCaller.rc());
     449    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    450450
    451451    AutoReadLock alock(this);
    … …  
    459459{
    460460    AutoCaller autoCaller(this);
    461     CheckComRCReturnRC(autoCaller.rc());
    462 
    463     /* the machine needs to be mutable */
    464     Machine::AutoMutableStateDependency adep (mParent);
    465     CheckComRCReturnRC(adep.rc());
     461    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     462
     463    /* the machine needs to be mutable */
     464    Machine::AutoMutableStateDependency adep(mParent);
     465    if (FAILED(adep.rc())) return adep.rc();
    466466
    467467    AutoWriteLock alock(this);
    … …  
    495495
    496496    AutoCaller autoCaller(this);
    497     CheckComRCReturnRC(autoCaller.rc());
     497    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    498498
    499499    AutoReadLock alock(this);
    … …  
    511511
    512512    AutoCaller autoCaller(this);
    513     CheckComRCReturnRC(autoCaller.rc());
    514 
    515     /* the machine needs to be mutable */
    516     Machine::AutoMutableStateDependency adep (mParent);
    517     CheckComRCReturnRC(adep.rc());
     513    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     514
     515    /* the machine needs to be mutable */
     516    Machine::AutoMutableStateDependency adep(mParent);
     517    if (FAILED(adep.rc())) return adep.rc();
    518518
    519519    AutoWriteLock alock(this);
    … …  
    538538
    539539    AutoCaller autoCaller(this);
    540     CheckComRCReturnRC(autoCaller.rc());
     540    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    541541
    542542    AutoReadLock alock(this);
    … …  
    550550{
    551551    AutoCaller autoCaller(this);
    552     CheckComRCReturnRC(autoCaller.rc());
    553 
    554     /* the machine needs to be mutable */
    555     Machine::AutoMutableStateDependency adep (mParent);
    556     CheckComRCReturnRC(adep.rc());
     552    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     553
     554    /* the machine needs to be mutable */
     555    Machine::AutoMutableStateDependency adep(mParent);
     556    if (FAILED(adep.rc())) return adep.rc();
    557557
    558558    AutoWriteLock alock(this);
    … …  
    577577
    578578    AutoCaller autoCaller(this);
    579     CheckComRCReturnRC(autoCaller.rc());
     579    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    580580
    581581    AutoReadLock alock(this);
    … …  
    589589{
    590590    AutoCaller autoCaller(this);
    591     CheckComRCReturnRC(autoCaller.rc());
    592 
    593     /* the machine needs to be mutable */
    594     Machine::AutoMutableStateDependency adep (mParent);
    595     CheckComRCReturnRC(adep.rc());
     591    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     592
     593    /* the machine needs to be mutable */
     594    Machine::AutoMutableStateDependency adep(mParent);
     595    if (FAILED(adep.rc())) return adep.rc();
    596596
    597597    AutoWriteLock alock(this);
    … …  
    616616
    617617    AutoCaller autoCaller(this);
    618     CheckComRCReturnRC(autoCaller.rc());
     618    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    619619
    620620    AutoReadLock alock(this);
    … …  
    627627{
    628628    AutoCaller autoCaller(this);
    629     CheckComRCReturnRC(autoCaller.rc());
    630 
    631     /* the machine needs to be mutable */
    632     Machine::AutoMutableStateDependency adep (mParent);
    633     CheckComRCReturnRC(adep.rc());
     629    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     630
     631    /* the machine needs to be mutable */
     632    Machine::AutoMutableStateDependency adep(mParent);
     633    if (FAILED(adep.rc())) return adep.rc();
    634634
    635635    AutoWriteLock alock(this);
    … …  
    654654
    655655    AutoCaller autoCaller(this);
    656     CheckComRCReturnRC(autoCaller.rc());
     656    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    657657
    658658    AutoReadLock alock(this);
    … …  
    666666{
    667667    AutoCaller autoCaller(this);
    668     CheckComRCReturnRC(autoCaller.rc());
    669 
    670     /* the machine needs to be mutable */
    671     Machine::AutoMutableStateDependency adep (mParent);
    672     CheckComRCReturnRC(adep.rc());
     668    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     669
     670    /* the machine needs to be mutable */
     671    Machine::AutoMutableStateDependency adep(mParent);
     672    if (FAILED(adep.rc())) return adep.rc();
    673673
    674674    AutoWriteLock alock(this);
    … …  
    694694{
    695695    AutoCaller autoCaller(this);
    696     CheckComRCReturnRC(autoCaller.rc());
    697 
    698     /* the machine needs to be mutable */
    699     Machine::AutoMutableStateDependency adep (mParent);
    700     CheckComRCReturnRC(adep.rc());
     696    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     697
     698    /* the machine needs to be mutable */
     699    Machine::AutoMutableStateDependency adep(mParent);
     700    if (FAILED(adep.rc())) return adep.rc();
    701701
    702702    AutoWriteLock alock(this);
    … …  
    734734{
    735735    AutoCaller autoCaller(this);
    736     CheckComRCReturnRC(autoCaller.rc());
    737 
    738     /* the machine needs to be mutable */
    739     Machine::AutoMutableStateDependency adep (mParent);
    740     CheckComRCReturnRC(adep.rc());
     736    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     737
     738    /* the machine needs to be mutable */
     739    Machine::AutoMutableStateDependency adep(mParent);
     740    if (FAILED(adep.rc())) return adep.rc();
    741741
    742742    AutoWriteLock alock(this);
    … …  
    776776{
    777777    AutoCaller autoCaller(this);
    778     CheckComRCReturnRC(autoCaller.rc());
    779 
    780     /* the machine needs to be mutable */
    781     Machine::AutoMutableStateDependency adep (mParent);
    782     CheckComRCReturnRC(adep.rc());
     778    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     779
     780    /* the machine needs to be mutable */
     781    Machine::AutoMutableStateDependency adep(mParent);
     782    if (FAILED(adep.rc())) return adep.rc();
    783783
    784784    AutoWriteLock alock(this);
    … …  
    826826{
    827827    AutoCaller autoCaller(this);
    828     CheckComRCReturnRC(autoCaller.rc());
    829 
    830     /* the machine needs to be mutable */
    831     Machine::AutoMutableStateDependency adep (mParent);
    832     CheckComRCReturnRC(adep.rc());
     828    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     829
     830    /* the machine needs to be mutable */
     831    Machine::AutoMutableStateDependency adep(mParent);
     832    if (FAILED(adep.rc())) return adep.rc();
    833833
    834834    AutoWriteLock alock(this);
    … …  
    868868{
    869869    AutoCaller autoCaller(this);
    870     CheckComRCReturnRC(autoCaller.rc());
    871 
    872     /* the machine needs to be mutable */
    873     Machine::AutoMutableStateDependency adep (mParent);
    874     CheckComRCReturnRC(adep.rc());
     870    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     871
     872    /* the machine needs to be mutable */
     873    Machine::AutoMutableStateDependency adep(mParent);
     874    if (FAILED(adep.rc())) return adep.rc();
    875875
    876876    AutoWriteLock alock(this);
    … …  
    926926    /* MAC address (can be null) */
    927927    rc = COMSETTER(MACAddress)(Bstr(data.strMACAddress));
    928     CheckComRCReturnRC(rc);
     928    if (FAILED(rc)) return rc;
    929929    /* cable (required) */
    930930    mData->mCableConnected = data.fCableConnected;
    … …  
    942942                mData->mNATNetwork = "";
    943943            rc = AttachToNAT();
    944             CheckComRCReturnRC(rc);
     944            if (FAILED(rc)) return rc;
    945945        break;
    946946
    947947        case NetworkAttachmentType_Bridged:
    948948            rc = COMSETTER(HostInterface)(Bstr(data.strName));
    949             CheckComRCReturnRC(rc);
     949            if (FAILED(rc)) return rc;
    950950            rc = AttachToBridgedInterface();
    951             CheckComRCReturnRC(rc);
     951            if (FAILED(rc)) return rc;
    952952        break;
    953953
    … …  
    957957
    958958            rc = AttachToInternalNetwork();
    959             CheckComRCReturnRC(rc);
     959            if (FAILED(rc)) return rc;
    960960        break;
    961961
    … …  
    963963#if defined(VBOX_WITH_NETFLT)
    964964            rc = COMSETTER(HostInterface)(Bstr(data.strName));
    965             CheckComRCReturnRC(rc);
     965            if (FAILED(rc)) return rc;
    966966#endif
    967967            rc = AttachToHostOnlyInterface();
    968             CheckComRCReturnRC(rc);
     968            if (FAILED(rc)) return rc;
    969969        break;
    970970
    971971        case NetworkAttachmentType_Null:
    972972            rc = Detach();
    973             CheckComRCReturnRC(rc);
     973            if (FAILED(rc)) return rc;
    974974        break;
    975975    }

  • trunk/src/VBox/Main/ParallelPortImpl.cpp

    r24000 r25149  
    201201    Bstr path(data.strPath);
    202202    HRESULT rc = checkSetPath (path);
    203     CheckComRCReturnRC(rc);
     203    if (FAILED(rc)) return rc;
    204204    mData->mPath = path;
    205205
    … …  
    316316
    317317    AutoCaller autoCaller(this);
    318     CheckComRCReturnRC(autoCaller.rc());
     318    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    319319
    320320    AutoReadLock alock(this);
    … …  
    330330
    331331    AutoCaller autoCaller(this);
    332     CheckComRCReturnRC(autoCaller.rc());
     332    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    333333
    334334    /* the machine needs to be mutable */
    335     Machine::AutoMutableStateDependency adep (mParent);
    336     CheckComRCReturnRC(adep.rc());
     335    Machine::AutoMutableStateDependency adep(mParent);
     336    if (FAILED(adep.rc())) return adep.rc();
    337337
    338338    AutoWriteLock alock(this);
    … …  
    364364
    365365    AutoCaller autoCaller(this);
    366     CheckComRCReturnRC(autoCaller.rc());
     366    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    367367
    368368    AutoReadLock alock(this);
    … …  
    378378
    379379    AutoCaller autoCaller(this);
    380     CheckComRCReturnRC(autoCaller.rc());
     380    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    381381
    382382    AutoReadLock alock(this);
    … …  
    398398
    399399    AutoCaller autoCaller(this);
    400     CheckComRCReturnRC(autoCaller.rc());
     400    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    401401
    402402    /* the machine needs to be mutable */
    403     Machine::AutoMutableStateDependency adep (mParent);
    404     CheckComRCReturnRC(adep.rc());
     403    Machine::AutoMutableStateDependency adep(mParent);
     404    if (FAILED(adep.rc())) return adep.rc();
    405405
    406406    AutoWriteLock alock(this);
    … …  
    432432
    433433    AutoCaller autoCaller(this);
    434     CheckComRCReturnRC(autoCaller.rc());
     434    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    435435
    436436    AutoReadLock alock(this);
    … …  
    452452
    453453    AutoCaller autoCaller(this);
    454     CheckComRCReturnRC(autoCaller.rc());
     454    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    455455
    456456    /* the machine needs to be mutable */
    457     Machine::AutoMutableStateDependency adep (mParent);
    458     CheckComRCReturnRC(adep.rc());
     457    Machine::AutoMutableStateDependency adep(mParent);
     458    if (FAILED(adep.rc())) return adep.rc();
    459459
    460460    AutoWriteLock alock(this);
    … …  
    486486
    487487    AutoCaller autoCaller(this);
    488     CheckComRCReturnRC(autoCaller.rc());
     488    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    489489
    490490    AutoReadLock alock(this);
    … …  
    515515{
    516516    AutoCaller autoCaller(this);
    517     CheckComRCReturnRC(autoCaller.rc());
     517    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    518518
    519519    /* the machine needs to be mutable */
    520     Machine::AutoMutableStateDependency adep (mParent);
    521     CheckComRCReturnRC(adep.rc());
     520    Machine::AutoMutableStateDependency adep(mParent);
     521    if (FAILED(adep.rc())) return adep.rc();
    522522
    523523    AutoWriteLock alock(this);
    … …  
    530530    {
    531531        HRESULT rc = checkSetPath (aPath);
    532         CheckComRCReturnRC(rc);
     532        if (FAILED(rc)) return rc;
    533533
    534534        mData.backup();

  • trunk/src/VBox/Main/Performance.cpp

    r22173 r25149  
    295295}
    296296
    297 void CircularBuffer::init(ULONG length)
     297void CircularBuffer::init(ULONG ulLength)
    298298{
    299299    if (mData)
    300300        RTMemFree(mData);
    301     mLength = length;
     301    mLength = ulLength;
    302302    if (mLength)
    303         mData = (ULONG *)RTMemAllocZ(length * sizeof(ULONG));
     303        mData = (ULONG*)RTMemAllocZ(ulLength * sizeof(ULONG));
    304304    else
    305305        mData = NULL;

  • trunk/src/VBox/Main/PerformanceImpl.cpp

    r25035 r25149  
    174174
    175175    AutoCaller autoCaller(this);
    176     CheckComRCReturnRC(autoCaller.rc());
     176    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    177177
    178178    AutoReadLock alock(this);
    … …  
    226226
    227227    AutoCaller autoCaller(this);
    228     CheckComRCReturnRC(autoCaller.rc());
     228    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    229229
    230230    pm::Filter filter (ComSafeArrayInArg (metricNames),
    … …  
    265265{
    266266    AutoCaller autoCaller(this);
    267     CheckComRCReturnRC(autoCaller.rc());
     267    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    268268
    269269    pm::Filter filter (ComSafeArrayInArg (metricNames),
    … …  
    314314{
    315315    AutoCaller autoCaller(this);
    316     CheckComRCReturnRC(autoCaller.rc());
     316    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    317317
    318318    pm::Filter filter (ComSafeArrayInArg (metricNames),
    … …  
    351351{
    352352    AutoCaller autoCaller(this);
    353     CheckComRCReturnRC(autoCaller.rc());
     353    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    354354
    355355    pm::Filter filter (ComSafeArrayInArg (metricNames),
    … …  
    394394{
    395395    AutoCaller autoCaller(this);
    396     CheckComRCReturnRC(autoCaller.rc());
     396    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    397397
    398398    pm::Filter filter (ComSafeArrayInArg (metricNames),

  • trunk/src/VBox/Main/ProgressImpl.cpp

    r24989 r25149  
    210210
    211211    AutoCaller autoCaller(this);
    212     CheckComRCReturnRC(autoCaller.rc());
     212    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    213213
    214214    /* mId is constant during life time, no need to lock */
    … …  
    223223
    224224    AutoCaller autoCaller(this);
    225     CheckComRCReturnRC(autoCaller.rc());
     225    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    226226
    227227    /* mDescription is constant during life time, no need to lock */
    … …  
    236236
    237237    AutoCaller autoCaller(this);
    238     CheckComRCReturnRC(autoCaller.rc());
     238    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    239239
    240240    /* mInitiator/mParent are constant during life time, no need to lock */
    … …  
    257257
    258258    AutoCaller autoCaller(this);
    259     CheckComRCReturnRC(autoCaller.rc());
     259    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    260260
    261261    AutoReadLock alock(this);
    … …  
    309309
    310310    AutoCaller autoCaller(this);
    311     CheckComRCReturnRC(autoCaller.rc());
     311    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    312312
    313313    AutoReadLock alock(this);
    … …  
    342342
    343343    AutoCaller autoCaller(this);
    344     CheckComRCReturnRC(autoCaller.rc());
     344    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    345345
    346346    checkForAutomaticTimeout();
    … …  
    375375
    376376    AutoCaller autoCaller(this);
    377     CheckComRCReturnRC(autoCaller.rc());
     377    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    378378
    379379    AutoReadLock alock(this);
    … …  
    389389
    390390    AutoCaller autoCaller(this);
    391     CheckComRCReturnRC(autoCaller.rc());
     391    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    392392
    393393    AutoReadLock alock(this);
    … …  
    403403
    404404    AutoCaller autoCaller(this);
    405     CheckComRCReturnRC(autoCaller.rc());
     405    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    406406
    407407    AutoReadLock alock(this);
    … …  
    421421
    422422    AutoCaller autoCaller(this);
    423     CheckComRCReturnRC(autoCaller.rc());
     423    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    424424
    425425    AutoReadLock alock(this);
    … …  
    439439
    440440    AutoCaller autoCaller(this);
    441     CheckComRCReturnRC(autoCaller.rc());
     441    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    442442
    443443    AutoReadLock alock(this);
    … …  
    453453
    454454    AutoCaller autoCaller(this);
    455     CheckComRCReturnRC(autoCaller.rc());
     455    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    456456
    457457    AutoReadLock alock(this);
    … …  
    467467
    468468    AutoCaller autoCaller(this);
    469     CheckComRCReturnRC(autoCaller.rc());
     469    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    470470
    471471    AutoReadLock alock(this);
    … …  
    481481
    482482    AutoCaller autoCaller(this);
    483     CheckComRCReturnRC(autoCaller.rc());
     483    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    484484
    485485    AutoReadLock alock(this);
    … …  
    496496{
    497497    AutoCaller autoCaller(this);
    498     CheckComRCReturnRC(autoCaller.rc());
     498    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    499499
    500500    AutoWriteLock alock(this);
    … …  
    514514
    515515    AutoCaller autoCaller(this);
    516     CheckComRCReturnRC(autoCaller.rc());
     516    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    517517
    518518    AutoReadLock alock(this);
    … …  
    599599{
    600600    HRESULT rc = ProgressBase::FinalConstruct();
    601     CheckComRCReturnRC(rc);
     601    if (FAILED(rc)) return rc;
    602602
    603603    mCompletedSem = NIL_RTSEMEVENTMULTI;
    … …  
    698698#endif
    699699                                      aInitiator, aDescription, aId);
    700     CheckComRCReturnRC(rc);
     700    if (FAILED(rc)) return rc;
    701701
    702702    mCancelable = aCancelable;
    … …  
    750750
    751751    rc = ProgressBase::protectedInit (autoInitSpan);
    752     CheckComRCReturnRC(rc);
     752    if (FAILED(rc)) return rc;
    753753
    754754    mCancelable = aCancelable;
    … …  
    821821
    822822    AutoCaller autoCaller(this);
    823     CheckComRCReturnRC(autoCaller.rc());
     823    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    824824
    825825    AutoWriteLock alock(this);
    … …  
    883883
    884884    AutoCaller autoCaller(this);
    885     CheckComRCReturnRC(autoCaller.rc());
     885    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    886886
    887887    AutoWriteLock alock(this);
    … …  
    941941{
    942942    AutoCaller autoCaller(this);
    943     CheckComRCReturnRC(autoCaller.rc());
     943    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    944944
    945945    AutoWriteLock alock(this);
    … …  
    12371237{
    12381238    HRESULT rc = ProgressBase::FinalConstruct();
    1239     CheckComRCReturnRC(rc);
     1239    if (FAILED(rc)) return rc;
    12401240
    12411241    mProgress = 0;
    … …  
    12801280#endif
    12811281                                      aInitiator, aDescription, aId);
    1282     CheckComRCReturnRC(rc);
     1282    if (FAILED(rc)) return rc;
    12831283
    12841284    mProgress = 0; /* the first object */
    … …  
    12941294    rc = mProgresses [0]->COMGETTER(OperationDescription) (
    12951295        m_bstrOperationDescription.asOutParam());
    1296     CheckComRCReturnRC(rc);
     1296    if (FAILED(rc)) return rc;
    12971297
    12981298    for (size_t i = 0; i < mProgresses.size(); i ++)
    … …  
    13021302            BOOL cancelable = FALSE;
    13031303            rc = mProgresses [i]->COMGETTER(Cancelable) (&cancelable);
    1304             CheckComRCReturnRC(rc);
     1304            if (FAILED(rc)) return rc;
    13051305
    13061306            if (!cancelable)
    … …  
    13111311            ULONG opCount = 0;
    13121312            rc = mProgresses [i]->COMGETTER(OperationCount) (&opCount);
    1313             CheckComRCReturnRC(rc);
     1313            if (FAILED(rc)) return rc;
    13141314
    13151315            m_cOperations += opCount;
    … …  
    13181318
    13191319    rc =  checkProgress();
    1320     CheckComRCReturnRC(rc);
     1320    if (FAILED(rc)) return rc;
    13211321
    13221322    return rc;
    … …  
    13921392
    13931393    AutoCaller autoCaller(this);
    1394     CheckComRCReturnRC(autoCaller.rc());
     1394    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13951395
    13961396    /* checkProgress needs a write lock */
    … …  
    14021402    {
    14031403        HRESULT rc = checkProgress();
    1404         CheckComRCReturnRC(rc);
     1404        if (FAILED(rc)) return rc;
    14051405
    14061406        /* global percent =
    … …  
    14181418
    14191419    AutoCaller autoCaller(this);
    1420     CheckComRCReturnRC(autoCaller.rc());
     1420    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14211421
    14221422    /* checkProgress needs a write lock */
    … …  
    14241424
    14251425    HRESULT rc = checkProgress();
    1426     CheckComRCReturnRC(rc);
     1426    if (FAILED(rc)) return rc;
    14271427
    14281428    return ProgressBase::COMGETTER(Completed) (aCompleted);
    … …  
    14341434
    14351435    AutoCaller autoCaller(this);
    1436     CheckComRCReturnRC(autoCaller.rc());
     1436    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14371437
    14381438    /* checkProgress needs a write lock */
    … …  
    14401440
    14411441    HRESULT rc = checkProgress();
    1442     CheckComRCReturnRC(rc);
     1442    if (FAILED(rc)) return rc;
    14431443
    14441444    return ProgressBase::COMGETTER(Canceled) (aCanceled);
    … …  
    14501450
    14511451    AutoCaller autoCaller(this);
    1452     CheckComRCReturnRC(autoCaller.rc());
     1452    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14531453
    14541454    /* checkProgress needs a write lock */
    … …  
    14561456
    14571457    HRESULT rc = checkProgress();
    1458     CheckComRCReturnRC(rc);
     1458    if (FAILED(rc)) return rc;
    14591459
    14601460    return ProgressBase::COMGETTER(ResultCode) (aResultCode);
    … …  
    14661466
    14671467    AutoCaller autoCaller(this);
    1468     CheckComRCReturnRC(autoCaller.rc());
     1468    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14691469
    14701470    /* checkProgress needs a write lock */
    … …  
    14721472
    14731473    HRESULT rc = checkProgress();
    1474     CheckComRCReturnRC(rc);
     1474    if (FAILED(rc)) return rc;
    14751475
    14761476    return ProgressBase::COMGETTER(ErrorInfo) (aErrorInfo);
    … …  
    14821482
    14831483    AutoCaller autoCaller(this);
    1484     CheckComRCReturnRC(autoCaller.rc());
     1484    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14851485
    14861486    /* checkProgress needs a write lock */
    … …  
    14881488
    14891489    HRESULT rc = checkProgress();
    1490     CheckComRCReturnRC(rc);
     1490    if (FAILED(rc)) return rc;
    14911491
    14921492    return ProgressBase::COMGETTER(Operation) (aOperation);
    … …  
    14981498
    14991499    AutoCaller autoCaller(this);
    1500     CheckComRCReturnRC(autoCaller.rc());
     1500    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15011501
    15021502    /* checkProgress needs a write lock */
    … …  
    15041504
    15051505    HRESULT rc = checkProgress();
    1506     CheckComRCReturnRC(rc);
     1506    if (FAILED(rc)) return rc;
    15071507
    15081508    return ProgressBase::COMGETTER(OperationDescription) (aOperationDescription);
    … …  
    15141514
    15151515    AutoCaller autoCaller(this);
    1516     CheckComRCReturnRC(autoCaller.rc());
     1516    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15171517
    15181518    /* checkProgress needs a write lock */
    … …  
    15201520
    15211521    HRESULT rc = checkProgress();
    1522     CheckComRCReturnRC(rc);
     1522    if (FAILED(rc)) return rc;
    15231523
    15241524    return ProgressBase::COMGETTER(OperationPercent) (aOperationPercent);
    … …  
    15551555
    15561556    AutoCaller autoCaller(this);
    1557     CheckComRCReturnRC(autoCaller.rc());
     1557    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15581558
    15591559    AutoWriteLock alock(this);
    … …  
    15631563    {
    15641564        RTTIMESPEC time;
    1565         RTTimeNow (&time);
     1565        RTTimeNow(&time);
    15661566
    15671567        HRESULT rc = S_OK;
    15681568        bool forever = aTimeout < 0;
    15691569        int64_t timeLeft = aTimeout;
    1570         int64_t lastTime = RTTimeSpecGetMilli (&time);
     1570        int64_t lastTime = RTTimeSpecGetMilli(&time);
    15711571
    15721572        while (!mCompleted && (forever || timeLeft > 0))
    15731573        {
    15741574            alock.leave();
    1575             rc = mProgresses.back()->WaitForCompletion (
    1576                 forever ? -1 : (LONG) timeLeft);
     1575            rc = mProgresses.back()->WaitForCompletion(forever ? -1 : (LONG) timeLeft);
    15771576            alock.enter();
    15781577
    … …  
    15801579                rc = checkProgress();
    15811580
    1582             CheckComRCBreakRC (rc);
     1581            if (FAILED(rc)) break;
    15831582
    15841583            if (!forever)
    15851584            {
    1586                 RTTimeNow (&time);
    1587                 timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
    1588                 lastTime = RTTimeSpecGetMilli (&time);
     1585                RTTimeNow(&time);
     1586                timeLeft -= RTTimeSpecGetMilli(&time) - lastTime;
     1587                lastTime = RTTimeSpecGetMilli(&time);
    15891588            }
    15901589        }
    15911590
    1592         CheckComRCReturnRC(rc);
     1591        if (FAILED(rc)) return rc;
    15931592    }
    15941593
    … …  
    16101609
    16111610    AutoCaller autoCaller(this);
    1612     CheckComRCReturnRC(autoCaller.rc());
     1611    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16131612
    16141613    AutoWriteLock alock(this);
    … …  
    16621661            alock.leave();
    16631662            /* wait for the appropriate progress operation completion */
    1664             rc = mProgresses [progress]-> WaitForOperationCompletion (
    1665                 operation, forever ? -1 : (LONG) timeLeft);
     1663            rc = mProgresses[progress]-> WaitForOperationCompletion(operation,
     1664                                                                    forever ? -1 : (LONG) timeLeft);
    16661665            alock.enter();
    16671666
    … …  
    16691668                rc = checkProgress();
    16701669
    1671             CheckComRCBreakRC (rc);
     1670            if (FAILED(rc)) break;
    16721671
    16731672            if (!forever)
    16741673            {
    1675                 RTTimeNow (&time);
    1676                 timeLeft -= RTTimeSpecGetMilli (&time) - lastTime;
    1677                 lastTime = RTTimeSpecGetMilli (&time);
     1674                RTTimeNow(&time);
     1675                timeLeft -= RTTimeSpecGetMilli(&time) - lastTime;
     1676                lastTime = RTTimeSpecGetMilli(&time);
    16781677            }
    16791678        }
    16801679
    1681         CheckComRCReturnRC(rc);
     1680        if (FAILED(rc)) return rc;
    16821681    }
    16831682
    … …  
    16901689{
    16911690    AutoCaller autoCaller(this);
    1692     CheckComRCReturnRC(autoCaller.rc());
     1691    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16931692
    16941693    AutoWriteLock alock(this);

  • trunk/src/VBox/Main/RemoteUSBDeviceImpl.cpp

    r21878 r25149  
    137137
    138138    AutoCaller autoCaller(this);
    139     CheckComRCReturnRC(autoCaller.rc());
     139    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    140140
    141141    /* this is const, no need to lock */
    … …  
    150150
    151151    AutoCaller autoCaller(this);
    152     CheckComRCReturnRC(autoCaller.rc());
     152    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    153153
    154154    /* this is const, no need to lock */
    … …  
    163163
    164164    AutoCaller autoCaller(this);
    165     CheckComRCReturnRC(autoCaller.rc());
     165    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    166166
    167167    /* this is const, no need to lock */
    … …  
    176176
    177177    AutoCaller autoCaller(this);
    178     CheckComRCReturnRC(autoCaller.rc());
     178    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    179179
    180180    /* this is const, no need to lock */
    … …  
    189189
    190190    AutoCaller autoCaller(this);
    191     CheckComRCReturnRC(autoCaller.rc());
     191    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    192192
    193193    /* this is const, no need to lock */
    … …  
    202202
    203203    AutoCaller autoCaller(this);
    204     CheckComRCReturnRC(autoCaller.rc());
     204    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    205205
    206206    /* this is const, no need to lock */
    … …  
    215215
    216216    AutoCaller autoCaller(this);
    217     CheckComRCReturnRC(autoCaller.rc());
     217    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    218218
    219219    /* this is const, no need to lock */
    … …  
    228228
    229229    AutoCaller autoCaller(this);
    230     CheckComRCReturnRC(autoCaller.rc());
     230    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    231231
    232232    /* this is const, no need to lock */
    … …  
    241241
    242242    AutoCaller autoCaller(this);
    243     CheckComRCReturnRC(autoCaller.rc());
     243    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    244244
    245245    /* this is const, no need to lock */
    … …  
    254254
    255255    AutoCaller autoCaller(this);
    256     CheckComRCReturnRC(autoCaller.rc());
     256    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    257257
    258258    /* this is const, no need to lock */
    … …  
    267267
    268268    AutoCaller autoCaller(this);
    269     CheckComRCReturnRC(autoCaller.rc());
     269    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    270270
    271271    /* this is const, no need to lock */
    … …  
    280280
    281281    AutoCaller autoCaller(this);
    282     CheckComRCReturnRC(autoCaller.rc());
     282    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    283283
    284284    /* RemoteUSBDevice is always remote. */
    … …  
    297297
    298298    AutoCaller autoCaller(this);
    299     CheckComRCReturnRC(autoCaller.rc());
     299    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    300300
    301301    AutoReadLock alock(this);

  • trunk/src/VBox/Main/SerialPortImpl.cpp

    r24000 r25149  
    205205    Bstr path(data.strPath);
    206206    HRESULT rc = checkSetPath(path);
    207     CheckComRCReturnRC(rc);
     207    if (FAILED(rc)) return rc;
    208208    mData->mPath = path;
    209209
    … …  
    348348
    349349    AutoCaller autoCaller(this);
    350     CheckComRCReturnRC(autoCaller.rc());
     350    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    351351
    352352    AutoReadLock alock(this);
    … …  
    362362
    363363    AutoCaller autoCaller(this);
    364     CheckComRCReturnRC(autoCaller.rc());
     364    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    365365
    366366    /* the machine needs to be mutable */
    367     Machine::AutoMutableStateDependency adep (mParent);
    368     CheckComRCReturnRC(adep.rc());
     367    Machine::AutoMutableStateDependency adep(mParent);
     368    if (FAILED(adep.rc())) return adep.rc();
    369369
    370370    AutoWriteLock alock(this);
    … …  
    389389
    390390    AutoCaller autoCaller(this);
    391     CheckComRCReturnRC(autoCaller.rc());
     391    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    392392
    393393    AutoReadLock alock(this);
    … …  
    401401{
    402402    AutoCaller autoCaller(this);
    403     CheckComRCReturnRC(autoCaller.rc());
     403    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    404404
    405405    /* the machine needs to be mutable */
    406     Machine::AutoMutableStateDependency adep (mParent);
    407     CheckComRCReturnRC(adep.rc());
     406    Machine::AutoMutableStateDependency adep(mParent);
     407    if (FAILED(adep.rc())) return adep.rc();
    408408
    409409    AutoWriteLock alock(this);
    … …  
    463463
    464464    AutoCaller autoCaller(this);
    465     CheckComRCReturnRC(autoCaller.rc());
     465    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    466466
    467467    AutoReadLock alock(this);
    … …  
    477477
    478478    AutoCaller autoCaller(this);
    479     CheckComRCReturnRC(autoCaller.rc());
     479    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    480480
    481481    AutoReadLock alock(this);
    … …  
    497497
    498498    AutoCaller autoCaller(this);
    499     CheckComRCReturnRC(autoCaller.rc());
     499    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    500500
    501501    /* the machine needs to be mutable */
    502     Machine::AutoMutableStateDependency adep (mParent);
    503     CheckComRCReturnRC(adep.rc());
     502    Machine::AutoMutableStateDependency adep(mParent);
     503    if (FAILED(adep.rc())) return adep.rc();
    504504
    505505    AutoWriteLock alock(this);
    … …  
    531531
    532532    AutoCaller autoCaller(this);
    533     CheckComRCReturnRC(autoCaller.rc());
     533    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    534534
    535535    AutoReadLock alock(this);
    … …  
    551551
    552552    AutoCaller autoCaller(this);
    553     CheckComRCReturnRC(autoCaller.rc());
     553    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    554554
    555555    /* the machine needs to be mutable */
    556     Machine::AutoMutableStateDependency adep (mParent);
    557     CheckComRCReturnRC(adep.rc());
     556    Machine::AutoMutableStateDependency adep(mParent);
     557    if (FAILED(adep.rc())) return adep.rc();
    558558
    559559    AutoWriteLock alock(this);
    … …  
    585585
    586586    AutoCaller autoCaller(this);
    587     CheckComRCReturnRC(autoCaller.rc());
     587    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    588588
    589589    AutoReadLock alock(this);
    … …  
    616616{
    617617    AutoCaller autoCaller(this);
    618     CheckComRCReturnRC(autoCaller.rc());
     618    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    619619
    620620    /* the machine needs to be mutable */
    621     Machine::AutoMutableStateDependency adep (mParent);
    622     CheckComRCReturnRC(adep.rc());
     621    Machine::AutoMutableStateDependency adep(mParent);
     622    if (FAILED(adep.rc())) return adep.rc();
    623623
    624624    AutoWriteLock alock(this);
    … …  
    631631    {
    632632        HRESULT rc = checkSetPath (aPath);
    633         CheckComRCReturnRC(rc);
     633        if (FAILED(rc)) return rc;
    634634
    635635        mData.backup();
    … …  
    650650
    651651    AutoCaller autoCaller(this);
    652     CheckComRCReturnRC(autoCaller.rc());
     652    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    653653
    654654    AutoReadLock alock(this);
    … …  
    662662{
    663663    AutoCaller autoCaller(this);
    664     CheckComRCReturnRC(autoCaller.rc());
     664    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    665665
    666666    /* the machine needs to be mutable */
    667     Machine::AutoMutableStateDependency adep (mParent);
    668     CheckComRCReturnRC(adep.rc());
     667    Machine::AutoMutableStateDependency adep(mParent);
     668    if (FAILED(adep.rc())) return adep.rc();
    669669
    670670    AutoWriteLock alock(this);

  • trunk/src/VBox/Main/SessionImpl.cpp

    r24493 r25149  
    151151
    152152    AutoCaller autoCaller(this);
    153     CheckComRCReturnRC(autoCaller.rc());
     153    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    154154
    155155    AutoReadLock alock(this);
    … …  
    165165
    166166    AutoCaller autoCaller(this);
    167     CheckComRCReturnRC(autoCaller.rc());
     167    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    168168
    169169    AutoReadLock alock(this);
    … …  
    180180
    181181    AutoCaller autoCaller(this);
    182     CheckComRCReturnRC(autoCaller.rc());
     182    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    183183
    184184    AutoReadLock alock(this);
    … …  
    202202
    203203    AutoCaller autoCaller(this);
    204     CheckComRCReturnRC(autoCaller.rc());
     204    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    205205
    206206    AutoReadLock alock(this);
    … …  
    227227
    228228    AutoCaller autoCaller(this);
    229     CheckComRCReturnRC(autoCaller.rc());
     229    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    230230
    231231    /* close() needs write lock */
    … …  
    333333
    334334    if (SUCCEEDED(rc))
    335     {       
     335    {
    336336        mType = SessionType_Direct;
    337337        mState = SessionState_Open;

  • trunk/src/VBox/Main/SharedFolderImpl.cpp

    r23257 r25149  
    262262
    263263    AutoCaller autoCaller(this);
    264     CheckComRCReturnRC(autoCaller.rc());
     264    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    265265
    266266    /* mName is constant during life time, no need to lock */
    … …  
    275275
    276276    AutoCaller autoCaller(this);
    277     CheckComRCReturnRC(autoCaller.rc());
     277    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    278278
    279279    /* mHostPath is constant during life time, no need to lock */
    … …  
    288288
    289289    AutoCaller autoCaller(this);
    290     CheckComRCReturnRC(autoCaller.rc());
     290    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    291291
    292292    /* mName and mHostPath are constant during life time, no need to lock */
    … …  
    330330
    331331    AutoCaller autoCaller(this);
    332     CheckComRCReturnRC(autoCaller.rc());
     332    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    333333
    334334    AutoReadLock alock(this);

  • trunk/src/VBox/Main/SnapshotImpl.cpp

    r24992 r25149  
    288288
    289289    AutoCaller autoCaller(this);
    290     CheckComRCReturnRC(autoCaller.rc());
     290    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    291291
    292292    AutoReadLock alock(this);
    … …  
    301301
    302302    AutoCaller autoCaller(this);
    303     CheckComRCReturnRC(autoCaller.rc());
     303    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    304304
    305305    AutoReadLock alock(this);
    … …  
    318318
    319319    AutoCaller autoCaller(this);
    320     CheckComRCReturnRC(autoCaller.rc());
     320    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    321321
    322322    Utf8Str strName(aName);
    … …  
    341341
    342342    AutoCaller autoCaller(this);
    343     CheckComRCReturnRC(autoCaller.rc());
     343    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    344344
    345345    AutoReadLock alock(this);
    … …  
    354354
    355355    AutoCaller autoCaller(this);
    356     CheckComRCReturnRC(autoCaller.rc());
     356    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    357357
    358358    Utf8Str strDescription(aDescription);
    … …  
    377377
    378378    AutoCaller autoCaller(this);
    379     CheckComRCReturnRC(autoCaller.rc());
     379    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    380380
    381381    AutoReadLock alock(this);
    … …  
    390390
    391391    AutoCaller autoCaller(this);
    392     CheckComRCReturnRC(autoCaller.rc());
     392    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    393393
    394394    AutoReadLock alock(this);
    … …  
    403403
    404404    AutoCaller autoCaller(this);
    405     CheckComRCReturnRC(autoCaller.rc());
     405    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    406406
    407407    AutoReadLock alock(this);
    … …  
    416416
    417417    AutoCaller autoCaller(this);
    418     CheckComRCReturnRC(autoCaller.rc());
     418    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    419419
    420420    AutoReadLock alock(this);
    … …  
    429429
    430430    AutoCaller autoCaller(this);
    431     CheckComRCReturnRC(autoCaller.rc());
     431    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    432432
    433433    AutoReadLock alock(m->pMachine->snapshotsTreeLockHandle());
    … …  
    691691
    692692    HRESULT rc = m->pMachine->saveHardware(data.hardware);
    693     CheckComRCReturnRC (rc);
     693    if (FAILED(rc)) return rc;
    694694
    695695    rc = m->pMachine->saveStorageControllers(data.storage);
    696     CheckComRCReturnRC (rc);
     696    if (FAILED(rc)) return rc;
    697697
    698698    alock.unlock();
    … …  
    708708            settings::Snapshot snap;
    709709            rc = (*it)->saveSnapshotImpl(snap, aAttrsOnly);
    710             CheckComRCReturnRC (rc);
     710            if (FAILED(rc)) return rc;
    711711
    712712            data.llChildSnapshots.push_back(snap);
    … …  
    814814        folder.createObject();
    815815        rc = folder->initCopy (this, *it);
    816         CheckComRCReturnRC(rc);
     816        if (FAILED(rc)) return rc;
    817817        *it = folder;
    818818    }
    … …  
    12191219         * hard disks are fixed up */
    12201220        HRESULT rc = saveSettings();
    1221         CheckComRCReturnRC(rc);
     1221        if (FAILED(rc)) return rc;
    12221222    }
    12231223
    … …  
    12371237        /* ensure the directory for the saved state file exists */
    12381238        HRESULT rc = VirtualBox::ensureFilePathExists(strStateFilePath);
    1239         CheckComRCReturnRC(rc);
     1239        if (FAILED(rc)) return rc;
    12401240    }
    12411241
    … …  
    16711671            aTask.modifyBackedUpState(MachineState_PoweredOff);
    16721672            rc = saveStateSettings(SaveSTS_StateFilePath);
    1673             CheckComRCThrowRC(rc);
     1673            if (FAILED(rc)) throw rc;
    16741674        }
    16751675
    … …  
    17021702                                     1,
    17031703                                     false /* aOnline */);
     1704            if (FAILED(rc)) throw rc;
    17041705
    17051706            alock.enter();
    17061707            snapshotLock.lock();
    1707 
    1708             CheckComRCThrowRC(rc);
    17091708
    17101709            /* Note: on success, current (old) hard disks will be
    … …  
    18441843        // save all settings, reset the modified flag and commit;
    18451844        rc = saveSettings(SaveS_ResetCurStateModified | saveFlags);
    1846         CheckComRCThrowRC(rc);
     1845        if (FAILED(rc)) throw rc;
     1846
    18471847        // from here on we cannot roll back on failure any more
    18481848
    … …  
    19371937    ComObjPtr<Snapshot> pSnapshot;
    19381938    HRESULT rc = findSnapshot(id, pSnapshot, true /* aSetError */);
    1939     CheckComRCReturnRC(rc);
     1939    if (FAILED(rc)) return rc;
    19401940
    19411941    AutoWriteLock snapshotLock(pSnapshot);
    … …  
    19571957        {
    19581958            rc = saveSettings();
    1959             CheckComRCReturnRC(rc);
     1959            if (FAILED(rc)) return rc;
    19601960        }
    19611961    }
    … …  
    21522152                // needs to be discarded (merged with the child if any), check prerequisites
    21532153                rc = pHD->prepareDiscard(chain);
    2154                 CheckComRCThrowRC(rc);
     2154                if (FAILED(rc)) throw rc;
    21552155
    21562156                // for simplicity, we merge pHd onto its child (forward merge), not the
    … …  
    22562256
    22572257            rc = saveAllSnapshots();
    2258             CheckComRCThrowRC(rc);
     2258            if (FAILED(rc)) throw rc;
    22592259
    22602260            /// @todo (dmik)
    … …  
    23002300                                 (ULONG)(it->hd->getSize() / _1M),          // weight
    23012301                                 it->chain);
    2302             CheckComRCBreakRC(rc);
     2302            if (FAILED(rc)) throw rc;
    23032303
    23042304            /* prevent from calling cancelDiscard() */
    … …  
    23092309        alock.enter();
    23102310        LogFlowThisFunc(("Entered locks OK\n"));
    2311 
    2312         CheckComRCThrowRC(rc);
    23132311    }
    23142312    catch (HRESULT aRC) { rc = aRC; }

  • trunk/src/VBox/Main/StorageControllerImpl.cpp

    r24250 r25149  
    244244
    245245    AutoCaller autoCaller(this);
    246     CheckComRCReturnRC(autoCaller.rc());
     246    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    247247
    248248    /* mName is constant during life time, no need to lock */
    … …  
    257257
    258258    AutoCaller autoCaller(this);
    259     CheckComRCReturnRC(autoCaller.rc());
     259    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    260260
    261261    AutoReadLock alock(this);
    … …  
    271271
    272272    AutoCaller autoCaller(this);
    273     CheckComRCReturnRC(autoCaller.rc());
     273    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    274274
    275275    AutoReadLock alock(this);
    … …  
    283283{
    284284    AutoCaller autoCaller(this);
    285     CheckComRCReturnRC(autoCaller.rc());
     285    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    286286
    287287    AutoWriteLock alock(this);
    … …  
    337337
    338338    AutoCaller autoCaller(this);
    339     CheckComRCReturnRC(autoCaller.rc());
     339    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    340340
    341341    AutoReadLock alock(this);
    … …  
    360360
    361361    AutoCaller autoCaller(this);
    362     CheckComRCReturnRC(autoCaller.rc());
     362    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    363363
    364364    AutoReadLock alock(this);
    … …  
    383383
    384384    AutoCaller autoCaller(this);
    385     CheckComRCReturnRC(autoCaller.rc());
     385    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    386386
    387387    AutoReadLock alock(this);
    … …  
    407407
    408408    AutoCaller autoCaller(this);
    409     CheckComRCReturnRC(autoCaller.rc());
     409    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    410410
    411411    AutoReadLock alock(this);
    … …  
    474474
    475475    AutoCaller autoCaller(this);
    476     CheckComRCReturnRC(autoCaller.rc());
     476    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    477477
    478478    /* the machine needs to be mutable */
    479     Machine::AutoMutableStateDependency adep (mParent);
    480     CheckComRCReturnRC(adep.rc());
     479    Machine::AutoMutableStateDependency adep(mParent);
     480    if (FAILED(adep.rc())) return adep.rc();
    481481
    482482    AutoWriteLock alock(this);
    … …  
    499499{
    500500    AutoCaller autoCaller(this);
    501     CheckComRCReturnRC(autoCaller.rc());
     501    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    502502
    503503    /* The machine doesn't need to be mutable. */
    … …  
    513513{
    514514    AutoCaller autoCaller(this);
    515     CheckComRCReturnRC(autoCaller.rc());
     515    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    516516
    517517    /* The machine doesn't need to be mutable. */
    … …  
    532532
    533533    AutoCaller autoCaller(this);
    534     CheckComRCReturnRC(autoCaller.rc());
     534    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    535535
    536536    AutoReadLock alock(this);
    … …  
    564564{
    565565    AutoCaller autoCaller(this);
    566     CheckComRCReturnRC(autoCaller.rc());
     566    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    567567
    568568    /* the machine needs to be mutable */
    569     Machine::AutoMutableStateDependency adep (mParent);
    570     CheckComRCReturnRC(adep.rc());
     569    Machine::AutoMutableStateDependency adep(mParent);
     570    if (FAILED(adep.rc())) return adep.rc();
    571571    AutoWriteLock alock(this);
    572572

  • trunk/src/VBox/Main/SystemPropertiesImpl.cpp

    r24438 r25149  
    106106            ComObjPtr<MediumFormat> hdf;
    107107            rc = hdf.createObject();
    108             CheckComRCBreakRC (rc);
     108            if (FAILED(rc)) break;
    109109
    110110            rc = hdf->init (&aVDInfo [i]);
    111             CheckComRCBreakRC (rc);
     111            if (FAILED(rc)) break;
    112112
    113113            mMediumFormats.push_back (hdf);
    … …  
    182182
    183183    AutoCaller autoCaller(this);
    184     CheckComRCReturnRC(autoCaller.rc());
     184    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    185185
    186186    /* no need to lock, this is const */
    … …  
    197197
    198198    AutoCaller autoCaller(this);
    199     CheckComRCReturnRC(autoCaller.rc());
     199    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    200200
    201201    /* no need to lock, this is const */
    … …  
    221221
    222222    AutoCaller autoCaller(this);
    223     CheckComRCReturnRC(autoCaller.rc());
     223    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    224224
    225225    /* no need to lock, this is const */
    … …  
    235235
    236236    AutoCaller autoCaller(this);
    237     CheckComRCReturnRC(autoCaller.rc());
     237    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    238238
    239239    /* no need to lock, this is const */
    … …  
    249249
    250250    AutoCaller autoCaller(this);
    251     CheckComRCReturnRC(autoCaller.rc());
     251    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    252252
    253253    /* no need to lock, this is const */
    … …  
    263263
    264264    AutoCaller autoCaller(this);
    265     CheckComRCReturnRC(autoCaller.rc());
     265    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    266266
    267267    /* no need to lock, this is const */
    … …  
    277277
    278278    AutoCaller autoCaller(this);
    279     CheckComRCReturnRC(autoCaller.rc());
     279    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    280280
    281281    /* no need to lock, this is const */
    … …  
    291291
    292292    AutoCaller autoCaller(this);
    293     CheckComRCReturnRC(autoCaller.rc());
     293    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    294294
    295295    /** The BIOS supports currently 32 bit LBA numbers (implementing the full
    … …  
    314314
    315315    AutoCaller autoCaller(this);
    316     CheckComRCReturnRC(autoCaller.rc());
     316    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    317317
    318318    /* no need to lock, this is const */
    … …  
    328328
    329329    AutoCaller autoCaller(this);
    330     CheckComRCReturnRC(autoCaller.rc());
     330    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    331331
    332332    /* no need to lock, this is const */
    … …  
    342342
    343343    AutoCaller autoCaller(this);
    344     CheckComRCReturnRC(autoCaller.rc());
     344    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    345345
    346346    /* no need to lock, this is const */
    … …  
    355355
    356356    AutoCaller autoCaller(this);
    357     CheckComRCReturnRC(autoCaller.rc());
     357    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    358358
    359359    /* no need to lock, this is const */
    … …  
    368368
    369369    AutoCaller autoCaller(this);
    370     CheckComRCReturnRC(autoCaller.rc());
     370    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    371371
    372372    /* no need to lock, this is const */
    … …  
    400400
    401401    AutoCaller autoCaller(this);
    402     CheckComRCReturnRC(autoCaller.rc());
     402    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    403403
    404404    /* no need to lock, this is const */
    … …  
    437437
    438438    AutoCaller autoCaller(this);
    439     CheckComRCReturnRC(autoCaller.rc());
     439    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    440440
    441441    /* no need to lock, this is const */
    … …  
    474474
    475475    AutoCaller autoCaller(this);
    476     CheckComRCReturnRC(autoCaller.rc());
     476    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    477477
    478478    /* no need to lock, this is const */
    … …  
    501501
    502502    AutoCaller autoCaller(this);
    503     CheckComRCReturnRC(autoCaller.rc());
     503    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    504504
    505505    /* no need to lock, this is const */
    … …  
    541541
    542542    AutoCaller autoCaller(this);
    543     CheckComRCReturnRC(autoCaller.rc());
     543    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    544544
    545545    AutoReadLock alock(this);
    … …  
    553553{
    554554    AutoCaller autoCaller(this);
    555     CheckComRCReturnRC(autoCaller.rc());
     555    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    556556
    557557    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    570570
    571571    AutoCaller autoCaller(this);
    572     CheckComRCReturnRC(autoCaller.rc());
     572    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    573573
    574574    AutoReadLock alock(this);
    … …  
    582582{
    583583    AutoCaller autoCaller(this);
    584     CheckComRCReturnRC(autoCaller.rc());
     584    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    585585
    586586    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    601601
    602602    AutoCaller autoCaller(this);
    603     CheckComRCReturnRC(autoCaller.rc());
     603    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    604604
    605605    AutoReadLock alock(this);
    … …  
    616616
    617617    AutoCaller autoCaller(this);
    618     CheckComRCReturnRC(autoCaller.rc());
     618    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    619619
    620620    AutoReadLock alock(this);
    … …  
    628628{
    629629    AutoCaller autoCaller(this);
    630     CheckComRCReturnRC(autoCaller.rc());
     630    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    631631
    632632    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    645645
    646646    AutoCaller autoCaller(this);
    647     CheckComRCReturnRC(autoCaller.rc());
     647    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    648648
    649649    AutoReadLock alock(this);
    … …  
    657657{
    658658    AutoCaller autoCaller(this);
    659     CheckComRCReturnRC(autoCaller.rc());
     659    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    660660
    661661    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    674674
    675675    AutoCaller autoCaller(this);
    676     CheckComRCReturnRC(autoCaller.rc());
     676    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    677677
    678678    AutoReadLock alock(this);
    … …  
    686686{
    687687    AutoCaller autoCaller(this);
    688     CheckComRCReturnRC(autoCaller.rc());
     688    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    689689
    690690    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    704704
    705705    AutoCaller autoCaller(this);
    706     CheckComRCReturnRC(autoCaller.rc());
     706    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    707707
    708708    AutoReadLock alock(this);
    … …  
    716716{
    717717    AutoCaller autoCaller(this);
    718     CheckComRCReturnRC(autoCaller.rc());
     718    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    719719
    720720    /* VirtualBox::saveSettings() needs a write lock */
    … …  
    734734
    735735    AutoCaller autoCaller(this);
    736     CheckComRCReturnRC(autoCaller.rc());
     736    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    737737
    738738    AutoReadLock alock(this);
    … …  
    749749{
    750750    AutoCaller autoCaller(this);
    751     CheckComRCReturnRC(autoCaller.rc());
     751    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    752752
    753753    AutoWriteLock alock(this);
    … …  
    756756
    757757    rc = setDefaultMachineFolder(data.strDefaultMachineFolder);
    758     CheckComRCReturnRC(rc);
     758    if (FAILED(rc)) return rc;
    759759
    760760    rc = setDefaultHardDiskFolder(data.strDefaultHardDiskFolder);
    761     CheckComRCReturnRC(rc);
     761    if (FAILED(rc)) return rc;
    762762
    763763    rc = setDefaultHardDiskFormat(data.strDefaultHardDiskFormat);
    764     CheckComRCReturnRC(rc);
     764    if (FAILED(rc)) return rc;
    765765
    766766    rc = setRemoteDisplayAuthLibrary(data.strRemoteDisplayAuthLibrary);
    767     CheckComRCReturnRC(rc);
     767    if (FAILED(rc)) return rc;
    768768
    769769    rc = setWebServiceAuthLibrary(data.strWebServiceAuthLibrary);
    770     CheckComRCReturnRC(rc);
     770    if (FAILED(rc)) return rc;
    771771
    772772    mLogHistoryCount = data.ulLogHistoryCount;
    … …  
    778778{
    779779    AutoCaller autoCaller(this);
    780     CheckComRCReturnRC(autoCaller.rc());
     780    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    781781
    782782    AutoReadLock alock(this);

  • trunk/src/VBox/Main/USBControllerImpl.cpp

    r24989 r25149  
    217217
    218218    AutoCaller autoCaller(this);
    219     CheckComRCReturnRC(autoCaller.rc());
     219    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    220220
    221221    AutoReadLock alock(this);
    … …  
    232232
    233233    AutoCaller autoCaller(this);
    234     CheckComRCReturnRC(autoCaller.rc());
     234    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    235235
    236236    /* the machine needs to be mutable */
    237     Machine::AutoMutableStateDependency adep (mParent);
    238     CheckComRCReturnRC(adep.rc());
     237    Machine::AutoMutableStateDependency adep(mParent);
     238    if (FAILED(adep.rc())) return adep.rc();
    239239
    240240    AutoWriteLock alock(this);
    … …  
    259259
    260260    AutoCaller autoCaller(this);
    261     CheckComRCReturnRC(autoCaller.rc());
     261    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    262262
    263263    AutoReadLock alock(this);
    … …  
    273273
    274274    AutoCaller autoCaller(this);
    275     CheckComRCReturnRC(autoCaller.rc());
     275    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    276276
    277277    /* the machine needs to be mutable */
    278     Machine::AutoMutableStateDependency adep (mParent);
    279     CheckComRCReturnRC(adep.rc());
     278    Machine::AutoMutableStateDependency adep(mParent);
     279    if (FAILED(adep.rc())) return adep.rc();
    280280
    281281    AutoWriteLock alock(this);
    … …  
    300300
    301301    AutoCaller autoCaller(this);
    302     CheckComRCReturnRC(autoCaller.rc());
     302    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    303303
    304304    /* not accessing data -- no need to lock */
    … …  
    364364
    365365    AutoCaller autoCaller(this);
    366     CheckComRCReturnRC(autoCaller.rc());
     366    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    367367
    368368    AutoReadLock alock(this);
    … …  
    393393
    394394    AutoCaller autoCaller(this);
    395     CheckComRCReturnRC(autoCaller.rc());
     395    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    396396
    397397    /* the machine needs to be mutable */
    398     Machine::AutoMutableStateDependency adep (mParent);
    399     CheckComRCReturnRC(adep.rc());
     398    Machine::AutoMutableStateDependency adep(mParent);
     399    if (FAILED(adep.rc())) return adep.rc();
    400400
    401401    AutoWriteLock alock(this);
    … …  
    424424
    425425    AutoCaller autoCaller(this);
    426     CheckComRCReturnRC(autoCaller.rc());
     426    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    427427
    428428    /* the machine needs to be mutable */
    429     Machine::AutoMutableStateDependency adep (mParent);
    430     CheckComRCReturnRC(adep.rc());
     429    Machine::AutoMutableStateDependency adep(mParent);
     430    if (FAILED(adep.rc())) return adep.rc();
    431431
    432432    AutoWriteLock alock(this);
    … …  
    487487
    488488    AutoCaller autoCaller(this);
    489     CheckComRCReturnRC(autoCaller.rc());
     489    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    490490
    491491    /* the machine needs to be mutable */
    492     Machine::AutoMutableStateDependency adep (mParent);
    493     CheckComRCReturnRC(adep.rc());
     492    Machine::AutoMutableStateDependency adep(mParent);
     493    if (FAILED(adep.rc())) return adep.rc();
    494494
    495495    AutoWriteLock alock(this);
    … …  
    588588        HRESULT rc = pFilter->init(this,        // parent
    589589                                   f);
    590         CheckComRCReturnRC(rc);
     590        if (FAILED(rc)) return rc;
    591591
    592592        mDeviceFilters->push_back(pFilter);
    … …  
    608608{
    609609    AutoCaller autoCaller(this);
    610     CheckComRCReturnRC(autoCaller.rc());
     610    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    611611
    612612    AutoReadLock alock(this);

  • trunk/src/VBox/Main/USBDeviceImpl.cpp

    r24989 r25149  
    150150
    151151    AutoCaller autoCaller(this);
    152     CheckComRCReturnRC(autoCaller.rc());
     152    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    153153
    154154    /* this is const, no need to lock */
    … …  
    170170
    171171    AutoCaller autoCaller(this);
    172     CheckComRCReturnRC(autoCaller.rc());
     172    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    173173
    174174    /* this is const, no need to lock */
    … …  
    190190
    191191    AutoCaller autoCaller(this);
    192     CheckComRCReturnRC(autoCaller.rc());
     192    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    193193
    194194    /* this is const, no need to lock */
    … …  
    210210
    211211    AutoCaller autoCaller(this);
    212     CheckComRCReturnRC(autoCaller.rc());
     212    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    213213
    214214    /* this is const, no need to lock */
    … …  
    229229
    230230    AutoCaller autoCaller(this);
    231     CheckComRCReturnRC(autoCaller.rc());
     231    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    232232
    233233    /* this is const, no need to lock */
    … …  
    249249
    250250    AutoCaller autoCaller(this);
    251     CheckComRCReturnRC(autoCaller.rc());
     251    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    252252
    253253    /* this is const, no need to lock */
    … …  
    269269
    270270    AutoCaller autoCaller(this);
    271     CheckComRCReturnRC(autoCaller.rc());
     271    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    272272
    273273    /* this is const, no need to lock */
    … …  
    289289
    290290    AutoCaller autoCaller(this);
    291     CheckComRCReturnRC(autoCaller.rc());
     291    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    292292
    293293    /* this is const, no need to lock */
    … …  
    302302
    303303    AutoCaller autoCaller(this);
    304     CheckComRCReturnRC(autoCaller.rc());
     304    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    305305
    306306    /* this is const, no need to lock */
    … …  
    315315
    316316    AutoCaller autoCaller(this);
    317     CheckComRCReturnRC(autoCaller.rc());
     317    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    318318
    319319    /* this is const, no need to lock */
    … …  
    328328
    329329    AutoCaller autoCaller(this);
    330     CheckComRCReturnRC(autoCaller.rc());
     330    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    331331
    332332    /* this is const, no need to lock */
    … …  
    341341
    342342    AutoCaller autoCaller(this);
    343     CheckComRCReturnRC(autoCaller.rc());
     343    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    344344
    345345    /* this is const, no need to lock */

  • trunk/src/VBox/Main/VFSExplorerImpl.cpp

    r23327 r25149  
    128128
    129129    AutoCaller autoCaller(this);
    130     CheckComRCReturnRC(autoCaller.rc());
     130    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    131131
    132132    AutoReadLock alock(this);
    … …  
    144144
    145145    AutoCaller autoCaller(this);
    146     CheckComRCReturnRC(autoCaller.rc());
     146    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    147147
    148148    AutoReadLock alock(this);
    … …  
    274274
    275275    AutoCaller autoCaller(this);
    276     CheckComRCReturnRC(autoCaller.rc());
     276    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    277277
    278278    AutoWriteLock appLock(this);
    … …  
    342342
    343343    AutoCaller autoCaller(this);
    344     CheckComRCReturnRC(autoCaller.rc());
     344    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    345345
    346346    AutoWriteLock appLock(this);
    … …  
    389389
    390390    AutoCaller autoCaller(this);
    391     CheckComRCReturnRC(autoCaller.rc());
     391    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    392392
    393393    AutoWriteLock appLock(this);
    … …  
    465465
    466466    AutoCaller autoCaller(this);
    467     CheckComRCReturnRC(autoCaller.rc());
     467    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    468468
    469469    AutoWriteLock appLock(this);
    … …  
    518518
    519519    AutoCaller autoCaller(this);
    520     CheckComRCReturnRC(autoCaller.rc());
     520    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    521521
    522522    AutoReadLock(this);
    … …  
    580580
    581581    AutoCaller autoCaller(this);
    582     CheckComRCReturnRC(autoCaller.rc());
     582    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    583583
    584584    AutoReadLock alock(this);
    … …  
    610610
    611611    AutoCaller autoCaller(this);
    612     CheckComRCReturnRC(autoCaller.rc());
     612    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    613613
    614614    AutoReadLock alock(this);
    … …  
    647647
    648648    AutoCaller autoCaller(this);
    649     CheckComRCReturnRC(autoCaller.rc());
     649    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    650650
    651651    AutoReadLock(this);

  • trunk/src/VBox/Main/VirtualBoxBase.cpp

    r23279 r25149  
    803803        ComObjPtr<VirtualBoxErrorInfo> info;
    804804        rc = info.createObject();
    805         CheckComRCBreakRC (rc);
     805        if (FAILED(rc)) break;
    806806
    807807#if !defined (VBOX_WITH_XPCOM)
    … …  
    813813            ComPtr<IErrorInfo> err;
    814814            rc = ::GetErrorInfo (0, err.asOutParam());
    815             CheckComRCBreakRC (rc);
     815            if (FAILED(rc)) break;
    816816            rc = err.queryInterfaceTo(curInfo.asOutParam());
    817817            if (FAILED (rc))
    … …  
    834834        /* set the current error info and preserve the previous one if any */
    835835        rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
    836         CheckComRCBreakRC (rc);
     836        if (FAILED(rc)) break;
    837837
    838838        ComPtr<IErrorInfo> err;
    … …  
    849849            nsCOMPtr <nsIExceptionManager> em;
    850850            rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
    851             CheckComRCBreakRC (rc);
     851            if (FAILED(rc)) break;
    852852
    853853            ComPtr<IVirtualBoxErrorInfo> curInfo;
    … …  
    857857                ComPtr<nsIException> ex;
    858858                rc = em->GetCurrentException (ex.asOutParam());
    859                 CheckComRCBreakRC (rc);
     859                if (FAILED(rc)) break;
    860860                rc = ex.queryInterfaceTo(curInfo.asOutParam());
    861                 if (FAILED (rc))
     861                if (FAILED(rc))
    862862                {
    863863                    /* create a IVirtualBoxErrorInfo wrapper for the native
    … …  
    878878            /* set the current error info and preserve the previous one if any */
    879879            rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
    880             CheckComRCBreakRC (rc);
     880            if (FAILED(rc)) break;
    881881
    882882            ComPtr<nsIException> ex;

  • trunk/src/VBox/Main/VirtualBoxErrorInfoImpl.cpp

    r21878 r25149  
    228228    ComPtr<IVirtualBoxErrorInfo> info;
    229229    nsresult rv = COMGETTER(Next) (info.asOutParam());
    230     CheckComRCReturnRC(rv);
     230    if (FAILED(rv)) return rv;
    231231    return info.queryInterfaceTo(aInner);
    232232}

  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r24989 r25149  
    347347
    348348        rc = m->pHost->loadSettings(m->pMainConfigFile->host);
    349         CheckComRCThrowRC(rc);
     349        if (FAILED(rc)) throw rc;
    350350
    351351        /* create the system properties object, someone may need it too */
    … …  
    355355
    356356        rc = m->pSystemProperties->loadSettings(m->pMainConfigFile->systemProperties);
    357         CheckComRCThrowRC(rc);
     357        if (FAILED(rc)) throw rc;
    358358
    359359        /* guest OS type objects, needed by machines */
    … …  
    405405            if (SUCCEEDED(rc = pDhcpServer.createObject()))
    406406                rc = pDhcpServer->init(this, data);
    407             CheckComRCThrowRC(rc);
     407            if (FAILED(rc)) throw rc;
    408408
    409409            rc = registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);
    410             CheckComRCThrowRC(rc);
     410            if (FAILED(rc)) throw rc;
    411411        }
    412412    }
    … …  
    519519                                 DeviceType_HardDisk,
    520520                                 xmlHD);         // XML data; this recurses to processes the children
    521         CheckComRCReturnRC(rc);
     521        if (FAILED(rc)) return rc;
    522522
    523523        rc = registerHardDisk(pHardDisk, false /* aSaveRegistry */);
    524         CheckComRCReturnRC(rc);
     524        if (FAILED(rc)) return rc;
    525525    }
    526526
    … …  
    534534        if (SUCCEEDED(pImage.createObject()))
    535535            rc = pImage->init(this, NULL, DeviceType_DVD, xmlDvd);
    536         CheckComRCReturnRC(rc);
     536        if (FAILED(rc)) return rc;
    537537
    538538        rc = registerDVDImage(pImage, false /* aSaveRegistry */);
    539         CheckComRCReturnRC(rc);
     539        if (FAILED(rc)) return rc;
    540540    }
    541541
    … …  
    549549        if (SUCCEEDED(pImage.createObject()))
    550550            rc = pImage->init(this, NULL, DeviceType_Floppy, xmlFloppy);
    551         CheckComRCReturnRC(rc);
     551        if (FAILED(rc)) return rc;
    552552
    553553        rc = registerFloppyImage(pImage, false /* aSaveRegistry */);
    554         CheckComRCReturnRC(rc);
     554        if (FAILED(rc)) return rc;
    555555    }
    556556
    … …  
    705705
    706706    AutoCaller autoCaller(this);
    707     CheckComRCReturnRC(autoCaller.rc());
     707    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    708708
    709709    sVersion.cloneTo(aVersion);
    … …  
    716716
    717717    AutoCaller autoCaller(this);
    718     CheckComRCReturnRC(autoCaller.rc());
     718    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    719719
    720720    *aRevision = sRevision;
    … …  
    727727
    728728    AutoCaller autoCaller(this);
    729     CheckComRCReturnRC(autoCaller.rc());
     729    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    730730
    731731    sPackageType.cloneTo(aPackageType);
    … …  
    738738
    739739    AutoCaller autoCaller(this);
    740     CheckComRCReturnRC(autoCaller.rc());
     740    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    741741
    742742    /* mHomeDir is const and doesn't need a lock */
    … …  
    750750
    751751    AutoCaller autoCaller(this);
    752     CheckComRCReturnRC(autoCaller.rc());
     752    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    753753
    754754    /* mCfgFile.mName is const and doesn't need a lock */
    … …  
    762762
    763763    AutoCaller autoCaller(this);
    764     CheckComRCReturnRC(autoCaller.rc());
     764    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    765765
    766766    /* mHost is const, no need to lock */
    … …  
    775775
    776776    AutoCaller autoCaller(this);
    777     CheckComRCReturnRC(autoCaller.rc());
     777    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    778778
    779779    /* mSystemProperties is const, no need to lock */
    … …  
    789789
    790790    AutoCaller autoCaller(this);
    791     CheckComRCReturnRC(autoCaller.rc());
     791    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    792792
    793793    AutoReadLock alock(this);
    … …  
    805805
    806806    AutoCaller autoCaller(this);
    807     CheckComRCReturnRC(autoCaller.rc());
     807    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    808808
    809809    AutoReadLock alock(this);
    … …  
    822822
    823823    AutoCaller autoCaller(this);
    824     CheckComRCReturnRC(autoCaller.rc());
     824    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    825825
    826826    AutoReadLock alock(this);
    … …  
    839839
    840840    AutoCaller autoCaller(this);
    841     CheckComRCReturnRC(autoCaller.rc());
     841    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    842842
    843843    AutoReadLock alock(this);
    … …  
    854854
    855855    AutoCaller autoCaller(this);
    856     CheckComRCReturnRC(autoCaller.rc());
     856    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    857857
    858858    /* protect mProgressOperations */
    … …  
    870870
    871871    AutoCaller autoCaller(this);
    872     CheckComRCReturnRC(autoCaller.rc());
     872    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    873873
    874874    AutoReadLock alock(this);
    … …  
    890890
    891891    AutoCaller autoCaller(this);
    892     CheckComRCReturnRC(autoCaller.rc());
     892    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    893893
    894894    return setError (E_NOTIMPL, "Not yet implemented");
    … …  
    902902
    903903    AutoCaller autoCaller(this);
    904     CheckComRCReturnRC(autoCaller.rc());
     904    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    905905
    906906    /* mPerformanceCollector is const, no need to lock */
    … …  
    920920
    921921    AutoCaller autoCaller(this);
    922     CheckComRCReturnRC(autoCaller.rc());
     922    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    923923
    924924    AutoReadLock alock(this);
    … …  
    940940
    941941    AutoCaller autoCaller(this);
    942     CheckComRCReturnRC(autoCaller.rc());
     942    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    943943
    944944    const char * url = NULL;
    … …  
    10381038
    10391039    AutoCaller autoCaller(this);
    1040     CheckComRCReturnRC(autoCaller.rc());
     1040    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    10411041
    10421042    /* Compose the settings file name using the following scheme:
    … …  
    10641064    ComObjPtr<Machine> machine;
    10651065    rc = machine.createObject();
    1066     CheckComRCReturnRC(rc);
     1066    if (FAILED(rc)) return rc;
    10671067
    10681068    /* Create UUID if an empty one was specified. */
    … …  
    10731073    GuestOSType *osType;
    10741074    rc = findGuestOSType(aOsTypeId, osType);
    1075     CheckComRCReturnRC(rc);
     1075    if (FAILED(rc)) return rc;
    10761076
    10771077    /* initialize the machine object */
    … …  
    11071107
    11081108    AutoCaller autoCaller(this);
    1109     CheckComRCReturnRC(autoCaller.rc());
     1109    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11101110
    11111111    HRESULT rc = E_FAIL;
    … …  
    11191119    ComObjPtr<Machine> machine;
    11201120    rc = machine.createObject();
    1121     CheckComRCReturnRC(rc);
     1121    if (FAILED(rc)) return rc;
    11221122
    11231123    /* Create UUID if an empty one was specified. */
    … …  
    11281128    GuestOSType *osType;
    11291129    rc = findGuestOSType(aOsTypeId, osType);
    1130     CheckComRCReturnRC(rc);
     1130    if (FAILED(rc)) return rc;
    11311131
    11321132    /* initialize the machine object */
    … …  
    11551155
    11561156    AutoCaller autoCaller(this);
    1157     CheckComRCReturnRC(autoCaller.rc());
     1157    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11581158
    11591159    HRESULT rc = E_FAIL;
    … …  
    11851185
    11861186    AutoCaller autoCaller(this);
    1187     CheckComRCReturnRC(autoCaller.rc());
     1187    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    11881188
    11891189    HRESULT rc;
    … …  
    11911191    Bstr name;
    11921192    rc = aMachine->COMGETTER(Name) (name.asOutParam());
    1193     CheckComRCReturnRC(rc);
     1193    if (FAILED(rc)) return rc;
    11941194
    11951195    /* We need the children map lock here to keep the getDependentChild() result
    … …  
    12271227
    12281228    AutoCaller autoCaller(this);
    1229     CheckComRCReturnRC(autoCaller.rc());
     1229    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12301230
    12311231    ComObjPtr<Machine> machine;
    … …  
    12481248
    12491249    AutoCaller autoCaller(this);
    1250     CheckComRCReturnRC(autoCaller.rc());
     1250    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    12511251
    12521252    /* start with not found */
    … …  
    12991299
    13001300    AutoCaller autoCaller(this);
    1301     CheckComRCReturnRC(autoCaller.rc());
     1301    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13021302
    13031303    AutoWriteLock alock(this);
    … …  
    13061306
    13071307    HRESULT rc = findMachine (id, true /* setError */, &machine);
    1308     CheckComRCReturnRC(rc);
     1308    if (FAILED(rc)) return rc;
    13091309
    13101310    rc = machine->trySetRegistered (FALSE);
    1311     CheckComRCReturnRC(rc);
     1311    if (FAILED(rc)) return rc;
    13121312
    13131313    /* remove from the collection of registered machines */
    … …  
    13331333
    13341334    AutoCaller autoCaller(this);
    1335     CheckComRCReturnRC(autoCaller.rc());
     1335    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13361336
    13371337    /* we don't access non-const data members so no need to lock */
    … …  
    13651365
    13661366    AutoCaller autoCaller(this);
    1367     CheckComRCReturnRC(autoCaller.rc());
     1367    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    13681368
    13691369    /* we don't access non-const data members so no need to lock */
    … …  
    14121412
    14131413    AutoCaller autoCaller(this);
    1414     CheckComRCReturnRC(autoCaller.rc());
     1414    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14151415
    14161416    Guid id(aId);
    … …  
    14311431
    14321432    AutoCaller autoCaller(this);
    1433     CheckComRCReturnRC(autoCaller.rc());
     1433    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14341434
    14351435    ComObjPtr<Medium> hardDisk;
    … …  
    14501450
    14511451    AutoCaller autoCaller(this);
    1452     CheckComRCReturnRC(autoCaller.rc());
     1452    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14531453
    14541454    HRESULT rc = VBOX_E_FILE_ERROR;
    … …  
    14791479
    14801480    AutoCaller autoCaller(this);
    1481     CheckComRCReturnRC(autoCaller.rc());
     1481    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    14821482
    14831483    Guid id(aId);
    … …  
    14981498
    14991499    AutoCaller autoCaller(this);
    1500     CheckComRCReturnRC(autoCaller.rc());
     1500    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15011501
    15021502    ComObjPtr<Medium> image;
    … …  
    15171517
    15181518    AutoCaller autoCaller(this);
    1519     CheckComRCReturnRC(autoCaller.rc());
     1519    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15201520
    15211521    HRESULT rc = VBOX_E_FILE_ERROR;
    … …  
    15481548
    15491549    AutoCaller autoCaller(this);
    1550     CheckComRCReturnRC(autoCaller.rc());
     1550    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15511551
    15521552    Guid id(aId);
    … …  
    15681568
    15691569    AutoCaller autoCaller(this);
    1570     CheckComRCReturnRC(autoCaller.rc());
     1570    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    15711571
    15721572    ComObjPtr<Medium> image;
    … …  
    16041604
    16051605    AutoCaller autoCaller(this);
    1606     CheckComRCReturnRC(autoCaller.rc());
     1606    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16071607
    16081608    /* first, look for a substitution */
    … …  
    16471647
    16481648    AutoCaller autoCaller(this);
    1649     CheckComRCReturnRC(autoCaller.rc());
     1649    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16501650
    16511651    return setError (E_NOTIMPL, "Not yet implemented");
    … …  
    16571657
    16581658    AutoCaller autoCaller(this);
    1659     CheckComRCReturnRC(autoCaller.rc());
     1659    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16601660
    16611661    return setError (E_NOTIMPL, "Not yet implemented");
    … …  
    16721672        return E_POINTER;
    16731673
    1674     AutoCaller autoCaller (this);
    1675     CheckComRCReturnRC (autoCaller.rc());
     1674    AutoCaller autoCaller(this);
     1675    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    16761676
    16771677    AutoReadLock alock (this);
    … …  
    17011701
    17021702    AutoCaller autoCaller(this);
    1703     CheckComRCReturnRC(autoCaller.rc());
     1703    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17041704
    17051705    /* start with nothing found */
    … …  
    17261726
    17271727    AutoCaller autoCaller(this);
    1728     CheckComRCReturnRC(autoCaller.rc());
     1728    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    17291729
    17301730    Utf8Str strKey(aKey);
    … …  
    17861786        /* save settings on success */
    17871787        HRESULT rc = saveSettings();
    1788         CheckComRCReturnRC (rc);
     1788        if (FAILED(rc)) return rc;
    17891789    }
    17901790
    … …  
    18041804
    18051805    AutoCaller autoCaller(this);
    1806     CheckComRCReturnRC(autoCaller.rc());
     1806    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18071807
    18081808    Guid id(aMachineId);
    … …  
    18101810
    18111811    HRESULT rc = findMachine (id, true /* setError */, &machine);
    1812     CheckComRCReturnRC(rc);
     1812    if (FAILED(rc)) return rc;
    18131813
    18141814    /* check the session state */
    18151815    SessionState_T state;
    18161816    rc = aSession->COMGETTER(State) (&state);
    1817     CheckComRCReturnRC(rc);
     1817    if (FAILED(rc)) return rc;
    18181818
    18191819    if (state != SessionState_Closed)
    … …  
    18601860
    18611861    AutoCaller autoCaller(this);
    1862     CheckComRCReturnRC(autoCaller.rc());
     1862    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    18631863
    18641864    Guid id(aMachineId);
    … …  
    18661866
    18671867    HRESULT rc = findMachine (id, true /* setError */, &machine);
    1868     CheckComRCReturnRC(rc);
     1868    if (FAILED(rc)) return rc;
    18691869
    18701870    /* check the session state */
    18711871    SessionState_T state;
    18721872    rc = aSession->COMGETTER(State) (&state);
    1873     CheckComRCReturnRC(rc);
     1873    if (FAILED(rc)) return rc;
    18741874
    18751875    if (state != SessionState_Closed)
    … …  
    19141914
    19151915    AutoCaller autoCaller(this);
    1916     CheckComRCReturnRC(autoCaller.rc());
     1916    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19171917
    19181918    Guid id(aMachineId);
    … …  
    19201920
    19211921    HRESULT rc = findMachine (id, true /* setError */, &machine);
    1922     CheckComRCReturnRC(rc);
     1922    if (FAILED(rc)) return rc;
    19231923
    19241924    /* check the session state */
    19251925    SessionState_T state;
    19261926    rc = aSession->COMGETTER(State) (&state);
    1927     CheckComRCReturnRC(rc);
     1927    if (FAILED(rc)) return rc;
    19281928
    19291929    if (state != SessionState_Closed)
    … …  
    19511951
    19521952    AutoCaller autoCaller(this);
    1953     CheckComRCReturnRC(autoCaller.rc());
     1953    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19541954
    19551955#if 0 /** @todo r=bird,r=pritesh: must check that the interface id match correct or we might screw up with old code! */
    … …  
    19751975
    19761976    AutoCaller autoCaller(this);
    1977     CheckComRCReturnRC(autoCaller.rc());
     1977    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    19781978
    19791979    HRESULT rc = S_OK;
    … …  
    20762076
    20772077    AutoCaller autoCaller(this);
    2078     CheckComRCReturnRC(autoCaller.rc());
     2078    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    20792079
    20802080    Bstr id;
    … …  
    21002100{
    21012101    AutoCaller autoCaller(this);
    2102     CheckComRCReturnRC(autoCaller.rc());
     2102    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21032103
    21042104    ComPtr<IProgress> progress;
    … …  
    21812181
    21822182    AutoCaller autoCaller(this);
    2183     CheckComRCReturnRC(autoCaller.rc());
     2183    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21842184
    21852185    /* create the SVCHelperClientThread() argument */
    … …  
    28262826
    28272827            HRESULT rc = hd->compareLocationTo(location.c_str(), result);
    2828             CheckComRCReturnRC(rc);
     2828            if (FAILED(rc)) return rc;
    28292829
    28302830            if (result == 0)
    … …  
    32353235HRESULT VirtualBox::saveSettings()
    32363236{
    3237     AutoCaller autoCaller (this);
     3237    AutoCaller autoCaller(this);
    32383238    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
    32393239
    … …  
    32673267            rc = (*it)->saveSettings(med);
    32683268            m->pMainConfigFile->llHardDisks.push_back(med);
    3269             CheckComRCThrowRC(rc);
     3269            if (FAILED(rc)) throw rc;
    32703270        }
    32713271
    … …  
    32783278            settings::Medium med;
    32793279            rc = (*it)->saveSettings(med);
    3280             CheckComRCThrowRC(rc);
     3280            if (FAILED(rc)) throw rc;
    32813281            m->pMainConfigFile->llDvdImages.push_back(med);
    32823282        }
    … …  
    32903290            settings::Medium med;
    32913291            rc = (*it)->saveSettings(med);
    3292             CheckComRCThrowRC(rc);
     3292            if (FAILED(rc)) throw rc;
    32933293            m->pMainConfigFile->llFloppyImages.push_back(med);
    32943294        }
    … …  
    33023302            settings::DHCPServer d;
    33033303            rc = (*it)->saveSettings(d);
    3304             CheckComRCThrowRC(rc);
     3304            if (FAILED(rc)) throw rc;
    33053305            m->pMainConfigFile->llDhcpServers.push_back(d);
    33063306        }
    … …  
    33083308        /* host data (USB filters) */
    33093309        rc = m->pHost->saveSettings(m->pMainConfigFile->host);
    3310         CheckComRCThrowRC(rc);
     3310        if (FAILED(rc)) throw rc;
    33113311
    33123312        rc = m->pSystemProperties->saveSettings(m->pMainConfigFile->systemProperties);
    3313         CheckComRCThrowRC(rc);
     3313        if (FAILED(rc)) throw rc;
    33143314
    33153315        // now write out the XML
    … …  
    33493349
    33503350    AutoCaller autoCaller(this);
    3351     CheckComRCReturnRC(autoCaller.rc());
     3351    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    33523352
    33533353    AutoWriteLock alock(this);
    … …  
    33783378        /* Machine::trySetRegistered() will commit and save machine settings */
    33793379        rc = aMachine->trySetRegistered(TRUE);
    3380         CheckComRCReturnRC(rc);
     3380        if (FAILED(rc)) return rc;
    33813381    }
    33823382
    … …  
    34243424                                         aHardDisk->getLocationFull(),
    34253425                                         strConflict);
    3426     CheckComRCReturnRC(rc);
     3426    if (FAILED(rc)) return rc;
    34273427
    34283428    if (strConflict.length())
    … …  
    35413541                                         aImage->getLocationFull(),
    35423542                                         strConflict);
    3543     CheckComRCReturnRC(rc);
     3543    if (FAILED(rc)) return rc;
    35443544
    35453545    if (strConflict.length())
    … …  
    36443644                                         aImage->getLocationFull(),
    36453645                                         strConflict);
    3646     CheckComRCReturnRC(rc);
     3646    if (FAILED(rc)) return rc;
    36473647
    36483648    if (strConflict.length())
    … …  
    44784478
    44794479    AutoCaller autoCaller(this);
    4480     CheckComRCReturnRC(autoCaller.rc());
     4480    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    44814481
    44824482    ComObjPtr<DHCPServer> dhcpServer;
    44834483    dhcpServer.createObject();
    44844484    HRESULT rc = dhcpServer->init (this, aName);
    4485     CheckComRCReturnRC(rc);
     4485    if (FAILED(rc)) return rc;
    44864486
    44874487    rc = registerDHCPServer(dhcpServer, true);
    4488     CheckComRCReturnRC(rc);
     4488    if (FAILED(rc)) return rc;
    44894489
    44904490    dhcpServer.queryInterfaceTo(aServer);
    … …  
    45044504
    45054505    AutoCaller autoCaller(this);
    4506     CheckComRCReturnRC(autoCaller.rc());
     4506    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    45074507
    45084508    AutoWriteLock alock(this);
    … …  
    45184518    {
    45194519        rc = (*it)->COMGETTER(NetworkName) (bstr.asOutParam());
    4520         CheckComRCThrowRC(rc);
     4520        if (FAILED(rc)) throw rc;
    45214521
    45224522        if(bstr == aName)
    … …  
    45384538
    45394539    AutoCaller autoCaller(this);
    4540     CheckComRCReturnRC(autoCaller.rc());
     4540    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    45414541
    45424542    HRESULT rc = unregisterDHCPServer(static_cast<DHCPServer *>(aServer), true);
    … …  
    45784578    HRESULT rc;
    45794579    rc = aDHCPServer->COMGETTER(NetworkName) (name.asOutParam());
    4580     CheckComRCReturnRC(rc);
     4580    if (FAILED(rc)) return rc;
    45814581
    45824582    ComPtr<IDHCPServer> existing;

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

    r25088 r25149  
    242242        if(SUCCEEDED(rc))
    243243        {
    244             CheckComRCReturnRC(rc);
    245244            progress.queryInterfaceTo(aProgress);
    246245            rc = NetIfAdpCtl(Utf8Str(ifname).c_str(), "remove", NULL, NULL);

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

    r22178 r25149  
    144144            ComPtr<IErrorInfo> err;
    145145            rc = ::GetErrorInfo (0, err.asOutParam());
    146             CheckComRCBreakRC (rc);
     146            if (FAILED(rc)) break;
    147147            rc = err.queryInterfaceTo(curInfo.asOutParam());
    148148            if (FAILED (rc))
    … …  
    161161        }
    162162        /* On failure, curInfo will stay null */
    163         Assert (SUCCEEDED(rc) || curInfo.isNull());
     163        Assert(SUCCEEDED(rc) || curInfo.isNull());
    164164
    165165        /* set the current error info and preserve the previous one if any */
    … …  
    174174                ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
    175175                rc = infoObj.createObject();
    176                 CheckComRCBreakRC (rc);
     176                if (FAILED(rc)) break;
    177177
    178178                rc = infoObj->init (aInfo, curInfo);
    179                 CheckComRCBreakRC (rc);
     179                if (FAILED(rc)) break;
    180180
    181181                info = infoObj;
    … …  
    184184            /* we want to return the head's result code */
    185185            rc = info->COMGETTER(ResultCode) (&aResultCode);
    186             CheckComRCBreakRC (rc);
     186            if (FAILED(rc)) break;
    187187        }
    188188        else
    … …  
    190190            ComObjPtr<VirtualBoxErrorInfo> infoObj;
    191191            rc = infoObj.createObject();
    192             CheckComRCBreakRC (rc);
     192            if (FAILED(rc)) break;
    193193
    194194            rc = infoObj->init (aResultCode, aIID, aComponent, strText.c_str(), curInfo);
    195             CheckComRCBreakRC (rc);
     195            if (FAILED(rc)) break;
    196196
    197197            info = infoObj;
    … …  
    211211            nsCOMPtr <nsIExceptionManager> em;
    212212            rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
    213             CheckComRCBreakRC (rc);
     213            if (FAILED(rc)) break;
    214214
    215215            ComPtr<IVirtualBoxErrorInfo> curInfo;
    … …  
    219219                ComPtr<nsIException> ex;
    220220                rc = em->GetCurrentException (ex.asOutParam());
    221                 CheckComRCBreakRC (rc);
     221                if (FAILED(rc)) break;
    222222                rc = ex.queryInterfaceTo(curInfo.asOutParam());
    223223                if (FAILED (rc))
    … …  
    249249                    ComObjPtr<VirtualBoxErrorInfoGlue> infoObj;
    250250                    rc = infoObj.createObject();
    251                     CheckComRCBreakRC (rc);
     251                    if (FAILED(rc)) break;
    252252
    253253                    rc = infoObj->init (aInfo, curInfo);
    254                     CheckComRCBreakRC (rc);
     254                    if (FAILED(rc)) break;
    255255
    256256                    info = infoObj;
    … …  
    260260                PRInt32 lrc;
    261261                rc = info->COMGETTER(ResultCode) (&lrc); aResultCode = lrc;
    262                 CheckComRCBreakRC (rc);
     262                if (FAILED(rc)) break;
    263263            }
    264264            else
    … …  
    266266                ComObjPtr<VirtualBoxErrorInfo> infoObj;
    267267                rc = infoObj.createObject();
    268                 CheckComRCBreakRC (rc);
     268                if (FAILED(rc)) break;
    269269
    270270                rc = infoObj->init(aResultCode, aIID, aComponent, strText, curInfo);
    271                 CheckComRCBreakRC (rc);
     271                if (FAILED(rc)) break;
    272272
    273273                info = infoObj;

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

    r22173 r25149  
    254254    ComPtr<IVirtualBoxErrorInfo> info;
    255255    nsresult rv = COMGETTER(Next) (info.asOutParam());
    256     CheckComRCReturnRC(rv);
     256    if (FAILED(rv)) return rv;
    257257    return info.queryInterfaceTo(aInner);
    258258}
    … …  
    305305        ComPtr<IVirtualBoxErrorInfo> next;
    306306        rc = cur->COMGETTER(Next) (next.asOutParam());
    307         CheckComRCReturnRC(rc);
     307        if (FAILED(rc)) return rc;
    308308
    309309        if (next.isNull())
    … …  
    327327        ComObjPtr<VirtualBoxErrorInfoGlue> wrapper;
    328328        rc = wrapper.createObject();
    329         CheckComRCBreakRC (rc);
     329        if (FAILED(rc)) break;
    330330
    331331        -- prev;
    … …  
    338338        *prev = wrapper;
    339339
    340         CheckComRCBreakRC (rc);
     340        if (FAILED(rc)) break;
    341341    }
    342342

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

    r24989 r25149  
    350350     *  @code
    351351     *      AutoCaller autoCaller(this);
    352      *      CheckComRCReturnRC(autoCaller.rc());
     352     *      if (FAILED(autoCaller.rc())) return autoCaller.rc();
    353353     *
    354354     *      Machine::AutoStateDependency<MutableStateDep> adep(mParent);
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