Changeset 78836 in vbox for trunk

Timestamp:

May 29, 2019 7:03:20 AM (6 years ago)

Author:

vboxsync

Message:

bugref:8345. Refining and cleaning up the code.

Location:

trunk/src/VBox/Main

Files:

• include/MachineImplMoveVM.h (modified) (3 diffs)
• src-server/MachineImplMoveVM.cpp (modified) (67 diffs)

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

@@ -80 +80 @@
     };
 
-    /** @todo r=bird: Why no m_ prefixes here? */
-    RTCList<MEDIUMTASKCHAINMOVE>            llMedias;
-    RTCList<SAVESTATETASKMOVE>              llSaveStateFiles;
-    std::map<Utf8Str, MEDIUMTASKMOVE>       finalMediumsMap;
-    std::map<Utf8Str, SAVESTATETASKMOVE>    finalSaveStateFilesMap;
-    std::map<VBoxFolder_t, Utf8Str>         vmFolders;
-    std::list<ErrorInfoItem>                errorsList;
+    RTCList<MEDIUMTASKCHAINMOVE>            m_llMedias;
+    RTCList<SAVESTATETASKMOVE>              m_llSaveStateFiles;
+    std::map<Utf8Str, MEDIUMTASKMOVE>       m_finalMediumsMap;
+    std::map<Utf8Str, SAVESTATETASKMOVE>    m_finalSaveStateFilesMap;
+    std::map<VBoxFolder_t, Utf8Str>         m_vmFolders;
+    std::list<ErrorInfoItem>                m_errorsList;
 
     ComObjPtr<Machine>  m_pMachine;
@@ -95 +94 @@
     Utf8Str             m_targetPath;
     Utf8Str             m_type;
-    HRESULT             result; /**< @todo r=bird: Why no m_ prefix here?    */
+    HRESULT             m_result;
 
 public:
@@ -107 +106 @@
         , m_targetPath(aTargetPath)
         , m_type(aType.isEmpty() ? "basic" : aType)
-        , result(S_OK)
+        , m_result(S_OK)
     {
     }

trunk/src/VBox/Main/src-server/MachineImplMoveVM.cpp

@@ -30 +30 @@
 #include "LoggingNew.h"
 
-/** @todo r=klaus this file is abusing the release log by putting pretty much
- * everything there. Should be adjusted to use debug logging where appropriate
- * and if really necessary some LogRel2 and the like. */
-
-
 /* This variable is global and used in the different places so it must be cleared each time before usage to avoid failure */
 std::vector< ComObjPtr<Machine> > machineList;
@@ -137 +132 @@
     if (fLog)
     {
-        LogRelFunc(("(The error code is %Rrc): %s\n",m_code, m_description.c_str()));
+        Log2(("(The error code is %Rrc): %s\n",m_code, m_description.c_str()));
     }
     else
