VirtualBox

Ignore:
Timestamp:
Jan 25, 2023 1:14:53 AM (23 months ago)
Author:
vboxsync
Message:

Main/src-server: rc -> hrc/vrc. Enabled scm rc checks. bugref:10223

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r98289 r98292  
    384384HRESULT Snapshot::setName(const com::Utf8Str &aName)
    385385{
    386     HRESULT rc = S_OK;
     386    HRESULT hrc = S_OK;
    387387
    388388    // prohibit setting a UUID only as the machine name, or else it can
    … …  
    399399        m->strName = aName;
    400400        alock.release(); /* Important! (child->parent locks are forbidden) */
    401         rc = m->pMachine->i_onSnapshotChange(this);
    402     }
    403 
    404     return rc;
     401        hrc = m->pMachine->i_onSnapshotChange(this);
     402    }
     403
     404    return hrc;
    405405}
    406406
    … …  
    414414HRESULT Snapshot::setDescription(const com::Utf8Str &aDescription)
    415415{
    416     HRESULT rc = S_OK;
     416    HRESULT hrc = S_OK;
    417417
    418418    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    421421        m->strDescription = aDescription;
    422422        alock.release(); /* Important! (child->parent locks are forbidden) */
    423         rc = m->pMachine->i_onSnapshotChange(this);
    424     }
    425 
    426     return rc;
     423        hrc = m->pMachine->i_onSnapshotChange(this);
     424    }
     425
     426    return hrc;
    427427}
    428428
    … …  
    903903        llSettingsTodo.pop_front();
    904904
    905         HRESULT rc = pSnapshot->i_saveSnapshotOne(*current);
    906         if (FAILED(rc))
    907             return rc;
     905        HRESULT hrc = pSnapshot->i_saveSnapshotOne(*current);
     906        if (FAILED(hrc))
     907            return hrc;
    908908
    909909        /* save all children */
    … …  
    954954    Assert(m->pMachine->isWriteLockOnCurrentThread());
    955955
    956     HRESULT rc = S_OK;
     956    HRESULT hrc = S_OK;
    957957
    958958    SnapshotsList llSnapshotsTodo;
    … …  
    987987        llSnapshotsAll.pop_front();
    988988
    989         rc = pSnapshot->m->pMachine->i_detachAllMedia(writeLock,
    990                                                       pSnapshot,
    991                                                       cleanupMode,
    992                                                       llMedia);
    993         if (SUCCEEDED(rc))
     989        hrc = pSnapshot->m->pMachine->i_detachAllMedia(writeLock, pSnapshot, cleanupMode, llMedia);
     990        if (SUCCEEDED(hrc))
    994991        {
    995992            Utf8Str strFile;
    … …  
    10961093    mSSData->strStateFilePath = aStateFilePath;
    10971094
    1098     HRESULT rc = S_OK;
     1095    HRESULT hrc = S_OK;
    10991096
    11001097    /* Create copies of all attachments (mMediaData after attaching a copy
    … …  
    11101107        ComObjPtr<MediumAttachment> pAtt;
    11111108        pAtt.createObject();
    1112         rc = pAtt->initCopy(this, *it);
    1113         if (FAILED(rc)) return rc;
     1109        hrc = pAtt->initCopy(this, *it);
     1110        if (FAILED(hrc)) return hrc;
    11141111        mMediumAttachments->push_back(pAtt);
    11151112
    … …  
    11171114        if (pMedium) // can be NULL for non-harddisk
    11181115        {
    1119             rc = pMedium->i_addBackReference(mData->mUuid, mSnapshotId);
    1120             AssertComRC(rc);
     1116            hrc = pMedium->i_addBackReference(mData->mUuid, mSnapshotId);
     1117            AssertComRC(hrc);
    11211118        }
    11221119    }
    … …  
    11311128        ComObjPtr<SharedFolder> pFolder;
    11321129        pFolder.createObject();
    1133         rc = pFolder->initCopy(this, *it);
    1134         if (FAILED(rc)) return rc;
     1130        hrc = pFolder->initCopy(this, *it);
     1131        if (FAILED(hrc)) return hrc;
    11351132        *it = pFolder;
    11361133    }
    … …  
    11451142        ComObjPtr<PCIDeviceAttachment> pDev;
    11461143        pDev.createObject();
    1147         rc = pDev->initCopy(this, *it);
    1148         if (FAILED(rc)) return rc;
     1144        hrc = pDev->initCopy(this, *it);
     1145        if (FAILED(hrc)) return hrc;
    11491146        *it = pDev;
    11501147    }
    … …  
    11601157        ComObjPtr<StorageController> ctrl;
    11611158        ctrl.createObject();
    1162         rc = ctrl->initCopy(this, *it);
    1163         if (FAILED(rc)) return rc;
     1159        hrc = ctrl->initCopy(this, *it);
     1160        if (FAILED(hrc)) return hrc;
    11641161        mStorageControllers->push_back(ctrl);
    11651162    }
    … …  
    11681165
    11691166    unconst(mBIOSSettings).createObject();
    1170     rc = mBIOSSettings->initCopy(this, pMachine->mBIOSSettings);
    1171     if (FAILED(rc)) return rc;
     1167    hrc = mBIOSSettings->initCopy(this, pMachine->mBIOSSettings);
     1168    if (FAILED(hrc)) return hrc;
    11721169
    11731170    unconst(mRecordingSettings).createObject();
    1174     rc = mRecordingSettings->initCopy(this, pMachine->mRecordingSettings);
    1175     if (FAILED(rc)) return rc;
     1171    hrc = mRecordingSettings->initCopy(this, pMachine->mRecordingSettings);
     1172    if (FAILED(hrc)) return hrc;
    11761173
    11771174    unconst(mTrustedPlatformModule).createObject();
    1178     rc = mTrustedPlatformModule->initCopy(this, pMachine->mTrustedPlatformModule);
    1179     if (FAILED(rc)) return rc;
     1175    hrc = mTrustedPlatformModule->initCopy(this, pMachine->mTrustedPlatformModule);
     1176    if (FAILED(hrc)) return hrc;
    11801177
    11811178    unconst(mNvramStore).createObject();
    1182     rc = mNvramStore->initCopy(this, pMachine->mNvramStore);
    1183     if (FAILED(rc)) return rc;
     1179    hrc = mNvramStore->initCopy(this, pMachine->mNvramStore);
     1180    if (FAILED(hrc)) return hrc;
    11841181
    11851182    unconst(mGraphicsAdapter).createObject();
    1186     rc = mGraphicsAdapter->initCopy(this, pMachine->mGraphicsAdapter);
    1187     if (FAILED(rc)) return rc;
     1183    hrc = mGraphicsAdapter->initCopy(this, pMachine->mGraphicsAdapter);
     1184    if (FAILED(hrc)) return hrc;
    11881185
    11891186    unconst(mVRDEServer).createObject();
    1190     rc = mVRDEServer->initCopy(this, pMachine->mVRDEServer);
    1191     if (FAILED(rc)) return rc;
     1187    hrc = mVRDEServer->initCopy(this, pMachine->mVRDEServer);
     1188    if (FAILED(hrc)) return hrc;
    11921189
    11931190    unconst(mAudioSettings).createObject();
    1194     rc = mAudioSettings->initCopy(this, pMachine->mAudioSettings);
    1195     if (FAILED(rc)) return rc;
     1191    hrc = mAudioSettings->initCopy(this, pMachine->mAudioSettings);
     1192    if (FAILED(hrc)) return hrc;
    11961193
    11971194    /* create copies of all USB controllers (mUSBControllerData
    … …  
    12051202        ComObjPtr<USBController> ctrl;
    12061203        ctrl.createObject();
    1207         rc = ctrl->initCopy(this, *it);
    1208         if (FAILED(rc)) return rc;
     1204        hrc = ctrl->initCopy(this, *it);
     1205        if (FAILED(hrc)) return hrc;
    12091206        mUSBControllers->push_back(ctrl);
    12101207    }
    12111208
    12121209    unconst(mUSBDeviceFilters).createObject();
    1213     rc = mUSBDeviceFilters->initCopy(this, pMachine->mUSBDeviceFilters);
    1214     if (FAILED(rc)) return rc;
     1210    hrc = mUSBDeviceFilters->initCopy(this, pMachine->mUSBDeviceFilters);
     1211    if (FAILED(hrc)) return hrc;
    12151212
    12161213    mNetworkAdapters.resize(pMachine->mNetworkAdapters.size());
    … …  
    12181215    {
    12191216        unconst(mNetworkAdapters[slot]).createObject();
    1220         rc = mNetworkAdapters[slot]->initCopy(this, pMachine->mNetworkAdapters[slot]);
    1221         if (FAILED(rc)) return rc;
     1217        hrc = mNetworkAdapters[slot]->initCopy(this, pMachine->mNetworkAdapters[slot]);
     1218        if (FAILED(hrc)) return hrc;
    12221219    }
    12231220
    … …  
    12251222    {
    12261223        unconst(mSerialPorts[slot]).createObject();
    1227         rc = mSerialPorts[slot]->initCopy(this, pMachine->mSerialPorts[slot]);
    1228         if (FAILED(rc)) return rc;
     1224        hrc = mSerialPorts[slot]->initCopy(this, pMachine->mSerialPorts[slot]);
     1225        if (FAILED(hrc)) return hrc;
    12291226    }
    12301227
    … …  
    12321229    {
    12331230        unconst(mParallelPorts[slot]).createObject();
    1234         rc = mParallelPorts[slot]->initCopy(this, pMachine->mParallelPorts[slot]);
    1235         if (FAILED(rc)) return rc;
     1231        hrc = mParallelPorts[slot]->initCopy(this, pMachine->mParallelPorts[slot]);
     1232        if (FAILED(hrc)) return hrc;
    12361233    }
    12371234
    12381235    unconst(mBandwidthControl).createObject();
    1239     rc = mBandwidthControl->initCopy(this, pMachine->mBandwidthControl);
    1240     if (FAILED(rc)) return rc;
     1236    hrc = mBandwidthControl->initCopy(this, pMachine->mBandwidthControl);
     1237    if (FAILED(hrc)) return hrc;
    12411238
    12421239    unconst(mGuestDebugControl).createObject();
    1243     rc = mGuestDebugControl->initCopy(this, pMachine->mGuestDebugControl);
    1244     if (FAILED(rc)) return rc;
     1240    hrc = mGuestDebugControl->initCopy(this, pMachine->mGuestDebugControl);
     1241    if (FAILED(hrc)) return hrc;
    12451242
    12461243    /* Confirm a successful initialization when it's the case */
    … …  
    14361433    mMachine->i_setModified(Machine::IsModified_Snapshots, false /* fAllowStateModification */);
    14371434    slock.release();
    1438     HRESULT rc = mMachine->i_saveSettings(&fNeedsGlobalSaveSettings,
    1439                                           alock,
    1440                                           SaveS_Force);        // we know we need saving, no need to check
     1435    HRESULT hrc = mMachine->i_saveSettings(&fNeedsGlobalSaveSettings,
     1436                                           alock,
     1437                                           SaveS_Force);        // we know we need saving, no need to check
    14411438    alock.release();
    14421439
    1443     if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
     1440    if (SUCCEEDED(hrc) && fNeedsGlobalSaveSettings)
    14441441    {
    14451442        // save the global settings
    14461443        AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
    1447         rc = mParent->i_saveSettings();
     1444        hrc = mParent->i_saveSettings();
    14481445    }
    14491446
    … …  
    14511448    mParent->i_onSnapshotChanged(uuidMachine, uuidSnapshot);
    14521449
    1453     return rc;
     1450    return hrc;
    14541451}
    14551452
    … …  
    16341631                        Global::stringifyMachineState(mData->mMachineState));
    16351632
    1636     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    1637     if (FAILED(rc))
    1638         return rc;
     1633    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     1634    if (FAILED(hrc))
     1635        return hrc;
    16391636
    16401637    // prepare the progress object:
    … …  
    16721669    ComObjPtr<Progress> pProgress;
    16731670    pProgress.createObject();
    1674     rc = pProgress->init(mParent,
    1675                          static_cast<IMachine *>(this),
    1676                          Bstr(tr("Taking a snapshot of the virtual machine")).raw(),
    1677                          fTakingSnapshotOnline /* aCancelable */,
    1678                          cOperations,
    1679                          ulTotalOperationsWeight,
    1680                          Bstr(tr("Setting up snapshot operation")).raw(),      // first sub-op description
    1681                          1);        // ulFirstOperationWeight
    1682     if (FAILED(rc))
    1683         return rc;
     1671    hrc = pProgress->init(mParent,
     1672                          static_cast<IMachine *>(this),
     1673                          Bstr(tr("Taking a snapshot of the virtual machine")).raw(),
     1674                          fTakingSnapshotOnline /* aCancelable */,
     1675                          cOperations,
     1676                          ulTotalOperationsWeight,
     1677                          Bstr(tr("Setting up snapshot operation")).raw(),      // first sub-op description
     1678                          1);        // ulFirstOperationWeight
     1679    if (FAILED(hrc))
     1680        return hrc;
    16841681
    16851682    /* create an ID for the snapshot */
    … …  
    17001697                                                   fTakingSnapshotOnline);
    17011698    MachineState_T const machineStateBackup = pTask->m_machineStateBackup;
    1702     rc = pTask->createThread();
     1699    hrc = pTask->createThread();
    17031700    pTask = NULL;
    1704     if (FAILED(rc))
    1705         return rc;
     1701    if (FAILED(hrc))
     1702        return hrc;
    17061703
    17071704    /* set the proper machine state (note: after creating a Task instance) */
    … …  
    17201717    pProgress.queryInterfaceTo(aProgress.asOutParam());
    17211718
    1722     return rc;
     1719    return hrc;
    17231720}
    17241721
    … …  
    17461743    // 5) update the various snapshot/machine objects, save settings
    17471744
    1748     HRESULT rc = S_OK;
     1745    HRESULT hrc = S_OK;
    17491746    AutoCaller autoCaller(this);
    17501747    LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
    … …  
    17531750        /* we might have been uninitialized because the session was accidentally
    17541751         * closed by the client, so don't assert */
    1755         rc = setError(E_FAIL,
    1756                       tr("The session has been accidentally closed"));
    1757         task.m_pProgress->i_notifyComplete(rc);
     1752        hrc = setError(E_FAIL, tr("The session has been accidentally closed"));
     1753        task.m_pProgress->i_notifyComplete(hrc);
    17581754        LogFlowThisFuncLeave();
    17591755        return;
    … …  
    17891785        /* save settings to ensure current changes are committed and
    17901786         * hard disks are fixed up */
    1791         rc = i_saveSettings(NULL, alock); /******************1 */
     1787        hrc = i_saveSettings(NULL, alock); /******************1 */
    17921788            // no need to check for whether VirtualBox.xml needs changing since
    17931789            // we can't have a machine XML rename pending at this point
    1794         if (FAILED(rc))
    1795             throw rc;
     1790        if (FAILED(hrc))
     1791            throw hrc;
    17961792
    17971793        /* task.m_strStateFilePath is "" when the machine is offline or saved */
    … …  
    17991795        {
    18001796            Bstr value;
    1801             rc = GetExtraData(Bstr("VBoxInternal2/ForceTakeSnapshotWithoutState").raw(),
    1802                               value.asOutParam());
    1803             if (FAILED(rc) || value != "1")
     1797            hrc = GetExtraData(Bstr("VBoxInternal2/ForceTakeSnapshotWithoutState").raw(), value.asOutParam());
     1798            if (FAILED(hrc) || value != "1")
    18041799                // creating a new online snapshot: we need a fresh saved state file
    18051800                i_composeSavedStateFilename(task.m_strStateFilePath);
    … …  
    18121807        {
    18131808            // ensure the directory for the saved state file exists
    1814             rc = VirtualBox::i_ensureFilePathExists(task.m_strStateFilePath, true /* fCreate */);
    1815             if (FAILED(rc))
    1816                 throw rc;
     1809            hrc = VirtualBox::i_ensureFilePathExists(task.m_strStateFilePath, true /* fCreate */);
     1810            if (FAILED(hrc))
     1811                throw hrc;
    18171812        }
    18181813
    … …  
    18221817        ComObjPtr<SnapshotMachine> pSnapshotMachine;
    18231818        pSnapshotMachine.createObject();
    1824         rc = pSnapshotMachine->init(this, task.m_uuidSnapshot.ref(), task.m_strStateFilePath);
    1825         AssertComRCThrowRC(rc);
     1819        hrc = pSnapshotMachine->init(this, task.m_uuidSnapshot.ref(), task.m_strStateFilePath);
     1820        AssertComRCThrowRC(hrc);
    18261821
    18271822        /* create a snapshot object */
    … …  
    18291824        RTTimeNow(&time);
    18301825        task.m_pSnapshot.createObject();
    1831         rc = task.m_pSnapshot->init(mParent,
    1832                                     task.m_uuidSnapshot,
    1833                                     task.m_strName,
    1834                                     task.m_strDescription,
    1835                                     time,
    1836                                     pSnapshotMachine,
    1837                                     mData->mCurrentSnapshot);
    1838         AssertComRCThrowRC(rc);
     1826        hrc = task.m_pSnapshot->init(mParent,
     1827                                     task.m_uuidSnapshot,
     1828                                     task.m_strName,
     1829                                     task.m_strDescription,
     1830                                     time,
     1831                                     pSnapshotMachine,
     1832                                     mData->mCurrentSnapshot);
     1833        AssertComRCThrowRC(hrc);
    18391834
    18401835        /* STEP 2: create the diff images */
    1841         LogFlowThisFunc(("Creating differencing hard disks (online=%d)...\n",
    1842                          task.m_fTakingSnapshotOnline));
     1836        LogFlowThisFunc(("Creating differencing hard disks (online=%d)...\n", task.m_fTakingSnapshotOnline));
    18431837
    18441838        // Backup the media data so we can recover if something goes wrong.
    … …  
    18491843        alock.release();
    18501844        /* create new differencing hard disks and attach them to this machine */
    1851         rc = i_createImplicitDiffs(task.m_pProgress,
    1852                                    1,            // operation weight; must be the same as in Machine::TakeSnapshot()
    1853                                    task.m_fTakingSnapshotOnline);
    1854         if (FAILED(rc))
    1855             throw rc;
     1845        hrc = i_createImplicitDiffs(task.m_pProgress,
     1846                                    1,            // operation weight; must be the same as in Machine::TakeSnapshot()
     1847                                    task.m_fTakingSnapshotOnline);
     1848        if (FAILED(hrc))
     1849            throw hrc;
    18561850        alock.acquire();
    18571851
    … …  
    18731867                alock.release();
    18741868                task.m_pProgress->i_setCancelCallback(i_takeSnapshotProgressCancelCallback, &task);
    1875                 rc = task.m_pDirectControl->SaveStateWithReason(Reason_Snapshot,
    1876                                                                 task.m_pProgress,
    1877                                                                 task.m_pSnapshot,
    1878                                                                 Bstr(task.m_strStateFilePath).raw(),
    1879                                                                 task.m_fPause,
    1880                                                                 &fSuspendedBySave);
     1869                hrc = task.m_pDirectControl->SaveStateWithReason(Reason_Snapshot,
     1870                                                                 task.m_pProgress,
     1871                                                                 task.m_pSnapshot,
     1872                                                                 Bstr(task.m_strStateFilePath).raw(),
     1873                                                                 task.m_fPause,
     1874                                                                 &fSuspendedBySave);
    18811875                task.m_pProgress->i_setCancelCallback(NULL, NULL);
    18821876                alock.acquire();
    1883                 if (FAILED(rc))
    1884                     throw rc;
     1877                if (FAILED(hrc))
     1878                    throw hrc;
    18851879            }
    18861880            else
    … …  
    18971891
    18981892            com::SafeIfaceArray<IMediumAttachment> atts;
    1899             rc = COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
    1900             if (FAILED(rc))
    1901                 throw rc;
     1893            hrc = COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
     1894            if (FAILED(hrc))
     1895                throw hrc;
    19021896
    19031897            alock.release();
    1904             rc = task.m_pDirectControl->ReconfigureMediumAttachments(ComSafeArrayAsInParam(atts));
     1898            hrc = task.m_pDirectControl->ReconfigureMediumAttachments(ComSafeArrayAsInParam(atts));
    19051899            alock.acquire();
    1906             if (FAILED(rc))
    1907                 throw rc;
     1900            if (FAILED(hrc))
     1901                throw hrc;
    19081902        }
    19091903
    … …  
    19151909            Utf8Str strNVRAMSnapAbs;
    19161910            i_calculateFullPath(strNVRAMSnap, strNVRAMSnapAbs);
    1917             rc = VirtualBox::i_ensureFilePathExists(strNVRAMSnapAbs, true /* fCreate */);
    1918             if (FAILED(rc))
    1919                 throw rc;
     1911            hrc = VirtualBox::i_ensureFilePathExists(strNVRAMSnapAbs, true /* fCreate */);
     1912            if (FAILED(hrc))
     1913                throw hrc;
    19201914            int vrc = RTFileCopy(strNVRAM.c_str(), strNVRAMSnapAbs.c_str());
    19211915            if (RT_FAILURE(vrc))
    … …  
    19651959         * machine state to the state it had at the beginning.
    19661960         */
    1967         rc = i_finishTakingSnapshot(task, alock, true /*aSuccess*/); /*******************2+3 */
    1968         // do not throw rc here because we can't call i_finishTakingSnapshot() twice
    1969         LogFlowThisFunc(("i_finishTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, ::stringifyMachineState(mData->mMachineState)));
    1970     }
    1971     catch (HRESULT rcThrown)
    1972     {
    1973         rc = rcThrown;
    1974         LogThisFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, ::stringifyMachineState(mData->mMachineState)));
     1961        hrc = i_finishTakingSnapshot(task, alock, true /*aSuccess*/); /*******************2+3 */
     1962        // do not throw hrc here because we can't call i_finishTakingSnapshot() twice
     1963        LogFlowThisFunc(("i_finishTakingSnapshot -> %Rhrc [mMachineState=%s]\n", hrc, ::stringifyMachineState(mData->mMachineState)));
     1964    }
     1965    catch (HRESULT hrcXcpt)
     1966    {
     1967        hrc = hrcXcpt;
     1968        LogThisFunc(("Caught %Rhrc [mMachineState=%s]\n", hrc, ::stringifyMachineState(mData->mMachineState)));
    19751969
    19761970        /// @todo r=klaus check that the implicit diffs created above are cleaned up im the relevant error cases
    … …  
    20132007            {
    20142008                MachineState_T enmMachineState = MachineState_Null;
    2015                 HRESULT rc2 = task.m_pDirectControl->COMGETTER(NominalState)(&enmMachineState);
    2016                 if (FAILED(rc2) || enmMachineState == MachineState_Null)
     2009                HRESULT hrc2 = task.m_pDirectControl->COMGETTER(NominalState)(&enmMachineState);
     2010                if (FAILED(hrc2) || enmMachineState == MachineState_Null)
    20172011                {
    20182012                    AssertMsgFailed(("state=%s\n", ::stringifyMachineState(enmMachineState)));
    … …  
    20252019                    {
    20262020                        alock.release();
    2027                         rc2 = task.m_pDirectControl->ResumeWithReason(Reason_Snapshot);
     2021                        hrc2 = task.m_pDirectControl->ResumeWithReason(Reason_Snapshot);
    20282022                        alock.acquire();
    2029                         if (SUCCEEDED(rc2))
     2023                        if (SUCCEEDED(hrc2))
    20302024                            enmMachineState = task.m_machineStateBackup;
    20312025                    }
    … …  
    20572051    }
    20582052
    2059     task.m_pProgress->i_notifyComplete(rc);
    2060 
    2061     if (SUCCEEDED(rc))
     2053    task.m_pProgress->i_notifyComplete(hrc);
     2054
     2055    if (SUCCEEDED(hrc))
    20622056        mParent->i_onSnapshotTaken(mData->mUuid, task.m_uuidSnapshot);
    20632057
    2064     if (SUCCEEDED(rc))
     2058    if (SUCCEEDED(hrc))
    20652059    {
    20662060        for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    … …  
    21262120    ComObjPtr<Snapshot> pOldCurrentSnap = mData->mCurrentSnapshot;
    21272121
    2128     HRESULT rc = S_OK;
     2122    HRESULT hrc = S_OK;
    21292123
    21302124    if (aSuccess)
    … …  
    21442138            flSaveSettings |= SaveS_ResetCurStateModified;
    21452139
    2146         rc = i_saveSettings(NULL, alock, flSaveSettings); /******************2 */
    2147     }
    2148 
    2149     if (aSuccess && SUCCEEDED(rc))
     2140        hrc = i_saveSettings(NULL, alock, flSaveSettings); /******************2 */
     2141    }
     2142
     2143    if (aSuccess && SUCCEEDED(hrc))
    21502144    {
    21512145        /* associate old hard disks with the snapshot and do locking/unlocking*/
    … …  
    21862180    alock.acquire();
    21872181
    2188     return rc;
     2182    return hrc;
    21892183}
    21902184
    … …  
    22282222                        Global::stringifyMachineState(mData->mMachineState));
    22292223
    2230     HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
    2231     if (FAILED(rc))
    2232         return rc;
     2224    HRESULT hrc = i_checkStateDependency(MutableOrSavedStateDep);
     2225    if (FAILED(hrc))
     2226        return hrc;
    22332227
    22342228    /* We need to explicitly check if the given snapshot is valid and bail out if not. */
    … …  
    22852279                                                         "RestoreSnap",
    22862280                                                         pSnapshot);
    2287     rc = pTask->createThread();
     2281    hrc = pTask->createThread();
    22882282    pTask = NULL;
    2289     if (FAILED(rc))
    2290         return rc;
     2283    if (FAILED(hrc))
     2284        return hrc;
    22912285
    22922286    /* set the proper machine state (note: after creating a Task instance) */
    … …  
    23332327    }
    23342328
    2335     HRESULT rc = S_OK;
     2329    HRESULT hrc = S_OK;
    23362330    Guid snapshotId;
    23372331    std::set<ComObjPtr<Medium> > pMediumsForNotify;
    … …  
    23622356            task.modifyBackedUpState(MachineState_PoweredOff);
    23632357
    2364             rc = i_saveStateSettings(SaveSTS_StateFilePath);
    2365             if (FAILED(rc))
    2366                 throw rc;
     2358            hrc = i_saveStateSettings(SaveSTS_StateFilePath);
     2359            if (FAILED(hrc))
     2360                throw hrc;
    23672361        }
    23682362
    … …  
    24052399            alock.release();
    24062400
    2407             rc = i_createImplicitDiffs(task.m_pProgress,
    2408                                        1,
    2409                                        false /* aOnline */);
    2410             if (FAILED(rc))
    2411                 throw rc;
     2401            hrc = i_createImplicitDiffs(task.m_pProgress, 1, false /* aOnline */);
     2402            if (FAILED(hrc))
     2403                throw hrc;
    24122404
    24132405            alock.acquire();
    … …  
    25532545        // save machine settings, reset the modified flag and commit;
    25542546        bool fNeedsGlobalSaveSettings = false;
    2555         rc = i_saveSettings(&fNeedsGlobalSaveSettings, alock,
    2556                             SaveS_ResetCurStateModified);
    2557         if (FAILED(rc))
    2558             throw rc;
     2547        hrc = i_saveSettings(&fNeedsGlobalSaveSettings, alock, SaveS_ResetCurStateModified);
     2548        if (FAILED(hrc))
     2549            throw hrc;
    25592550
    25602551        // release the locks before updating registry and deleting image files
    … …  
    25762567            // store the id here because it becomes NULL after deleting storage.
    25772568            com::Guid id = pMedium->i_getId();
    2578             HRESULT rc2 = pMedium->i_deleteStorage(NULL /* aProgress */,
    2579                                                    true /* aWait */,
    2580                                                    false /* aNotify */);
     2569            HRESULT hrc2 = pMedium->i_deleteStorage(NULL /* aProgress */, true /* aWait */, false /* aNotify */);
    25812570            // ignore errors here because we cannot roll back after i_saveSettings() above
    2582             if (SUCCEEDED(rc2))
     2571            if (SUCCEEDED(hrc2))
    25832572            {
    25842573                pMediumsForNotify.insert(pParent);
    … …  
    25902579    catch (HRESULT hrcXcpt)
    25912580    {
    2592         rc = hrcXcpt;
    2593     }
    2594 
    2595     if (FAILED(rc))
     2581        hrc = hrcXcpt;
     2582    }
     2583
     2584    if (FAILED(hrc))
    25962585    {
    25972586        /* preserve existing error info */
    … …  
    26092598
    26102599    /* set the result (this will try to fetch current error info on failure) */
    2611     task.m_pProgress->i_notifyComplete(rc);
    2612 
    2613     if (SUCCEEDED(rc))
     2600    task.m_pProgress->i_notifyComplete(hrc);
     2601
     2602    if (SUCCEEDED(hrc))
    26142603    {
    26152604        mParent->i_onSnapshotRestored(mData->mUuid, snapshotId);
    … …  
    26292618    }
    26302619
    2631     LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
     2620    LogFlowThisFunc(("Done restoring snapshot (hrc=%08X)\n", hrc));
    26322621
    26332622    LogFlowThisFuncLeave();
    … …  
    27312720                        Global::stringifyMachineState(mData->mMachineState));
    27322721
    2733     HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
    2734     if (FAILED(rc))
    2735         return rc;
     2722    HRESULT hrc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
     2723    if (FAILED(hrc))
     2724        return hrc;
    27362725
    27372726    ComObjPtr<Snapshot> pSnapshot;
    2738     rc = i_findSnapshotById(aStartId, pSnapshot, true /* aSetError */);
    2739     if (FAILED(rc))
    2740         return rc;
     2727    hrc = i_findSnapshotById(aStartId, pSnapshot, true /* aSetError */);
     2728    if (FAILED(hrc))
     2729        return hrc;
    27412730
    27422731    AutoWriteLock snapshotLock(pSnapshot COMMA_LOCKVAL_SRC_POS);
    … …  
    27662755        {
    27672756            snapshotLock.release();
    2768             rc = i_saveSettings(NULL, alock);
     2757            hrc = i_saveSettings(NULL, alock);
    27692758            snapshotLock.acquire();
    27702759                // no need to change for whether VirtualBox.xml needs saving since
    27712760                // we can't have a machine XML rename pending at this point
    2772             if (FAILED(rc)) return rc;
     2761            if (FAILED(hrc)) return hrc;
    27732762        }
    27742763    }
    … …  
    28392828                                                       fDeleteOnline,
    28402829                                                       pSnapshot);
    2841     rc = pTask->createThread();
     2830    hrc = pTask->createThread();
    28422831    pTask = NULL;
    2843     if (FAILED(rc))
    2844         return rc;
     2832    if (FAILED(hrc))
     2833        return hrc;
    28452834
    28462835    // the task might start running but will block on acquiring the machine's write lock
    … …  
    29882977    try
    29892978    {
    2990         HRESULT rc = S_OK;
     2979        HRESULT hrc = S_OK;
    29912980
    29922981        /* Locking order:  */
    … …  
    30693058                if (pOnlineMediumAttachment)
    30703059                {
    3071                     rc = mData->mSession.mLockedMedia.Get(pOnlineMediumAttachment,
    3072                                                           pVMMALockList);
    3073                     if (FAILED(rc))
     3060                    hrc = mData->mSession.mLockedMedia.Get(pOnlineMediumAttachment, pVMMALockList);
     3061                    if (FAILED(hrc))
    30743062                        fOnlineMergePossible = false;
    30753063                }
    … …  
    30823070
    30833071            treeLock.release();
    3084             rc = i_prepareDeleteSnapshotMedium(pHD, machineId, snapshotId,
    3085                                                fOnlineMergePossible,
    3086                                                pVMMALockList, pSource, pTarget,
    3087                                                fMergeForward, pParentForTarget,
    3088                                                pChildrenToReparent,
    3089                                                fNeedsOnlineMerge,
    3090                                                pMediumLockList,
    3091                                                pHDLockToken);
     3072            hrc = i_prepareDeleteSnapshotMedium(pHD, machineId, snapshotId,
     3073                                                fOnlineMergePossible,
     3074                                                pVMMALockList, pSource, pTarget,
     3075                                                fMergeForward, pParentForTarget,
     3076                                                pChildrenToReparent,
     3077                                                fNeedsOnlineMerge,
     3078                                                pMediumLockList,
     3079                                                pHDLockToken);
    30923080            treeLock.acquire();
    3093             if (FAILED(rc))
    3094                 throw rc;
     3081            if (FAILED(hrc))
     3082                throw hrc;
    30953083
    30963084            // For simplicity, prepareDeleteSnapshotMedium selects the merge
    … …  
    31073095            // not going to merge a big source into a small target on online merge. Otherwise it will be resized
    31083096            if (fNeedsOnlineMerge && pSource->i_getLogicalSize() > pTarget->i_getLogicalSize())
    3109             {
    3110                 rc = setError(E_FAIL,
    3111                               tr("Unable to merge storage '%s', because it is smaller than the source image. If you resize it to have a capacity of at least %lld bytes you can retry",
    3112                                  "", pSource->i_getLogicalSize()),
    3113                               pTarget->i_getLocationFull().c_str(), pSource->i_getLogicalSize());
    3114                 throw rc;
    3115             }
     3097                throw setError(E_FAIL,
     3098                               tr("Unable to merge storage '%s', because it is smaller than the source image. If you resize it to have a capacity of at least %lld bytes you can retry",
     3099                                  "", pSource->i_getLogicalSize()),
     3100                               pTarget->i_getLocationFull().c_str(), pSource->i_getLogicalSize());
    31163101
    31173102            // a couple paranoia checks for backward merges
    … …  
    31473132                // Note that the medium attachment object stays associated
    31483133                // with the snapshot until the merge was successful.
    3149                 HRESULT rc2 = S_OK;
    3150                 rc2 = pSource->i_removeBackReference(replaceMachineId, replaceSnapshotId);
    3151                 AssertComRC(rc2);
     3134                HRESULT hrc2 = pSource->i_removeBackReference(replaceMachineId, replaceSnapshotId);
     3135                AssertComRC(hrc2);
    31523136
    31533137                toDelete.push_back(MediumDeleteRec(pHD, pSource, pTarget,
    … …  
    31993183                }
    32003184
    3201                 rc = pTarget_local->COMGETTER(MediumFormat)(pTargetFormat.asOutParam());
    3202                 if (FAILED(rc))
    3203                     throw rc;
     3185                hrc = pTarget_local->COMGETTER(MediumFormat)(pTargetFormat.asOutParam());
     3186                if (FAILED(hrc))
     3187                    throw hrc;
    32043188
    32053189                if (pTarget_local->i_isMediumFormatFile())
    … …  
    32073191                    int vrc = RTFsQuerySerial(pTarget_local->i_getLocationFull().c_str(), &pu32Serial);
    32083192                    if (RT_FAILURE(vrc))
    3209                     {
    3210                         rc = setError(E_FAIL,
    3211                                       tr("Unable to merge storage '%s'. Can't get storage UID"),
    3212                                       pTarget_local->i_getLocationFull().c_str());
    3213                         throw rc;
    3214                     }
     3193                        throw setError(E_FAIL,
     3194                                       tr("Unable to merge storage '%s'. Can't get storage UID"),
     3195                                       pTarget_local->i_getLocationFull().c_str());
    32153196
    32163197                    pSource_local->COMGETTER(Size)((LONG64*)&diskSize);
    … …  
    32503231                    LogFlowThisFunc(("Path to the storage wasn't found...\n"));
    32513232
    3252                     rc = setError(E_INVALIDARG,
    3253                                   tr("Unable to merge storage '%s'. Path to the storage wasn't found"),
    3254                                   it_sm->second);
    3255                     throw rc;
     3233                    throw setError(E_INVALIDARG,
     3234                                   tr("Unable to merge storage '%s'. Path to the storage wasn't found"),
     3235                                   it_sm->second);
    32563236                }
    32573237
    … …  
    32593239                if (RT_FAILURE(vrc))
    32603240                {
    3261                     rc = setError(E_FAIL,
    3262                                   tr("Unable to merge storage '%s'. Can't get the storage size"),
    3263                                   it_sm->second);
    3264                     throw rc;
     3241                    throw setError(E_FAIL,
     3242                                   tr("Unable to merge storage '%s'. Can't get the storage size"),
     3243                                   it_sm->second);
    32653244                }
    32663245
    … …  
    32693248                    LogFlowThisFunc(("Not enough free space to merge...\n"));
    32703249
    3271                     rc = setError(E_OUTOFMEMORY,
    3272                                   tr("Unable to merge storage '%s'. Not enough free storage space"),
    3273                                   it_sm->second);
    3274                     throw rc;
     3250                    throw setError(E_OUTOFMEMORY,
     3251                                   tr("Unable to merge storage '%s'. Not enough free storage space"),
     3252                                   it_sm->second);
    32753253                }
    32763254
    … …  
    33633341                    Guid uMedium = pMedium->i_getId();
    33643342                    DeviceType_T uMediumType = pMedium->i_getDeviceType();
    3365                     rc = pMedium->i_deleteStorage(&task.m_pProgress,
    3366                                                   true /* aWait */,
    3367                                                   false /* aNotify */);
    3368                     if (FAILED(rc))
    3369                         throw rc;
     3343                    hrc = pMedium->i_deleteStorage(&task.m_pProgress, true /* aWait */, false /* aNotify */);
     3344                    if (FAILED(hrc))
     3345                        throw hrc;
    33703346
    33713347                    pMediumsForNotify.insert(pParent);
    … …  
    34243400                    mConsoleTaskData.mDeleteSnapshotInfo = (void *)&(*it);
    34253401                    // online medium merge, in the direction decided earlier
    3426                     rc = i_onlineMergeMedium(it->mpOnlineMediumAttachment,
    3427                                              it->mpSource,
    3428                                              it->mpTarget,
    3429                                              it->mfMergeForward,
    3430                                              it->mpParentForTarget,
    3431                                              it->mpChildrenToReparent,
    3432                                              it->mpMediumLockList,
    3433                                              task.m_pProgress,
    3434                                              &fNeedsSave);
     3402                    hrc = i_onlineMergeMedium(it->mpOnlineMediumAttachment,
     3403                                              it->mpSource,
     3404                                              it->mpTarget,
     3405                                              it->mfMergeForward,
     3406                                              it->mpParentForTarget,
     3407                                              it->mpChildrenToReparent,
     3408                                              it->mpMediumLockList,
     3409                                              task.m_pProgress,
     3410                                              &fNeedsSave);
    34353411                    mConsoleTaskData.mDeleteSnapshotInfo = NULL;
    34363412                }
    … …  
    34383414                {
    34393415                    // normal medium merge, in the direction decided earlier
    3440                     rc = it->mpSource->i_mergeTo(it->mpTarget,
    3441                                                  it->mfMergeForward,
    3442                                                  it->mpParentForTarget,
    3443                                                  it->mpChildrenToReparent,
    3444                                                  it->mpMediumLockList,
    3445                                                  &task.m_pProgress,
    3446                                                  true /* aWait */,
    3447                                                  false /* aNotify */);
     3416                    hrc = it->mpSource->i_mergeTo(it->mpTarget,
     3417                                                  it->mfMergeForward,
     3418                                                  it->mpParentForTarget,
     3419                                                  it->mpChildrenToReparent,
     3420                                                  it->mpMediumLockList,
     3421                                                  &task.m_pProgress,
     3422                                                  true /* aWait */,
     3423                                                  false /* aNotify */);
    34483424                }
    34493425
    … …  
    34543430                // moment) is still there or not. Be careful not to lose the
    34553431                // error code below, before the "Delayed failure exit".
    3456                 if (FAILED(rc))
     3432                if (FAILED(hrc))
    34573433                {
    34583434                    AutoReadLock mlock(it->mpSource COMMA_LOCKVAL_SRC_POS);
    … …  
    34603436                        // Diff medium not backed by a file - cannot get status so
    34613437                        // be pessimistic.
    3462                         throw rc;
     3438                        throw hrc;
    34633439                    const Utf8Str &loc = it->mpSource->i_getLocationFull();
    34643440                    // Source medium is still there, so merge failed early.
    34653441                    if (RTFileExists(loc.c_str()))
    3466                         throw rc;
     3442                        throw hrc;
    34673443
    34683444                    // Source medium is gone. Assume the merge succeeded and
    … …  
    35513527            // Delayed failure exit when the merge cleanup failed but the
    35523528            // merge actually succeeded.
    3553             if (FAILED(rc))
    3554                 throw rc;
     3529            if (FAILED(hrc))
     3530                throw hrc;
    35553531        }
    35563532
    … …  
    36383614    }
    36393615
    3640     LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", (HRESULT)mrc));
     3616    LogFlowThisFunc(("Done deleting snapshot (mrc=%08X)\n", (HRESULT)mrc));
    36413617    LogFlowThisFuncLeave();
    36423618}
    … …  
    37643740        childLock.release();
    37653741        alock.release();
    3766         HRESULT rc = aHD->i_queryPreferredMergeDirection(pChild, fMergeForward);
     3742        HRESULT hrc = aHD->i_queryPreferredMergeDirection(pChild, fMergeForward);
    37673743        alock.acquire();
    37683744        childLock.acquire();
    37693745
    3770         if (FAILED(rc) && rc != E_FAIL)
    3771             return rc;
     3746        if (FAILED(hrc) && hrc != E_FAIL)
     3747            return hrc;
    37723748
    37733749        if (fMergeForward)
    … …  
    37853761    }
    37863762
    3787     HRESULT rc;
     3763    HRESULT hrc;
    37883764    childLock.release();
    37893765    alock.release();
    3790     rc = aSource->i_prepareMergeTo(aTarget, &aMachineId, &aSnapshotId,
    3791                                    !fOnlineMergePossible /* fLockMedia */,
    3792                                    aMergeForward, aParentForTarget,
    3793                                    aChildrenToReparent, aMediumLockList);
     3766    hrc = aSource->i_prepareMergeTo(aTarget, &aMachineId, &aSnapshotId,
     3767                                    !fOnlineMergePossible /* fLockMedia */,
     3768                                    aMergeForward, aParentForTarget,
     3769                                    aChildrenToReparent, aMediumLockList);
    37943770    alock.acquire();
    37953771    childLock.acquire();
    3796     if (SUCCEEDED(rc) && fOnlineMergePossible)
     3772    if (SUCCEEDED(hrc) && fOnlineMergePossible)
    37973773    {
    37983774        /* Try to lock the newly constructed medium lock list. If it succeeds
    … …  
    38023778        childLock.release();
    38033779        alock.release();
    3804         rc = aMediumLockList->Lock();
     3780        hrc = aMediumLockList->Lock();
    38053781        alock.acquire();
    38063782        childLock.acquire();
    3807         if (FAILED(rc))
     3783        if (FAILED(hrc))
    38083784        {
    38093785            /* Locking failed, this cannot be done as an offline merge. Try to
    … …  
    38343810                childLock.release();
    38353811                alock.release();
    3836                 rc = it->UpdateLock(fLockReq);
     3812                hrc = it->UpdateLock(fLockReq);
    38373813                alock.acquire();
    38383814                childLock.acquire();
    3839                 if (FAILED(rc))
     3815                if (FAILED(hrc))
    38403816                {
    38413817                    // could not update the lock, trigger cleanup below
    … …  
    38623838                    childLock.release();
    38633839                    alock.release();
    3864                     rc = aChildrenToReparent->Lock(true /* fSkipOverLockedMedia */);
     3840                    hrc = aChildrenToReparent->Lock(true /* fSkipOverLockedMedia */);
    38653841                    alock.acquire();
    38663842                    childLock.acquire();
    … …  
    38783854                            childLock.release();
    38793855                            alock.release();
    3880                             rc = aVMMALockList->Update(pMedium, true);
     3856                            hrc = aVMMALockList->Update(pMedium, true);
    38813857                            alock.acquire();
    38823858                            childLock.acquire();
    38833859                            mediumLock.acquire();
    3884                             if (FAILED(rc))
    3885                                 throw rc;
     3860                            if (FAILED(hrc))
     3861                                throw hrc;
    38863862                        }
    38873863                    }
    … …  
    38933869                childLock.release();
    38943870                alock.release();
    3895                 rc = aVMMALockList->Lock();
     3871                hrc = aVMMALockList->Lock();
    38963872                alock.acquire();
    38973873                childLock.acquire();
    3898                 if (FAILED(rc))
     3874                if (FAILED(hrc))
    38993875                {
    39003876                    aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
    3901                     rc = setError(rc,
    3902                                   tr("Cannot lock hard disk '%s' for a live merge"),
    3903                                   aHD->i_getLocationFull().c_str());
     3877                    hrc = setError(hrc,
     3878                                   tr("Cannot lock hard disk '%s' for a live merge"),
     3879                                   aHD->i_getLocationFull().c_str());
    39043880                }
    39053881                else
    … …  
    39133889            {
    39143890                aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
    3915                 rc = setError(rc,
    3916                               tr("Failed to construct lock list for a live merge of hard disk '%s'"),
    3917                               aHD->i_getLocationFull().c_str());
     3891                hrc = setError(hrc,
     3892                               tr("Failed to construct lock list for a live merge of hard disk '%s'"),
     3893                               aHD->i_getLocationFull().c_str());
    39183894            }
    39193895
    39203896            // fix the VM's lock list if anything failed
    3921             if (FAILED(rc))
     3897            if (FAILED(hrc))
    39223898            {
    39233899                lockListVMMABegin = aVMMALockList->GetBegin();
    … …  
    39433919        }
    39443920    }
    3945     else if (FAILED(rc))
     3921    else if (FAILED(hrc))
    39463922    {
    39473923        aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
    3948         rc = setError(rc,
    3949                       tr("Cannot lock hard disk '%s' when deleting a snapshot"),
    3950                       aHD->i_getLocationFull().c_str());
    3951     }
    3952 
    3953     return rc;
     3924        hrc = setError(hrc,
     3925                       tr("Cannot lock hard disk '%s' when deleting a snapshot"),
     3926                       aHD->i_getLocationFull().c_str());
     3927    }
     3928
     3929    return hrc;
    39543930}
    39553931
    … …  
    39903966            if (!aHDLockToken.isNull())
    39913967            {
    3992                 HRESULT rc = aHDLockToken->Abandon();
    3993                 AssertComRC(rc);
     3968                HRESULT hrc = aHDLockToken->Abandon();
     3969                AssertComRC(hrc);
    39943970            }
    39953971        }
    39963972        else
    39973973        {
    3998             HRESULT rc = aHD->i_unmarkForDeletion();
    3999             AssertComRC(rc);
     3974            HRESULT hrc = aHD->i_unmarkForDeletion();
     3975            AssertComRC(hrc);
    40003976        }
    40013977    }
    … …  
    40434019    {
    40444020        // reattach the source media to the snapshot
    4045         HRESULT rc = aSource->i_addBackReference(aMachineId, aSnapshotId);
    4046         AssertComRC(rc);
     4021        HRESULT hrc = aSource->i_addBackReference(aMachineId, aSnapshotId);
     4022        AssertComRC(hrc);
    40474023    }
    40484024}
    … …  
    40844060    NOREF(aChildrenToReparent);
    40854061
    4086     HRESULT rc = S_OK;
     4062    HRESULT hrc = S_OK;
    40874063
    40884064    try
    … …  
    41364112        // Must not hold any locks here, as this will call back to finish
    41374113        // updating the medium attachment, chain linking and state.
    4138         rc = directControl->OnlineMergeMedium(aMediumAttachment,
    4139                                               uSourceIdx, uTargetIdx,
    4140                                               aProgress);
    4141         if (FAILED(rc))
    4142             throw rc;
    4143     }
    4144     catch (HRESULT hrcXcpt) { rc = hrcXcpt; }
     4114        hrc = directControl->OnlineMergeMedium(aMediumAttachment, uSourceIdx, uTargetIdx, aProgress);
     4115        if (FAILED(hrc))
     4116            throw hrc;
     4117    }
     4118    catch (HRESULT hrcXcpt) { hrc = hrcXcpt; }
    41454119
    41464120    // The callback mentioned above takes care of update the medium state
    … …  
    41494123        *pfNeedsMachineSaveSettings = true;
    41504124
    4151     return rc;
     4125    return hrc;
    41524126}
    41534127
    … …  
    41644138HRESULT SessionMachine::finishOnlineMergeMedium()
    41654139{
    4166     HRESULT rc = S_OK;
     4140    HRESULT hrc = S_OK;
    41674141    MediumDeleteRec *pDeleteRec = (MediumDeleteRec *)mConsoleTaskData.mDeleteSnapshotInfo;
    41684142    AssertReturn(pDeleteRec, E_FAIL);
    … …  
    41834157        // first, unregister the target since it may become a base
    41844158        // hard disk which needs re-registration
    4185         rc = mParent->i_unregisterMedium(pDeleteRec->mpTarget);
    4186         AssertComRC(rc);
     4159        hrc = mParent->i_unregisterMedium(pDeleteRec->mpTarget);
     4160        AssertComRC(hrc);
    41874161
    41884162        // then, reparent it and disconnect the deleted branch at
    … …  
    41944168
    41954169        // then, register again
    4196         rc = mParent->i_registerMedium(pDeleteRec->mpTarget, &pDeleteRec->mpTarget, treeLock);
    4197         AssertComRC(rc);
     4170        hrc = mParent->i_registerMedium(pDeleteRec->mpTarget, &pDeleteRec->mpTarget, treeLock);
     4171        AssertComRC(hrc);
    41984172    }
    41994173    else
    … …  
    42424216    /* unregister and uninitialize all hard disks removed by the merge */
    42434217    MediumLockList *pMediumLockList = NULL;
    4244     rc = mData->mSession.mLockedMedia.Get(pDeleteRec->mpOnlineMediumAttachment, pMediumLockList);
     4218    hrc = mData->mSession.mLockedMedia.Get(pDeleteRec->mpOnlineMediumAttachment, pMediumLockList);
    42454219    const ComObjPtr<Medium> &pLast = pDeleteRec->mfMergeForward ? pDeleteRec->mpTarget : pDeleteRec->mpSource;
    4246     AssertReturn(SUCCEEDED(rc) && pMediumLockList, E_FAIL);
     4220    AssertReturn(SUCCEEDED(hrc) && pMediumLockList, E_FAIL);
    42474221    MediumLockList::Base::iterator lockListBegin =
    42484222        pMediumLockList->GetBegin();
    … …  
    42664240        else
    42674241        {
    4268             rc = mParent->i_unregisterMedium(pMedium);
    4269             AssertComRC(rc);
     4242            hrc = mParent->i_unregisterMedium(pMedium);
     4243            AssertComRC(hrc);
    42704244
    42714245            /* now, uninitialize the deleted hard disk (note that
    … …  
    42904264             * caller added by MergeChain before uninit() and updates the
    42914265             * iterator to point to the right place. */
    4292             rc = pMediumLockList->RemoveByIterator(it);
    4293             AssertComRC(rc);
     4266            hrc = pMediumLockList->RemoveByIterator(it);
     4267            AssertComRC(hrc);
    42944268
    42954269            treeLock.release();
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