Changeset 63584 in vbox

Timestamp:

Aug 18, 2016 11:48:04 AM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

110276

Message:

bugref:8482. The redundant async task implementations was eliminated in the classes MachineImpl, GuestSessionImpl, SnapshotImpl, VirtualBoxImpl.

Location:

trunk/src/VBox/Main

Files:

• include/MachineImpl.h (modified) (4 diffs)
• src-client/GuestSessionImpl.cpp (modified) (1 diff)
• src-server/MachineImpl.cpp (modified) (6 diffs)
• src-server/SnapshotImpl.cpp (modified) (6 diffs)
• src-server/VirtualBoxImpl.cpp (modified) (4 diffs)

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

@@ -39 +39 @@
 #include "Performance.h"
 #include "PerformanceImpl.h"
+#include "ThreadTask.h"
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
 
@@ -790 +791 @@
      * in here (implemented by the subclasses).
      */
-    struct Task
-    {
+    class Task : public ThreadTask
+    {
+    public:
         Task(Machine *m, Progress *p, const Utf8Str &t)
-            : m_pMachine(m),
+            : ThreadTask(t),
+              m_pMachine(m),
               m_machineCaller(m),
               m_pProgress(p),
-              m_strTaskName(t),
               m_machineStateBackup(m->mData->mMachineState) // save the current machine state
         {}
         virtual ~Task(){}
-
-        HRESULT createThread()
-        {
-            int vrc = RTThreadCreate(NULL,
-                                     taskHandler,
-                                     (void *)this,
-                                     0,
-                                     RTTHREADTYPE_MAIN_WORKER,
-                                     0,
-                                     m_strTaskName.c_str());
-            if (RT_FAILURE(vrc))
-            {
-                HRESULT rc = Machine::i_setErrorStatic(E_FAIL, Machine::tr("Could not create thread \"%s\" (%Rrc)"), m_strTaskName.c_str(), vrc);
-                delete this;
-                return rc;
-            }
-            return S_OK;
-        }
 
         void modifyBackedUpState(MachineState_T s)
@@ -824 +808 @@
         }
 
-        virtual void handler() = 0;
-
-        ComObjPtr<Machine>       m_pMachine;
+        ComObjPtr<Machine>              m_pMachine;
         AutoCaller                      m_machineCaller;
         ComObjPtr<Progress>             m_pProgress;
-        Utf8Str                         m_strTaskName;
         const MachineState_T            m_machineStateBackup;
     };
 
-    struct DeleteConfigTask;
+    class DeleteConfigTask;
     void i_deleteConfigHandler(DeleteConfigTask &task);
-
-    static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
 
     friend class SessionMachine;
@@ -1437 +1416 @@
     };
 
-    struct SaveStateTask;
-    struct SnapshotTask;
-    struct TakeSnapshotTask;
-    struct DeleteSnapshotTask;
-    struct RestoreSnapshotTask;
-
-    friend struct TakeSnapshotTask;
-    friend struct DeleteSnapshotTask;
-    friend struct RestoreSnapshotTask;
+    class SaveStateTask;
+    class SnapshotTask;
+    class TakeSnapshotTask;
+    class DeleteSnapshotTask;
+    class RestoreSnapshotTask;
 
     void i_saveStateHandler(SaveStateTask &aTask);

trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

@@ -2147 +2147 @@
 }
 