@@ -145 +140 @@
 HRESULT MachineMoveVM::init()
 {
-    HRESULT rc = S_OK;
-
-    errorsList.clear();
+    HRESULT hrc = S_OK;
+
+    m_errorsList.clear();
 
     Utf8Str strTargetFolder;
@@ -155 +150 @@
         if (len >= RTPATH_MAX)
         {
-            /** @todo r=bird: Why the leading space in errorDesc? */
-            /** @todo "The destination path exceeds the maximum length" should
-             *        suffice here, I think. */
-            /** @todo r=bird: missing tr(). */
-            /** @todo r=bird: Actually, why bother with these error strings here? Nobody
-             *        will ever see them, given that the caller deletes the task when
-             *        init() fails. */
-            Utf8Str errorDesc(" The destination path isn't correct. The length of path exceeded the maximum value.");
-            errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-            /** @todo r=bird: What on earth is this?  It will cause the caller to leak the
-             *        task structure, unless it's catching exception (which it wasn't, but
-             *        I made it is now).  I sure hope this wasn't intentional... */
-            throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+            return m_pMachine->setError(VBOX_E_IPRT_ERROR,
+                                        m_pMachine->tr(Utf8Str("The destination path exceeds "
+                                                               "the maximum value.").c_str()));
         }
 
@@ -199 +184 @@
         if (FAILED(vrc))
         {
-            /** @todo r=bird: What's this RTPrint doing here?!? */
-            RTPrintf("strTargetFolder is %s\n", strTargetFolder.c_str());
-            Utf8StrFmt errorDesc("Unable to move machine. Can't get the destination storage size (%s)",
-                                 strTargetFolder.c_str());
-            errorsList.push_back(ErrorInfoItem(E_FAIL, errorDesc.c_str()));
-            rc = m_pMachine->setErrorBoth(E_FAIL, vrc, m_pMachine->tr(errorDesc.c_str()));
-            throw rc;
+            return m_pMachine->setErrorBoth(E_FAIL, vrc,
+                                            m_pMachine->tr(Utf8StrFmt("Unable to move machine. Can't get "
+                                                                      "the destination storage size (%s)",
+                                                                      strTargetFolder.c_str()).c_str()));
         }
 
@@ -211 +193 @@
         Utf8Str strTempFile = strTargetFolder + "test.txt";
         vrc = RTDirOpen(&hDir, strTargetFolder.c_str());
-        if (FAILED(vrc))
-            throw rc = vrc; /** @todo r=bird: RTDirOpen returns a VBox status code. That is _not_ the same as a COM HRESULT! */
+        if (RT_FAILURE(vrc))
+            return m_pMachine->setErrorVrc(vrc);
         else
         {
             RTFILE hFile;
             vrc = RTFileOpen(&hFile, strTempFile.c_str(), RTFILE_O_OPEN_CREATE | RTFILE_O_READWRITE | RTFILE_O_DENY_NONE);
-            if (FAILED(vrc))
-            {
-                LogRelFunc(("Can't create a test file %s (The error is %Rrc)\n", strTempFile.c_str(), vrc));
-                Utf8StrFmt errorDesc("Can't create a test file test.txt in the %s. Check the access rights of "
-                                     "the destination folder.", strTargetFolder.c_str());
-                errorsList.push_back(ErrorInfoItem(HRESULT(vrc), errorDesc.c_str()));
-                rc = m_pMachine->setErrorBoth(VBOX_E_FILE_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
-                /** @todo r=bird: What happens to this error and 'rc'?  Should it be ignored? */
-            }
-
-            RTFileClose(hFile); /** @todo r=bird: Whey close if opening fail? */
+            if (RT_FAILURE(vrc))
+            {
+                return m_pMachine->setErrorVrc(vrc,
+                                               m_pMachine->tr(Utf8StrFmt("Can't create a test file test.txt in the %s. "
+                                                                         "Check the access rights of the destination "
+                                                                         "folder.", strTargetFolder.c_str()).c_str()));
+            }
+
+            /** @todo r=vvp: Do we need to check each return result here? Looks excessively.
+             *  And it's not so important for the test file. */
+            RTFileClose(hFile);
             RTFileDelete(strTempFile.c_str());
             RTDirClose(hDir);
         }
 
-        /** @todo r=bird: Why the need for 'info' here?  LogRelFunc can do the exact
-         *        same thing without touching the heap.  I don't get what this is
-         *        about...  There is also excessive log duplication here as well as
-         *        seemingly unnecessary trailing whitespace. */
-        Utf8Str info = Utf8StrFmt("blocks: total %RTfoff, free %RTfoff ", cbTotal, cbFree);
-        LogRelFunc(("%s \n", info.c_str()));
-        LogRelFunc(("total space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbTotal/_1K, cbTotal/_1M, cbTotal/_1G));
-        LogRelFunc(("total free space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbFree/_1K, cbFree/_1M, cbFree/_1G));
+        Log2(("blocks: total %RTfoff, free %RTfoff ", cbTotal, cbFree));
+        Log2(("total space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbTotal/_1K, cbTotal/_1M, cbTotal/_1G));
+        Log2(("total free space (Kb) %RTfoff (Mb) %RTfoff (Gb) %RTfoff\n", cbFree/_1K, cbFree/_1M, cbFree/_1G));
 
         RTFSPROPERTIES properties;
         vrc = RTFsQueryProperties(strTargetFolder.c_str(), &properties);
-        if (FAILED(vrc)) throw vrc;
-        info = Utf8StrFmt("disk properties:\n"
-                          "remote: %s \n"
-                          "read only: %s \n"
-                          "compressed: %s \n",
-                          properties.fRemote == true ? "true":"false",
-                          properties.fReadOnly == true ? "true":"false",
-                          properties.fCompressed == true ? "true":"false");
-
-        LogRelFunc(("%s \n", info.c_str()));
+        if (FAILED(vrc))
+            return m_pMachine->setErrorVrc(vrc);
+
+        Utf8StrFmt info ("disk properties:\n"
+                         "remote: %s \n"
+                         "read only: %s \n"
+                         "compressed: %s \n",
+                         properties.fRemote == true ? "true":"false",
+                         properties.fReadOnly == true ? "true":"false",
+                         properties.fCompressed == true ? "true":"false");
+
+        Log2(("%s \n", info.c_str()));
 
         /* Get the original VM path */
         Utf8Str strSettingsFilePath;
         Bstr bstr_settingsFilePath;
-        m_pMachine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam()); /** @todo r=bird: check the status code. */
+        hrc = m_pMachine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
+        if (FAILED(hrc))
+            return hrc;
+
         strSettingsFilePath = bstr_settingsFilePath;
         strSettingsFilePath.stripFilename();
 
-        vmFolders.insert(std::make_pair(VBox_SettingFolder, strSettingsFilePath));
+        m_vmFolders.insert(std::make_pair(VBox_SettingFolder, strSettingsFilePath));
 
         /* Collect all files from the VM's folder */
         fileList_t fullFileList;
-        rc = getFilesList(strSettingsFilePath, fullFileList);
-        if (FAILED(rc)) throw rc;
+        hrc = getFilesList(strSettingsFilePath, fullFileList);
+        if (FAILED(hrc))
+            return hrc;
 
         /*
@@ -276 +259 @@
         Utf8Str strLogFolder;
         Bstr bstr_logFolder;
-        m_pMachine->COMGETTER(LogFolder)(bstr_logFolder.asOutParam());
+        hrc = m_pMachine->COMGETTER(LogFolder)(bstr_logFolder.asOutParam());
+        if (FAILED(hrc))
+            return hrc;
+
         strLogFolder = bstr_logFolder;
         if (   m_type.equals("basic")
             && strLogFolder.contains(strSettingsFilePath))
         {
-            vmFolders.insert(std::make_pair(VBox_LogFolder, strLogFolder));
+            m_vmFolders.insert(std::make_pair(VBox_LogFolder, strLogFolder));
         }
 
@@ -287 +273 @@
         Bstr bstr_stateFilePath;
         MachineState_T machineState;
-        rc = m_pMachine->COMGETTER(State)(&machineState);
-        if (FAILED(rc)) throw rc;
+        hrc = m_pMachine->COMGETTER(State)(&machineState);
+        if (FAILED(hrc))
+             return hrc;
+
         if (machineState == MachineState_Saved)
         {
@@ -296 +284 @@
             if (   m_type.equals("basic")
                 && strStateFilePath.contains(strSettingsFilePath))
-                vmFolders.insert(std::make_pair(VBox_StateFolder, strStateFilePath));//Utf8Str(bstr_stateFilePath)));
+                m_vmFolders.insert(std::make_pair(VBox_StateFolder, strStateFilePath));
         }
 
         Utf8Str strSnapshotFolder;
         Bstr bstr_snapshotFolder;
-        m_pMachine->COMGETTER(SnapshotFolder)(bstr_snapshotFolder.asOutParam());
+        hrc = m_pMachine->COMGETTER(SnapshotFolder)(bstr_snapshotFolder.asOutParam());
+        if (FAILED(hrc))
+             return hrc;
+
         strSnapshotFolder = bstr_snapshotFolder;
         if (   m_type.equals("basic")
             && strSnapshotFolder.contains(strSettingsFilePath))
-            vmFolders.insert(std::make_pair(VBox_SnapshotFolder, strSnapshotFolder));
+            m_vmFolders.insert(std::make_pair(VBox_SnapshotFolder, strSnapshotFolder));
 
         if (m_pMachine->i_isSnapshotMachine())
         {
             Bstr bstrSrcMachineId;
-            rc = m_pMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
-            if (FAILED(rc)) throw rc;
+            hrc = m_pMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
+            if (FAILED(hrc))
+                 return hrc;
+
             ComPtr<IMachine> newSrcMachine;
-            rc = m_pMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
-            if (FAILED(rc)) throw rc;
+            hrc = m_pMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
+            if (FAILED(hrc))
+                 return hrc;
         }
 
@@ -333 +327 @@
         {
             ULONG cSnapshots = 0;
-            rc = m_pMachine->COMGETTER(SnapshotCount)(&cSnapshots);
-            if (FAILED(rc)) throw rc;
+            hrc = m_pMachine->COMGETTER(SnapshotCount)(&cSnapshots);
+            if (FAILED(hrc))
+                 return hrc;
+
             if (cSnapshots > 0)
             {
@@ -341 +337 @@
                     id = m_pMachine->i_getSnapshotId().toString();
                 ComPtr<ISnapshot> pSnapshot;
-                rc = m_pMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
-                if (FAILED(rc)) throw rc;
-                rc = createMachineList(pSnapshot, machineList);
-                if (FAILED(rc)) throw rc;
+                hrc = m_pMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
+                if (FAILED(hrc))
+                     return hrc;
+                hrc = createMachineList(pSnapshot, machineList);
+                if (FAILED(hrc))
+                     return hrc;
             }
         }
@@ -351 +349 @@
         ULONG uTotalWeight = 1;
 
-        /* The lists llMedias and llSaveStateFiles are filled in the queryMediasForAllStates() */
-        queryMediasForAllStates(machineList); /** @todo r=bird: As a rule status codes needs checking every time. */
+        /* The lists m_llMedias and m_llSaveStateFiles are filled in the queryMediasForAllStates() */
+        hrc = queryMediasForAllStates(machineList);
+        if (FAILED(hrc))
+             return hrc;
 
         {
             uint64_t totalMediumsSize = 0;
 
-            for (size_t i = 0; i < llMedias.size(); ++i)
+            for (size_t i = 0; i < m_llMedias.size(); ++i)
             {
                 LONG64  cbSize = 0;
-                MEDIUMTASKCHAINMOVE &mtc = llMedias.at(i);
+                MEDIUMTASKCHAINMOVE &mtc = m_llMedias.at(i);
                 for (size_t a = mtc.chain.size(); a > 0; --a)
                 {
@@ -367 +367 @@
                     Utf8Str name = mtc.chain[a - 1].strBaseName;
                     ComPtr<IMedium> plMedium = mtc.chain[a - 1].pMedium;
-                    rc = plMedium->COMGETTER(Location)(bstrLocation.asOutParam());
-                    if (FAILED(rc)) throw rc;
-                        strLocation = bstrLocation;
+                    hrc = plMedium->COMGETTER(Location)(bstrLocation.asOutParam());
+                    if (FAILED(hrc))
+                         return hrc;
+
+                    strLocation = bstrLocation;
 
                     /*if an image is located in the actual VM folder it will be added to the actual list */
                     if (strLocation.contains(strSettingsFilePath))
                     {
-                        rc = plMedium->COMGETTER(Size)(&cbSize);
-                        if (FAILED(rc)) throw rc;
+                        hrc = plMedium->COMGETTER(Size)(&cbSize);
+                        if (FAILED(hrc))
+                             return hrc;
 
                         std::pair<std::map<Utf8Str, MEDIUMTASKMOVE>::iterator,bool> ret;
-                        ret = finalMediumsMap.insert(std::make_pair(name, mtc.chain[a - 1]));
+                        ret = m_finalMediumsMap.insert(std::make_pair(name, mtc.chain[a - 1]));
                         if (ret.second == true)
                         {
@@ -385 +388 @@
                             uTotalWeight += mtc.chain[a - 1].uWeight;
                             totalMediumsSize += cbSize;
-                            LogRelFunc(("Image %s was added into the moved list\n", name.c_str()));
+                            Log2(("Image %s was added into the moved list\n", name.c_str()));
                         }
                     }
@@ -391 +394 @@
             }
 
-            LogRelFunc(("Total Size of images is %lld bytes\n", totalMediumsSize));
+            Log2(("Total Size of images is %lld bytes\n", totalMediumsSize));
             neededFreeSpace += totalMediumsSize;
         }
@@ -399 +402 @@
             uint64_t totalStateSize = 0;
 
-            for (size_t i = 0; i < llSaveStateFiles.size(); ++i)
+            for (size_t i = 0; i < m_llSaveStateFiles.size(); ++i)
             {
                 uint64_t cbFile = 0;
-                SAVESTATETASKMOVE &sst = llSaveStateFiles.at(i);
+                SAVESTATETASKMOVE &sst = m_llSaveStateFiles.at(i);
 
                 Utf8Str name = sst.strSaveStateFile;
@@ -412 +415 @@
                     {
                         std::pair<std::map<Utf8Str, SAVESTATETASKMOVE>::iterator,bool> ret;
-                        ret = finalSaveStateFilesMap.insert(std::make_pair(name, sst));
+                        ret = m_finalSaveStateFilesMap.insert(std::make_pair(name, sst));
                         if (ret.second == true)
                         {
@@ -418 +421 @@
                             ++uCount;
                             uTotalWeight += sst.uWeight;
-                            LogRelFunc(("The state file %s was added into the moved list\n", name.c_str()));
+                            Log2(("The state file %s was added into the moved list\n", name.c_str()));
                         }
                     }
                     else
-                        LogRelFunc(("The state file %s wasn't added into the moved list. Couldn't get the file size.\n",
-                                         name.c_str()));
+                    {
+                        Log2(("The state file %s wasn't added into the moved list. Couldn't get the file size.\n",
+                              name.c_str()));
+                        return m_pMachine->setErrorVrc(vrc);
+                    }
                 }
             }
@@ -432 +438 @@
         /* Prepare data for moving the log files */
         {
-            Utf8Str strFolder = vmFolders[VBox_LogFolder];
+            Utf8Str strFolder = m_vmFolders[VBox_LogFolder];
 
             if (RTPathExists(strFolder.c_str()))
             {
                 uint64_t totalLogSize = 0;
-                rc = getFolderSize(strFolder, totalLogSize);
-                if (SUCCEEDED(rc))
+                hrc = getFolderSize(strFolder, totalLogSize);
+                if (SUCCEEDED(hrc))
                 {
                     neededFreeSpace += totalLogSize;
                     if (cbFree - neededFreeSpace <= _1M)
                     {
-                        throw VERR_OUT_OF_RESOURCES;//less than 1Mb free space on the target location
+                        return m_pMachine->setError(VBOX_E_IPRT_ERROR,
+                                                    m_pMachine->tr(Utf8StrFmt("There is lack of disk space "
+                                                                              "(%Rrc)", VERR_OUT_OF_RESOURCES).c_str()));
                     }
 
                     fileList_t filesList;
-                    getFilesList(strFolder, filesList); /** @todo r=bird: return code check */
+                    hrc = getFilesList(strFolder, filesList);
+                    if (FAILED(hrc))
+                        return hrc;
+
                     cit_t it = filesList.m_list.begin();
                     while (it != filesList.m_list.end())
@@ -461 +472 @@
                             uTotalWeight += (ULONG)((cbFile + _1M - 1) / _1M);
                             actualFileList.add(strFile);
-                            LogRelFunc(("The log file %s added into the moved list\n", strFile.c_str()));
+                            Log2(("The log file %s added into the moved list\n", strFile.c_str()));
                         }
                         else
-                            LogRelFunc(("The log file %s wasn't added into the moved list. Couldn't get the file size."
-                                             "\n", strFile.c_str()));
+                            Log2(("The log file %s wasn't added into the moved list. "
+                                  "Couldn't get the file size.\n", strFile.c_str()));
                         ++it;
                     }
                 }
+                else
+                    return hrc;
             }
             else
             {
-                LogRelFunc(("Information: The original log folder %s doesn't exist\n", strFolder.c_str()));
-                rc = S_OK;//it's not error in this case if there isn't an original log folder
-            }
-        }
-
-        LogRelFunc(("Total space needed is %lld bytes\n", neededFreeSpace));
+                Log2(("Information: The original log folder %s doesn't exist\n", strFolder.c_str()));
+                hrc = S_OK;//it's not error in this case if there isn't an original log folder
+            }
+        }
+
+        LogRel(("Total space needed is %lld bytes\n", neededFreeSpace));
         /* Check a target location on enough room */
         if (cbFree - neededFreeSpace <= _1M)
         {
-            LogRelFunc(("but free space on destination is %RTfoff\n", cbFree));
-            /** @todo r=bird: You're throwing a VBox status code here, but only catching
-             *        HRESULT.  So, this will go to the caller or someone else up the
-             *        stack, which is unacceptable throw behaviour. */
-            throw VERR_OUT_OF_RESOURCES;//less than 1Mb free space on the target location
+            LogRel(("but free space on destination is %RTfoff\n", cbFree));
+            return m_pMachine->setError(VBOX_E_IPRT_ERROR,
+                                        m_pMachine->tr(Utf8StrFmt ("There is lack of disk space"
+                                                                   " (%Rrc)", VERR_OUT_OF_RESOURCES).c_str()));
         }
 
         /* Add step for .vbox machine setting file */
-        { /** @todo what's the scoping for? */
-            ++uCount;
-            uTotalWeight += 1;
-        }
+        ++uCount;
+        uTotalWeight += 1;
 
         /* Reserve additional steps in case of failure and rollback all changes */
-        {
-            uTotalWeight += uCount;//just add 1 for each possible rollback operation
-            uCount += uCount;//and increase the steps twice
-        }
+        uTotalWeight += uCount;//just add 1 for each possible rollback operation
+        uCount += uCount;//and increase the steps twice
 
         /* Init Progress instance */
         {
-            rc = m_pProgress->init(m_pMachine->i_getVirtualBox(),
-                                   static_cast<IMachine*>(m_pMachine) /* aInitiator */,
-                                   Utf8Str(m_pMachine->tr("Moving Machine")),
-                                   true /* fCancellable */,
-                                   uCount,
-                                   uTotalWeight,
-                                   Utf8Str(m_pMachine->tr("Initialize Moving")),
-                                   1);
-            if (FAILED(rc))
-            {
-                Utf8StrFmt errorDesc("Couldn't correctly setup the progress object for moving VM operation (%Rrc)", rc);
-                errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-
-                throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
+            hrc = m_pProgress->init(m_pMachine->i_getVirtualBox(),
+                                    static_cast<IMachine*>(m_pMachine) /* aInitiator */,
+                                    Utf8Str(m_pMachine->tr("Moving Machine")),
+                                    true /* fCancellable */,
+                                    uCount,
+                                    uTotalWeight,
+                                    Utf8Str(m_pMachine->tr("Initialize Moving")),
+                                    1);
+            if (FAILED(hrc))
+            {
+                return m_pMachine->setError(VBOX_E_IPRT_ERROR,
+                                            m_pMachine->tr(Utf8StrFmt("Couldn't correctly setup the progress "
+                                                                      "object for moving VM operation (%Rrc)", hrc).c_str()));
             }
         }
@@ -521 +528 @@
         /* save all VM data */
         m_pMachine->i_setModified(Machine::IsModified_MachineData);
-        rc = m_pMachine->SaveSettings();
-    }
-    catch(HRESULT hrc)
-    {
-/** @todo r=bird: Seriously, why throw any error when you can just return
- *        them.  This is just copying the thrown message and passing it onto
- *        the return statemnt a few lines later.  (The log statemnt doesn't
- *        really count as it doesn't log the status.) */
-        rc = hrc;
+        hrc = m_pMachine->SaveSettings();
+        if (FAILED(hrc))
+            return hrc;
+    }
+    catch(HRESULT aRc)
+    {
+        hrc = aRc;
     }
 
     LogFlowFuncLeave();
 
-    return rc;
+    return hrc;
 }
 
@@ -545 +550 @@
         {
             settings::Snapshot snap = (settings::Snapshot)(*it);
-            LogRelFunc(("snap.uuid = %s\n", snap.uuid.toStringCurly().c_str()));
-            LogRelFunc(("snap.strStateFile = %s\n", snap.strStateFile.c_str()));
+            Log2(("snap.uuid = %s\n", snap.uuid.toStringCurly().c_str()));
+            Log2(("snap.strStateFile = %s\n", snap.strStateFile.c_str()));
         }
 
@@ -593 +598 @@
 {
     LogFlowFuncEnter();
-    HRESULT rc = S_OK;
+    HRESULT hrc = S_OK;
 
     MachineMoveVM* taskMoveVM = task;
@@ -604 +609 @@
     {
         Bstr bstrMachineName;
-        machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+        hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+        if (FAILED(hrc))
+        {
+            taskMoveVM->m_result = hrc;
+            if (!taskMoveVM->m_pProgress.isNull())
+                taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->m_result);
+            return;
+        }
         strTargetFolder.append(Utf8Str(bstrMachineName));
     }
@@ -652 +664 @@
     {
         /* Move all disks */
-        rc = taskMoveVM->moveAllDisks(taskMoveVM->finalMediumsMap, &strTargetFolder);
-        if (FAILED(rc))
-            throw rc;
+        hrc = taskMoveVM->moveAllDisks(taskMoveVM->m_finalMediumsMap, &strTargetFolder);
+        if (FAILED(hrc))
+            throw hrc;
 
         /* Get Machine::Data here because moveAllDisks() change it */
@@ -675 +687 @@
             /* Check if a snapshot folder is necessary and if so doesn't already
              * exists. */
-            if (   taskMoveVM->finalSaveStateFilesMap.size() != 0
+            if (   taskMoveVM->m_finalSaveStateFilesMap.size() != 0
                 && !RTDirExists(strTrgSnapshotFolder.c_str()))
             {
@@ -682 +694 @@
                 {
                     Utf8StrFmt errorDesc("Could not create snapshots folder '%s' (%Rrc)", strTrgSnapshotFolder.c_str(), vrc);
-                    taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                    taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                     throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
@@ -688 +700 @@
             }
 
-            std::map<Utf8Str, SAVESTATETASKMOVE>::iterator itState = taskMoveVM->finalSaveStateFilesMap.begin();
-            while (itState != taskMoveVM->finalSaveStateFilesMap.end())
+            std::map<Utf8Str, SAVESTATETASKMOVE>::iterator itState = taskMoveVM->m_finalSaveStateFilesMap.begin();
+            while (itState != taskMoveVM->m_finalSaveStateFilesMap.end())
             {
                 const SAVESTATETASKMOVE &sst = itState->second;
@@ -696 +708 @@
 
                 /* Move to next sub-operation. */
-                rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy the save state file '%s' ..."),
+                hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy the save state file '%s' ..."),
                                                             RTPathFilename(sst.strSaveStateFile.c_str())).raw(), sst.uWeight);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(hrc))
+                    throw hrc;
 
                 int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0,
@@ -706 +719 @@
                     Utf8StrFmt errorDesc("Could not copy state file '%s' to '%s' (%Rrc)",
                                          sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
-                    taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                    taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                     throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
@@ -725 +738 @@
          */
         {
-            LogRelFunc(("Update state file path\n"));
-            rc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->finalSaveStateFilesMap,
-                                                     taskMoveVM->vmFolders[VBox_SettingFolder],
+            Log2(("Update state file path\n"));
+            hrc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->m_finalSaveStateFilesMap,
+                                                     taskMoveVM->m_vmFolders[VBox_SettingFolder],
                                                      strTargetFolder);
-            if (FAILED(rc))
-                throw rc;
+            if (FAILED(hrc))
+                throw hrc;
         }
 
@@ -739 +752 @@
          */
         {
-            LogRelFunc(("Copy Machine settings file \n"));
-
-            rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy Machine settings file '%s' ..."),
+            Log2(("Copy Machine settings file \n"));
+
+            hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy Machine settings file '%s' ..."),
                                                 (*machineConfFile).machineUserData.strName.c_str()).raw(), 1);
-            if (FAILED(rc)) throw rc;
+            if (FAILED(hrc))
+                throw hrc;
 
             Utf8Str strTargetSettingsFilePath = strTargetFolder;
@@ -755 +769 @@
                     Utf8StrFmt errorDesc("Could not create a home machine folder '%s' (%Rrc)",
                                          strTargetSettingsFilePath.c_str(), vrc);
-                    taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                    taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                     throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                 }
-                LogRelFunc(("Created a home machine folder %s\n", strTargetSettingsFilePath.c_str()));
+                Log2(("Created a home machine folder %s\n", strTargetSettingsFilePath.c_str()));
             }
 
@@ -765 +779 @@
             Bstr bstrMachineName;
             machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+            if (FAILED(hrc))
+                throw hrc;
             strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName));
             strTargetSettingsFilePath.append(".vbox");
@@ -771 +787 @@
             Bstr bstr_settingsFilePath;
             machine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
+            if (FAILED(hrc))
+                throw hrc;
             strSettingsFilePath = bstr_settingsFilePath;
 
@@ -779 +797 @@
                 Utf8StrFmt errorDesc("Could not copy the setting file '%s' to '%s' (%Rrc)",
                                      strSettingsFilePath.c_str(), strTargetSettingsFilePath.stripFilename().c_str(), vrc);
-                taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                 throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
             }
 
-            LogRelFunc(("The setting file %s has been copied into the folder %s\n", strSettingsFilePath.c_str(),
+            Log2(("The setting file %s has been copied into the folder %s\n", strSettingsFilePath.c_str(),
                         strTargetSettingsFilePath.stripFilename().c_str()));
 
@@ -795 +813 @@
         /* Moving Machine log files */
         {
-            LogRelFunc(("Copy machine log files \n"));
-
-            if (taskMoveVM->vmFolders[VBox_LogFolder].isNotEmpty())
+            Log2(("Copy machine log files \n"));
+
+            if (taskMoveVM->m_vmFolders[VBox_LogFolder].isNotEmpty())
             {
                 /* Check an original log folder existence */
-                if (RTDirExists(taskMoveVM->vmFolders[VBox_LogFolder].c_str()))
+                if (RTDirExists(taskMoveVM->m_vmFolders[VBox_LogFolder].c_str()))
                 {
                     Utf8Str strTargetLogFolderPath = strTargetFolder;
@@ -813 +831 @@
                             Utf8StrFmt errorDesc("Could not create log folder '%s' (%Rrc)",
                                                  strTargetLogFolderPath.c_str(), vrc);
-                            taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                            taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                             throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                         }
-                        LogRelFunc(("Created a log machine folder %s\n", strTargetLogFolderPath.c_str()));
+                        Log2(("Created a log machine folder %s\n", strTargetLogFolderPath.c_str()));
                     }
 
                     fileList_t filesList;
-                    taskMoveVM->getFilesList(taskMoveVM->vmFolders[VBox_LogFolder], filesList);
+                    taskMoveVM->getFilesList(taskMoveVM->m_vmFolders[VBox_LogFolder], filesList);
                     cit_t it = filesList.m_list.begin();
                     while(it != filesList.m_list.end())
@@ -832 +850 @@
 
                         /* Move to next sub-operation. */
-                        rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copying the log file '%s' ..."),
+                        hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copying the log file '%s' ..."),
                                                                                RTPathFilename(strFullSourceFilePath.c_str())).raw(),
                                                                        1);
-                        if (FAILED(rc)) throw rc;
+                        if (FAILED(hrc))
+                            throw hrc;
 
                         int vrc = RTFileCopyEx(strFullSourceFilePath.c_str(), strFullTargetFilePath.c_str(), 0,
@@ -845 +864 @@
                                                  strFullTargetFilePath.stripFilename().c_str(),
                                                  vrc);
-                            taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+                            taskMoveVM->m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
                             throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
                         }
 