-int GuestSession::i_startTaskAsync(const Utf8Str &strTaskDesc,
-                                   GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress)
-{
-    LogFlowThisFunc(("strTaskDesc=%s, pTask=%p\n", strTaskDesc.c_str(), pTask));
-
-    AssertPtrReturn(pTask, VERR_INVALID_POINTER);
-
-    /* Create the progress object. */
-    HRESULT hr = pProgress.createObject();
-    if (FAILED(hr))
-        return VERR_COM_UNEXPECTED;
-
-    hr = pProgress->init(static_cast<IGuestSession*>(this),
-                         Bstr(strTaskDesc).raw(),
-                         TRUE /* aCancelable */);
-    if (FAILED(hr))
-        return VERR_COM_UNEXPECTED;
-
-    /* Initialize our worker task. */
-    RT_GCC_NO_WARN_DEPRECATED_BEGIN
-    std::auto_ptr<GuestSessionTask> task(pTask);
-    RT_GCC_NO_WARN_DEPRECATED_END
-    int rc = task->RunAsync(strTaskDesc, pProgress);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /* Don't destruct on success. */
-    task.release();
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
+//int GuestSession::i_startTaskAsync(const Utf8Str &strTaskDesc,
+//                                   GuestSessionTask *pTask, ComObjPtr<Progress> &pProgress)
+//{
+//    LogFlowThisFunc(("strTaskDesc=%s, pTask=%p\n", strTaskDesc.c_str(), pTask));
+//
+//    AssertPtrReturn(pTask, VERR_INVALID_POINTER);
+//
+//    /* Create the progress object. */
+//    HRESULT hr = pProgress.createObject();
+//    if (FAILED(hr))
+//        return VERR_COM_UNEXPECTED;
+//
+//    hr = pProgress->init(static_cast<IGuestSession*>(this),
+//                         Bstr(strTaskDesc).raw(),
+//                         TRUE /* aCancelable */);
+//    if (FAILED(hr))
+//        return VERR_COM_UNEXPECTED;
+//
+//    /* Initialize our worker task. */
+//    RT_GCC_NO_WARN_DEPRECATED_BEGIN
+//    std::auto_ptr<GuestSessionTask> task(pTask);
+//    RT_GCC_NO_WARN_DEPRECATED_END
+//    int rc = task->RunAsync(strTaskDesc, pProgress);
+//    if (RT_FAILURE(rc))
+//        return rc;
+//
+//    /* Don't destruct on success. */
+//    task.release();
+//
+//    LogFlowFuncLeaveRC(rc);
+//    return rc;
+//}
 
 /**

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

@@ -5256 +5256 @@
  * Task record for deleting a machine config.
  */
-struct Machine::DeleteConfigTask
+class Machine::DeleteConfigTask
     : public Machine::Task
 {
+public:
     DeleteConfigTask(Machine *m,
                      Progress *p,
@@ -5269 +5270 @@
     {}
 
+private:
     void handler()
     {
-        m_pMachine->i_deleteConfigHandler(*this);
+        try
+        {
+            m_pMachine->i_deleteConfigHandler(*this);
+        }
+        catch(...)
+        {
+            LogRel(("Some exception in the function Machine::i_deleteConfigHandler()\n"));
+        }
     }
 
     RTCList<ComPtr<IMedium> >   m_llMediums;
     StringsList                 m_llFilesToDelete;
+
+    friend void Machine::i_deleteConfigHandler(DeleteConfigTask &task);
 };
 
@@ -12846 +12857 @@
  * Task record for saving the machine state.
  */
-struct SessionMachine::SaveStateTask
+class SessionMachine::SaveStateTask
     : public Machine::Task
 {
+public:
     SaveStateTask(SessionMachine *m,
                   Progress *p,
@@ -12859 +12871 @@
     {}
 
+private:
     void handler()
     {
@@ -12866 +12879 @@
     Reason_T m_enmReason;
     Utf8Str m_strStateFilePath;
+
+    friend class SessionMachine;
 };
 
@@ -14779 +14794 @@
 
 
-/**
- * Static Machine method that can get passed to RTThreadCreate to
- * have a thread started for a Task. See Machine::Task.
- */
-/* static */ DECLCALLBACK(int) Machine::taskHandler(RTTHREAD /* thread */, void *pvUser)
-{
-    AssertReturn(pvUser, VERR_INVALID_POINTER);
-
-    Task *pTask = static_cast<Task *>(pvUser);
-    pTask->handler();
-    /** @todo r=klaus it would be safer to update the progress object here,
-     * as it avoids possible races due to scoping issues/tricks in the handler */
-    // it's our responsibility to delete the task
-    delete pTask;
-
-    return 0;
-}
-
 /*static*/
 HRESULT Machine::i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...)

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

@@ -1300 +1300 @@
  * SessionMachine::RestoreSnapshotTask and SessionMachine::DeleteSnapshotTask.
  */
-struct SessionMachine::SnapshotTask
+class SessionMachine::SnapshotTask
     : public SessionMachine::Task
 {
+public:
     SnapshotTask(SessionMachine *m,
                  Progress *p,
@@ -1315 +1316 @@
 
 /** Take snapshot task */
-struct SessionMachine::TakeSnapshotTask
+class SessionMachine::TakeSnapshotTask
     : public SessionMachine::SnapshotTask
 {
+public:
     TakeSnapshotTask(SessionMachine *m,
                      Progress *p,
@@ -1344 +1346 @@
     }
 
+private:
     void handler()
     {
-        ((SessionMachine *)(Machine *)m_pMachine)->i_takeSnapshotHandler(*this);
+        try
+        {
+            ((SessionMachine *)(Machine *)m_pMachine)->i_takeSnapshotHandler(*this);
+        }
+        catch(...)
+        {
+            LogRel(("Some exception in the function i_takeSnapshotHandler()\n"));
+        }
     }
 
@@ -1357 +1367 @@
     uint32_t m_uMemSize;
     bool m_fTakingSnapshotOnline;
+
+    friend HRESULT SessionMachine::i_finishTakingSnapshot(TakeSnapshotTask &task, AutoWriteLock &alock, bool aSuccess);
+    friend void SessionMachine::i_takeSnapshotHandler(TakeSnapshotTask &task);
+    friend void SessionMachine::i_takeSnapshotProgressCancelCallback(void *pvUser);
 };
 
 /** Restore snapshot task */
-struct SessionMachine::RestoreSnapshotTask
+class SessionMachine::RestoreSnapshotTask
     : public SessionMachine::SnapshotTask
 {
+public:
     RestoreSnapshotTask(SessionMachine *m,
                         Progress *p,
@@ -1370 +1385 @@
     {}
 
+private:
     void handler()
     {
-        ((SessionMachine *)(Machine *)m_pMachine)->i_restoreSnapshotHandler(*this);
+        try
+        {
+            ((SessionMachine *)(Machine *)m_pMachine)->i_restoreSnapshotHandler(*this);
+        }
+        catch(...)
+        {
+            LogRel(("Some exception in the function i_restoreSnapshotHandler()\n"));
+        }
     }
 };
 
 /** Delete snapshot task */
-struct SessionMachine::DeleteSnapshotTask
+class SessionMachine::DeleteSnapshotTask
     : public SessionMachine::SnapshotTask
 {
+public:
     DeleteSnapshotTask(SessionMachine *m,
                        Progress *p,
@@ -1389 +1413 @@
     {}
 
+private:
     void handler()
     {
-        ((SessionMachine *)(Machine *)m_pMachine)->i_deleteSnapshotHandler(*this);
+        try
+        {
+            ((SessionMachine *)(Machine *)m_pMachine)->i_deleteSnapshotHandler(*this);
+        }
+        catch(...)
+        {
+            LogRel(("Some exception in the function i_deleteSnapshotHandler()\n"));
+        }
     }
 
     bool m_fDeleteOnline;
+    friend void SessionMachine::i_deleteSnapshotHandler(DeleteSnapshotTask &task);
 };
 

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

@@ -81 +81 @@
 #ifdef RT_OS_WINDOWS
 # include "win/svchlp.h"
-# include "ThreadTask.h"
-# include "tchar.h"
 #endif
+
+#include "ThreadTask.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3965 +3965 @@
 }
 
-struct SaveMediaRegistriesDesc
-{
+static DECLCALLBACK(int) fntSaveMediaRegistries(RTTHREAD ThreadSelf, void *pvUser);
+
+class SaveMediaRegistriesDesc : public ThreadTask
+{
+
+public:
+    SaveMediaRegistriesDesc()
+    {
+        m_strTaskName = "SaveMediaReg";
+    }
+    virtual ~SaveMediaRegistriesDesc(void) { }
+
+private:
+    void handler()
+    {
+        try
+        {
+            fntSaveMediaRegistries(m_hThread, this);
+        }
+        catch(...)
+        {
+            LogRel(("Exception in the function fntSaveMediaRegistries()\n"));
+        }
+    }
+
     MediaList llMedia;
     ComObjPtr<VirtualBox> pVirtualBox;
+
+    friend DECLCALLBACK(int) fntSaveMediaRegistries(RTTHREAD ThreadSelf, void *pvUser);
+    friend void VirtualBox::i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
+                                                const Guid &uuidRegistry,
+                                                const Utf8Str &strMachineFolder);
 };
 
-static DECLCALLBACK(int) fntSaveMediaRegistries(RTTHREAD ThreadSelf, void *pvUser)
+DECLCALLBACK(int) fntSaveMediaRegistries(RTTHREAD ThreadSelf, void *pvUser)
 {
     NOREF(ThreadSelf);
@@ -3993 +4021 @@
     pDesc->llMedia.clear();
     pDesc->pVirtualBox.setNull();
-    delete pDesc;
 
     return VINF_SUCCESS;
@@ -4083 +4110 @@
             // lots of places which would need to handle saving more settings.
             pDesc->pVirtualBox = this;
-            int vrc = RTThreadCreate(NULL,
-                                     fntSaveMediaRegistries,
-                                     (void *)pDesc,
-                                     0,     // cbStack (default)
-                                     RTTHREADTYPE_MAIN_WORKER,
-                                     0,     // flags
-                                     "SaveMediaReg");
-            ComAssertRC(vrc);
-            // failure means that settings aren't saved, but there isn't
-            // much we can do besides avoiding memory leaks
-            if (RT_FAILURE(vrc))
+            HRESULT hr = S_OK;
+            try
             {
-                LogRelFunc(("Failed to create thread for saving media registries (%Rrc)\n", vrc));
-                delete pDesc;
+                //the function createThread() takes ownership of pDesc
+                //so there is no need to use delete operator for pDesc
+                //after calling this function
+                hr = pDesc->createThread();
+            }
+            catch(...)
+            {
+                hr = E_FAIL;
+            }
+
+            if (FAILED(hr))
+            {
+                // failure means that settings aren't saved, but there isn't
+                // much we can do besides avoiding memory leaks
+                LogRelFunc(("Failed to create thread for saving media registries (%Rhr)\n", hr));
             }
         }