-                        LogRelFunc(("The log file %s has been copied into the folder %s\n", strFullSourceFilePath.c_str(),
-                                    strFullTargetFilePath.stripFilename().c_str()));
+                        Log2(("The log file %s has been copied into the folder %s\n", strFullSourceFilePath.c_str(),
+                              strFullTargetFilePath.stripFilename().c_str()));
 
                         /* save new file in case of restoring */
@@ -865 +884 @@
 
         /* save all VM data */
-        {
-            rc = machine->SaveSettings();
-        }
-
-        {
-            LogRelFunc(("Update path to XML setting file\n"));
+        hrc = machine->SaveSettings();
+        if (FAILED(hrc))
+            throw hrc;
+
+        {
+            Log2(("Update path to XML setting file\n"));
             Utf8Str strTargetSettingsFilePath = strTargetFolder;
             Bstr bstrMachineName;
-            machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+            hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+            if (FAILED(hrc))
+                throw hrc;
             strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
             machineData->m_strConfigFileFull = strTargetSettingsFilePath;
@@ -888 +909 @@
             AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
 
-            rc = machine->mParent->i_saveSettings();
-        }
-    }
-    catch(HRESULT hrc)
-    {
-        LogRelFunc(("Moving machine to a new destination was failed. Check original and destination places.\n"));
-        rc = hrc;
-        taskMoveVM->result = rc;
+            hrc = machine->mParent->i_saveSettings();
+            if (FAILED(hrc))
+                throw hrc;
+        }
+    }
+    catch(HRESULT aRc)
+    {
+        hrc = aRc;
+        taskMoveVM->m_result = hrc;
     }
     catch (...)
     {
-        LogRelFunc(("Moving machine to a new destination was failed. Check original and destination places.\n"));
-        rc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
-        taskMoveVM->result = rc;
+        Log2(("Moving machine to a new destination was failed. Check original and destination places.\n"));
+        hrc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
+        taskMoveVM->m_result = hrc;
     }
 
     /* Cleanup on failure */
-    if (FAILED(rc))
+    if (FAILED(hrc))
     {
         Machine::Data *machineData = machine->mData.data();
-
-        /* ! Apparently we should update the Progress object !*/
-        ULONG operationCount = 0;
-        rc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
-        ULONG operation = 0;
-        rc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
-        Bstr bstrOperationDescription;
-        rc = taskMoveVM->m_pProgress->COMGETTER(OperationDescription)(bstrOperationDescription.asOutParam());
-        Utf8Str strOperationDescription = bstrOperationDescription;
-        ULONG operationPercent = 0;
-        rc = taskMoveVM->m_pProgress->COMGETTER(OperationPercent)(&operationPercent);
-
-        Bstr bstrMachineName;
-        machine->COMGETTER(Name)(bstrMachineName.asOutParam());
-        LogRelFunc(("Moving machine %s was failed on operation %s\n",
-                    Utf8Str(bstrMachineName.raw()).c_str(), Utf8Str(bstrOperationDescription.raw()).c_str()));
 
         /* Restoring the original mediums */
@@ -940 +946 @@
              * Thus we start from "operation + 1" and finish when "i < operationCount - operation".
              */
+
+            /** @todo r=vvp: Do we need to check each return result here? Looks excessively
+             *  and what to do with any failure here? We are already in the rollback action.
+             *  Throw only the important errors?
+             *  We MUST finish this action anyway to avoid garbage and get the original VM state. */
+            /* ! Apparently we should update the Progress object !*/
+            ULONG operationCount = 0;
+            hrc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
+            if (FAILED(hrc))
+                throw hrc;
+            ULONG operation = 0;
+            hrc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
+            if (FAILED(hrc))
+                throw hrc;
+            Bstr bstrOperationDescription;
+            hrc = taskMoveVM->m_pProgress->COMGETTER(OperationDescription)(bstrOperationDescription.asOutParam());
+            if (FAILED(hrc))
+                throw hrc;
+            Utf8Str strOperationDescription = bstrOperationDescription;
+            ULONG operationPercent = 0;
+            hrc = taskMoveVM->m_pProgress->COMGETTER(OperationPercent)(&operationPercent);
+            if (FAILED(hrc))
+                throw hrc;
+            Bstr bstrMachineName;
+            hrc = machine->COMGETTER(Name)(bstrMachineName.asOutParam());
+            if (FAILED(hrc))
+                throw hrc;
+
+            Log2(("Moving machine %s was failed on operation %s\n",
+                  Utf8Str(bstrMachineName.raw()).c_str(), Utf8Str(bstrOperationDescription.raw()).c_str()));
+
             for (ULONG i = operation + 1; i < operationCount - operation; ++i)
-            {
-                rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i + 1).raw(), 1);
-                if (FAILED(rc)) throw rc;
-            }
-
-            rc = taskMoveVM->moveAllDisks(taskMoveVM->finalMediumsMap);
-            if (FAILED(rc))
-                throw rc;
-        }
-        catch(HRESULT hrc)
-        {
-            LogRelFunc(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
-            taskMoveVM->result = hrc;
+                taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i + 1).raw(), 1);
+
+            hrc = taskMoveVM->moveAllDisks(taskMoveVM->m_finalMediumsMap);
+            if (FAILED(hrc))
+                throw hrc;
+
+            /* Revert original paths to the state files */
+            {
+                hrc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->m_finalSaveStateFilesMap,
+                                                          strTargetFolder,
+                                                          taskMoveVM->m_vmFolders[VBox_SettingFolder]);
+                if (FAILED(hrc))
+                {
+                    Log2(("Rollback scenario: can't restore the original paths to the state files. "
+                          "Machine settings %s can be corrupted.\n", machineData->m_strConfigFileFull.c_str()));
+                    throw hrc;
+                }
+            }
+
+            /* Delete all created files. Here we update progress object */
+            hrc = taskMoveVM->deleteFiles(newFiles);
+            if (FAILED(hrc))
+            {
+                Log2(("Rollback scenario: can't delete new created files. Check the destination folder."));
+                throw hrc;
+            }
+
+            /* Delete destination folder */
+            int vrc = RTDirRemove(strTargetFolder.c_str());
+            if (RT_FAILURE(vrc))
+            {
+                Log2(("Rollback scenario: can't delete new destination folder."));
+                throw machine->setErrorVrc(vrc, "Rollback scenario: can't delete new destination folder.");
+            }
+
+            /* save all VM data */
+            {
+                AutoWriteLock  srcLock(machine COMMA_LOCKVAL_SRC_POS);
+                srcLock.release();
+                hrc = machine->SaveSettings();
+                if (FAILED(hrc))
+                {
+                    Log2(("Rollback scenario: can't save machine settings."));
+                    throw hrc;
+                }
+                srcLock.acquire();
+            }
+
+            /* Restore an original path to XML setting file */
+            {
+                Log2(("Rollback scenario: restoration of the original path to XML setting file\n"));
+                Utf8Str strOriginalSettingsFilePath = taskMoveVM->m_vmFolders[VBox_SettingFolder];
+                strOriginalSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
+                machineData->m_strConfigFileFull = strOriginalSettingsFilePath;
+                machine->mParent->i_copyPathRelativeToConfig(strOriginalSettingsFilePath, machineData->m_strConfigFile);
+            }
+
+            /* Marks the global registry for uuid as modified */
+            {
+                AutoWriteLock  srcLock(machine COMMA_LOCKVAL_SRC_POS);
+                srcLock.release();
+                Guid uuid = machine->mData->mUuid;
+                machine->mParent->i_markRegistryModified(uuid);
+                srcLock.acquire();
+            }
+
+            /* save the global settings; for that we should hold only the VirtualBox lock */
+            {
+                AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
+                hrc = machine->mParent->i_saveSettings();
+                if (FAILED(hrc))
+                {
+                    Log2(("Rollback scenario: can't save global settings."));
+                    throw hrc;
+                }
+            }
+        }
+        catch(HRESULT aRc)
+        {
+            Log2(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
+            taskMoveVM->m_result = aRc;
         }
         catch (...)
         {
-            LogRelFunc(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
-            rc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
-            taskMoveVM->result = rc;
-        }
-
-        /* Revert original paths to the state files */
-        rc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->finalSaveStateFilesMap,
-                                                 strTargetFolder,
-                                                 taskMoveVM->vmFolders[VBox_SettingFolder]);
-        if (FAILED(rc))
-        {
-            LogRelFunc(("Rollback scenario: can't restore the original paths to the state files. "
-                        "Machine settings %s can be corrupted.\n", machineData->m_strConfigFileFull.c_str()));
-        }
-
-        /* Delete all created files. Here we update progress object */
-        rc = taskMoveVM->deleteFiles(newFiles);
-        if (FAILED(rc))
-            LogRelFunc(("Rollback scenario: can't delete new created files. Check the destination folder."));
-
-        /* Delete destination folder */
-        RTDirRemove(strTargetFolder.c_str());
-
-        /* save all VM data */
-        {
-            AutoWriteLock  srcLock(machine COMMA_LOCKVAL_SRC_POS);
-            srcLock.release();
-            rc = machine->SaveSettings();
-            srcLock.acquire();
-        }
-
-        /* Restore an original path to XML setting file */
-        {
-            LogRelFunc(("Rollback scenario: restoration of the original path to XML setting file\n"));
-            Utf8Str strOriginalSettingsFilePath = taskMoveVM->vmFolders[VBox_SettingFolder];
-            strOriginalSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
-            machineData->m_strConfigFileFull = strOriginalSettingsFilePath;
-            machine->mParent->i_copyPathRelativeToConfig(strOriginalSettingsFilePath, machineData->m_strConfigFile);
-        }
-
-        /* Marks the global registry for uuid as modified */
-        {
-            AutoWriteLock  srcLock(machine COMMA_LOCKVAL_SRC_POS);
-            srcLock.release();
-            Guid uuid = machine->mData->mUuid;
-            machine->mParent->i_markRegistryModified(uuid);
-            srcLock.acquire();
-        }
-
-        /* save the global settings; for that we should hold only the VirtualBox lock */
-        {
-            AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
-            rc = machine->mParent->i_saveSettings();
-        }
-
+            Log2(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
+            hrc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
+            taskMoveVM->m_result = hrc;
+        }
         /* In case of failure the progress object on the other side (user side) get notification about operation
            completion but the operation percentage may not be set to 100% */
@@ -1022 +1076 @@
          * because we doubled the number of operations for rollback case.
          * But if we want to update the progress object corectly it's needed to add all medium moved by standard
-         * "move medium" logic (for us it's taskMoveVM->finalMediumsMap) to the current number of operation.
+         * "move medium" logic (for us it's taskMoveVM->m_finalMediumsMap) to the current number of operation.
          */
 
         ULONG operationCount = 0;
-        rc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
+        hrc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
         ULONG operation = 0;
-        rc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
-
-        for (ULONG i = operation; i < operation + taskMoveVM->finalMediumsMap.size() - 1; ++i)
-        {
-            rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i).raw(), 1);
-            if (FAILED(rc)) throw rc; /** @todo r=bird: Who exactly should be catching this? Our caller is
-                                       * ThreadTask::taskHandlerThreadProc and it doesn't catch anything, nor does the
-                                       * IPRT. */
-        }
-
-        rc = taskMoveVM->deleteFiles(originalFiles);
-        if (FAILED(rc))
-            LogRelFunc(("Forward scenario: can't delete all original files.\n"));
+        hrc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
+
+        for (ULONG i = operation; i < operation + taskMoveVM->m_finalMediumsMap.size() - 1; ++i)
+            taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i).raw(), 1);
+
+        hrc = taskMoveVM->deleteFiles(originalFiles);
+        if (FAILED(hrc))
+            Log2(("Forward scenario: can't delete all original files.\n"));
     }
 
@@ -1046 +1095 @@
     {
         /* Set the first error happened */
-        if (!taskMoveVM->errorsList.empty())
-        {
-            ErrorInfoItem ei = taskMoveVM->errorsList.front();
+        if (!taskMoveVM->m_errorsList.empty())
+        {
+            ErrorInfoItem ei = taskMoveVM->m_errorsList.front();
             machine->setError(ei.m_code, machine->tr(ei.m_description.c_str()));
         }
 
-        taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->result);
+        taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->m_result);
     }
 
@@ -1088 +1137 @@
 
                 if (mt.fSnapshot == true)
-                {
                     strLocation.stripFilename().stripPath().append(RTPATH_DELIMITER).append(Utf8Str(bstrSrcName));
-                }
                 else
-                {
                     strLocation.stripPath();
-                }
 
                 strTargetImageName.append(RTPATH_DELIMITER).append(strLocation);
@@ -1148 +1193 @@
                 com::ErrorInfoKeeper eik;
                 Utf8Str errorDesc(eik.getText().raw());
-                errorsList.push_back(ErrorInfoItem(eik.getResultCode(), errorDesc.c_str()));
+                m_errorsList.push_back(ErrorInfoItem(eik.getResultCode(), errorDesc.c_str()));
             }
 
             if (FAILED(rc)) throw rc;
 
-            LogRelFunc(("Moving %s has been finished\n", strTargetImageName.c_str()));
+            Log2(("Moving %s has been finished\n", strTargetImageName.c_str()));
 
             ++itMedium;
@@ -1162 +1207 @@
     catch(HRESULT hrc)
     {
-        LogRelFunc(("\nException during moving the disk %s\n", strLocation.c_str()));
+        Log2(("\nException during moving the disk %s\n", strLocation.c_str()));
         rc = hrc;
         machineLock.release();
@@ -1168 +1213 @@
     catch (...)
     {
-        LogRelFunc(("\nException during moving the disk %s\n", strLocation.c_str()));
+        Log2(("\nException during moving the disk %s\n", strLocation.c_str()));
         rc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
         machineLock.release();
@@ -1176 +1221 @@
     {
         Utf8StrFmt errorDesc("Exception during moving the disk %s\n", strLocation.c_str());
-        errorsList.push_back(ErrorInfoItem(rc, errorDesc.c_str()));
+        m_errorsList.push_back(ErrorInfoItem(rc, errorDesc.c_str()));
     }
 
@@ -1228 +1273 @@
 {
     RTDIR hDir;
-    HRESULT rc = S_OK;
+    HRESULT hrc = S_OK;
     int vrc = RTDirOpen(&hDir, strRootFolder.c_str());
     if (RT_SUCCESS(vrc))
@@ -1247 +1292 @@
                 Utf8Str strNextFolder(strRootFolder);
                 strNextFolder.append(RTPATH_DELIMITER).append(DirEntry.szName);
-                rc = getFilesList(strNextFolder, filesList);
-                if (FAILED(rc))
+                hrc = getFilesList(strNextFolder, filesList);
+                if (FAILED(hrc))
                     break;
             }
@@ -1259 +1304 @@
     {
         Utf8StrFmt errorDesc("Folder '%s' doesn't exist (%Rrc)", strRootFolder.c_str(), vrc);
-        errorsList.push_back(ErrorInfoItem(VERR_FILE_NOT_FOUND, errorDesc.c_str()));
-
-        rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
+        m_errorsList.push_back(ErrorInfoItem(VERR_FILE_NOT_FOUND, errorDesc.c_str()));
+
+        hrc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
     }
     else
     {
         Utf8StrFmt errorDesc("Could not open folder '%s' (%Rrc)", strRootFolder.c_str(), vrc);
-        errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-
-/** @todo r=bird: document this throwing business, please!  Error handling is
- *        a bit fishy here.  See also */
-        throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
-    }
-
-    return rc;
+        m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+
+        hrc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
+    }
+
+    return hrc;
 }
 
 HRESULT MachineMoveVM::deleteFiles(const RTCList<Utf8Str>& listOfFiles)
 {
-    HRESULT rc = S_OK;
+    HRESULT hrc = S_OK;
     /* Delete all created files. */
     try
@@ -1284 +1327 @@
         for (size_t i = 0; i < listOfFiles.size(); ++i)
         {
-            LogRelFunc(("Deleting file %s ...\n", listOfFiles.at(i).c_str()));
-            rc = m_pProgress->SetNextOperation(BstrFmt("Deleting file %s...", listOfFiles.at(i).c_str()).raw(), 1);
-            if (FAILED(rc)) throw rc;
+            Log2(("Deleting file %s ...\n", listOfFiles.at(i).c_str()));
+            hrc = m_pProgress->SetNextOperation(BstrFmt("Deleting file %s...", listOfFiles.at(i).c_str()).raw(), 1);
+            if (FAILED(hrc)) throw hrc;
 
             int vrc = RTFileDelete(listOfFiles.at(i).c_str());
             if (RT_FAILURE(vrc))
             {
-                Utf8StrFmt errorDesc("Could not delete file '%s' (%Rrc)", listOfFiles.at(i).c_str(), rc);
-                errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-
-                rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
+                Utf8StrFmt errorDesc("Could not delete file '%s' (%Rrc)", listOfFiles.at(i).c_str(), hrc);
+                m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+
+                throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
             }
             else
-                LogRelFunc(("File %s has been deleted\n", listOfFiles.at(i).c_str()));
-        }
-    }
-    catch(HRESULT hrc)
-    {
-        rc = hrc;
+                Log2(("File %s has been deleted\n", listOfFiles.at(i).c_str()));
+        }
+    }
+    catch(HRESULT aRc)
+    {
+        hrc = aRc;
     }
     catch (...)
     {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
-    }
-
-    return rc;
+        hrc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
+    }
+
+    return hrc;
 }
 
 HRESULT MachineMoveVM::getFolderSize(const Utf8Str& strRootFolder, uint64_t& size)
 {
-    HRESULT rc = S_OK;
+    HRESULT hrc = S_OK;
     int vrc = 0;
     uint64_t totalFolderSize = 0;
@@ -1322 +1365 @@
     if (ex == true)
     {
-        rc = getFilesList(strRootFolder, filesList);
-        if (SUCCEEDED(rc))
+        hrc = getFilesList(strRootFolder, filesList);
+        if (SUCCEEDED(hrc))
         {
             cit_t it = filesList.m_list.begin();
@@ -1339 +1382 @@
                 {
                     Utf8StrFmt errorDesc("Could not get the size of file '%s' (%Rrc)", fullPath.c_str(), vrc);
-                    errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-
-                    throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
+                    m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+
+                    return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
                 }
                 ++it;
@@ -1348 +1391 @@
             size = totalFolderSize;
         }
-        else
-        {
-/** @todo r=bird: This only happens if RTDirOpen fails.  So, I'm not sure
- * what you're going for here... See not about throwing in getFilesList(). */
-            Utf8StrFmt errorDesc("Could not calculate the size of folder '%s'", strRootFolder.c_str());
-            errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
-
-            m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
-        }
     }
     else
         size = 0;
 
-    return rc;
+    return hrc;
 }
 
@@ -1433 +1467 @@
             Bstr bstrLocation;
             rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
-            if (FAILED(rc)) throw rc;
+            if (FAILED(rc)) return rc;
 
             /* Cast to ComObjPtr<Medium> */
@@ -1439 +1473 @@
 
             /*Check for "read-only" medium in terms that VBox can't create this one */
-            bool fPass = isMediumTypeSupportedForMoving(pMedium);
-            if(!fPass)
-            {
-                LogRelFunc(("Skipping file %s because of this medium type hasn't been supported for moving.\n",
-                         Utf8Str(bstrLocation.raw()).c_str()));
-                continue;
+            try
+            {
+                bool fPass = isMediumTypeSupportedForMoving(pMedium);
+                if(!fPass)
+                {
+                    Log2(("Skipping file %s because of this medium type hasn't been supported for moving.\n",
+                          Utf8Str(bstrLocation.raw()).c_str()));
+                    continue;
+                }
+            } catch (HRESULT aRc)
+            {
+                return aRc;
             }
 
@@ -1465 +1505 @@
                 MediumType_T mediumType;//immutable, shared, passthrough
                 rc = pMedium->COMGETTER(Type)(&mediumType);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc)) return rc;
 
                 rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc)) return rc;
 
                 MEDIUMTASKMOVE mt;// = {false, "basename", NULL, 0, 0};
                 mt.strBaseName = bstrLocation;
-                Utf8Str strFolder = vmFolders[VBox_SnapshotFolder];
+                Utf8Str strFolder = m_vmFolders[VBox_SnapshotFolder];
                 if (strFolder.isNotEmpty() && mt.strBaseName.contains(strFolder))
                 {
@@ -1490 +1530 @@
             }
 
-            llMedias.append(mtc);
+            m_llMedias.append(mtc);
         }
         /* Add the save state files of this machine if there is one. */
@@ -1500 +1540 @@
      * that in the previous loop, cause there we go from child -> parent and
      * didn't know how many are between. */
-    for (size_t i = 0; i < llMedias.size(); ++i)
+    for (size_t i = 0; i < m_llMedias.size(); ++i)
     {
         uint32_t uIdx = 0;
-        MEDIUMTASKCHAINMOVE &mtc = llMedias.at(i);
+        MEDIUMTASKCHAINMOVE &mtc = m_llMedias.at(i);
         for (size_t a = mtc.chain.size(); a > 0; --a)
             mtc.chain[a - 1].uIdx = uIdx++;
@@ -1528 +1568 @@
         {
             Utf8StrFmt errorDesc("Could not get file size of '%s' (%Rrc)", sst.strSaveStateFile.c_str(), vrc);
-            errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
+            m_errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
 
             return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
@@ -1535 +1575 @@
          * be read and written */
         sst.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
-        llSaveStateFiles.append(sst);
+        m_llSaveStateFiles.append(sst);
     }
     return S_OK;
@@ -1605 +1645 @@
     if (formatName.compare("VHDX", Utf8Str::CaseInsensitive) == 0)
     {
-        LogRelFunc(("Skipping medium %s. VHDX format is supported in \"read-only\" mode only. \n",
-                    Utf8Str(bstrLocation.raw()).c_str()));
+        Log2(("Skipping medium %s. VHDX format is supported in \"read-only\" mode only. \n",
+              Utf8Str(bstrLocation.raw()).c_str()));
         fSupported = false;
     }
@@ -1617 +1657 @@
         if (!fSupported)
         {
-            LogRelFunc(("Skipping medium %s because it's not a real file on the disk.\n",
-                        Utf8Str(bstrLocation.raw()).c_str()));
+            Log2(("Skipping medium %s because it's not a real file on the disk.\n",
+                  Utf8Str(bstrLocation.raw()).c_str()));
         }
     }
@@ -1631 +1671 @@
         if (fIso == false)
         {
-            LogRelFunc(("Skipping file %s. Only ISO images are supported for now.\n",
-                         Utf8Str(bstrLocation.raw()).c_str()));
+            Log2(("Skipping file %s. Only ISO images are supported for now.\n",
+                  Utf8Str(bstrLocation.raw()).c_str()));
             fSupported = false;
         }