Changeset 58519 in vbox for trunk

Timestamp:

Oct 30, 2015 8:17:19 AM (9 years ago)

Author:

vboxsync

Message:

pr7179. DnD part has been changed.

Location:

trunk/src/VBox/Main

Files:

• include/GuestDnDSourceImpl.h (modified) (1 diff)
• include/GuestDnDTargetImpl.h (modified) (1 diff)
• include/ThreadTask.h (modified) (2 diffs)
• src-all/ThreadTask.cpp (modified) (2 diffs)
• src-client/GuestDnDSourceImpl.cpp (modified) (6 diffs)
• src-client/GuestDnDTargetImpl.cpp (modified) (6 diffs)

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

@@ -110 +110 @@
         RECVDATACTX mRecvCtx;
     } mData;
+
+    friend class RecvDataTask;
 };
 

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

@@ -102 +102 @@
         uint32_t mcbBlockSize;
     } mData;
+
+    friend class SendDataTask;
 };
 

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

@@ -20 +20 @@
 #include "VBox/com/string.h"
 
+struct ThreadVoidData
+{
+public:
+    ThreadVoidData(){};
+    virtual ~ThreadVoidData(){};
+};
+
 class ThreadTask
 {
 public:
-    ThreadTask(const Utf8Str &t) : m_strTaskName(t){};
+    ThreadTask(const Utf8Str &t) : m_pThread(NULL), m_strTaskName(t){};
     virtual ~ThreadTask(){};
-    HRESULT createThread();
+    HRESULT createThread(PRTTHREAD pThread = NULL, RTTHREADTYPE enmType = RTTHREADTYPE_MAIN_WORKER);
     virtual void handler() = 0;
     static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
-    static HRESULT i_setErrorStatic(HRESULT aResultCode, const Utf8Str &aText);
+    static HRESULT setErrorStatic(HRESULT aResultCode, const Utf8Str &aText);
 
     inline Utf8Str getTaskName() const {return m_strTaskName;};
@@ -34 +41 @@
 protected:
     ThreadTask():m_strTaskName("GenericTask"){};
+    PRTTHREAD m_pThread;
     Utf8Str m_strTaskName;
 };

trunk/src/VBox/Main/src-all/ThreadTask.cpp

@@ -20 +20 @@
 #include "ThreadTask.h"
 
-HRESULT ThreadTask::createThread()
+HRESULT ThreadTask::createThread(PRTTHREAD pThread, RTTHREADTYPE enmType)
 {
     HRESULT rc = S_OK;
     try
     {
-        int vrc = RTThreadCreate(NULL,
+        m_pThread = pThread;
+        int vrc = RTThreadCreate(m_pThread,
                                  taskHandler,
                                  (void *)this,
                                  0,
-                                 RTTHREADTYPE_MAIN_WORKER,
+                                 enmType,
                                  0,
                                  this->getTaskName().c_str());
@@ -89 +90 @@
 }
 
-/*static*/ HRESULT ThreadTask::i_setErrorStatic(HRESULT aResultCode,
+/*static*/ HRESULT ThreadTask::setErrorStatic(HRESULT aResultCode,
                                     const Utf8Str &aText)
 {

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

@@ -27 +27 @@
 #include "Global.h"
 #include "AutoCaller.h"
+#include "ThreadTask.h"
 
 #include <iprt/asm.h>
@@ -47 +48 @@
  * Base class for a source task.
  */
-class GuestDnDSourceTask
+class GuestDnDSourceTask : public ThreadTask
 {
 public:
 
     GuestDnDSourceTask(GuestDnDSource *pSource)
-        : mSource(pSource),
-          mRC(VINF_SUCCESS) { }
+        : ThreadTask("GenericGuestDnDSourceTask")
+        , mSource(pSource)
+        , mRC(VINF_SUCCESS) { }
 
     virtual ~GuestDnDSourceTask(void) { }
@@ -77 +79 @@
     RecvDataTask(GuestDnDSource *pSource, PRECVDATACTX pCtx)
         : GuestDnDSourceTask(pSource)
-        , mpCtx(pCtx) { }
+        , mpCtx(pCtx)
+    {
+        m_strTaskName = "dndSrcRcvData";
+    }
+
+    void handler()
+    {
+        int vrc = GuestDnDSource::i_receiveDataThread(*m_pThread, this);
+    }
 
     virtual ~RecvDataTask(void) { }
@@ -347 +357 @@
         return hr;
 
+    RecvDataTask *pTask = NULL;
+    RTTHREAD threadRcv;
+    int rc = S_OK;
+
     try
     {
@@ -357 +371 @@
         LogRel2(("DnD: Requesting data from guest in format: %s\n", aFormat.c_str()));
 
-        RecvDataTask *pTask = new RecvDataTask(this, &mData.mRecvCtx);
-        AssertReturn(pTask->isOk(), pTask->getRC());
-
-        LogFlowFunc(("Starting thread ...\n"));
-
-        RTTHREAD threadRcv;
-        int rc = RTThreadCreate(&threadRcv, GuestDnDSource::i_receiveDataThread,
-                                (void *)pTask, 0, RTTHREADTYPE_MAIN_WORKER, 0, "dndSrcRcvData");
+        pTask = new RecvDataTask(this, &mData.mRecvCtx);
+        if (!pTask->isOk())
+        {
+            delete pTask;
+            LogRel2(("DnD: Could not create RecvDataTask object \n"));
+            throw hr = E_FAIL;
+        }
+
+        //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
+        hr = pTask->createThread(&threadRcv);
+
+    }
+    catch(std::bad_alloc &)
+    {
+        hr = setError(E_OUTOFMEMORY);
+    }
+    catch(...)
+    {
+        LogRel2(("DnD: Could not create thread for RecvDataTask \n"));
+        hr = E_FAIL;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        rc = RTThreadUserWait(threadRcv, 30 * 1000 /* 30s timeout */);
         if (RT_SUCCESS(rc))
         {
-            rc = RTThreadUserWait(threadRcv, 30 * 1000 /* 30s timeout */);
-            if (RT_SUCCESS(rc))
-            {
-                mDataBase.m_cTransfersPending++;
-
-                hr = pResp->queryProgressTo(aProgress.asOutParam());
-                ComAssertComRC(hr);
-
-                /* Note: pTask is now owned by the worker thread. */
-            }
-            else
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Waiting for receiving thread failed (%Rrc)"), rc);
+            mDataBase.m_cTransfersPending++;
+
+            hr = pResp->queryProgressTo(aProgress.asOutParam());
+            ComAssertComRC(hr);
+
+            /* Note: pTask is now owned by the worker thread. */
         }
         else
-            hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread failed (%Rrc)"), rc);
-
-        if (FAILED(hr))
-            delete pTask;
-    }
-    catch(std::bad_alloc &)
-    {
-        hr = setError(E_OUTOFMEMORY);
-    }
+            hr = setError(VBOX_E_IPRT_ERROR, tr("Waiting for receiving thread failed (%Rrc)"), rc);
+    }
+    else
+        hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread for GuestDnDSource::i_receiveDataThread failed (%Rrc)"), rc);
+    /* Note: mDataBase.mfTransferIsPending will be set to false again by i_receiveDataThread. */
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));
@@ -1005 +1026 @@
     rc = pThis->i_receiveData(pTask->getCtx(), RT_INDEFINITE_WAIT /* msTimeout */);
 
-    if (pTask)
-        delete pTask;
-
     AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
 

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

@@ -26 +26 @@
 #include "Global.h"
 #include "AutoCaller.h"
+#include "ThreadTask.h"
 
 #include <algorithm>        /* For std::find(). */
@@ -51 +52 @@
  * Base class for a target task.
  */
-class GuestDnDTargetTask
+class GuestDnDTargetTask : public ThreadTask
 {
 public:
 
     GuestDnDTargetTask(GuestDnDTarget *pTarget)
-        : mTarget(pTarget),
-          mRC(VINF_SUCCESS) { }
+        : ThreadTask("GenericGuestDnDTargetTask")
+        , mTarget(pTarget)
+        , mRC(VINF_SUCCESS) { }
 
     virtual ~GuestDnDTargetTask(void) { }
@@ -81 +83 @@
     SendDataTask(GuestDnDTarget *pTarget, PSENDDATACTX pCtx)
         : GuestDnDTargetTask(pTarget),
-          mpCtx(pCtx) { }
+          mpCtx(pCtx)
+    {
+        m_strTaskName = "dndTgtSndData";
+    }
+
+    void handler()
+    {
+        int vrc = GuestDnDTarget::i_sendDataThread(*m_pThread, this);
+    }
 
     virtual ~SendDataTask(void)
@@ -564 +574 @@
 
     rc = pThis->i_sendData(pTask->getCtx(), RT_INDEFINITE_WAIT /* msTimeout */);
-
-    if (pTask)
-        delete pTask;
 
     AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
@@ -617 +624 @@
         return hr;
 
+    SendDataTask *pTask = NULL;
+    PSENDDATACTX pSendCtx = NULL;
+    RTTHREAD threadSnd;
+    int rc = S_OK;
+
     try
     {
-        PSENDDATACTX pSendCtx = new SENDDATACTX;
+        //pSendCtx is passed into SendDataTask where one is deleted in destructor
+        pSendCtx = new SENDDATACTX;
         RT_BZERO(pSendCtx, sizeof(SENDDATACTX));
 
@@ -626 +639 @@
         pSendCtx->mScreenID     = aScreenId;
         pSendCtx->mFmtReq       = aFormat;
-
         pSendCtx->mData.getMeta().add(aData);
 
-        SendDataTask *pTask = new SendDataTask(this, pSendCtx);
-        AssertReturn(pTask->isOk(), pTask->getRC());
-
-        LogFlowFunc(("Starting thread ...\n"));
-
-        RTTHREAD threadSnd;
-        int rc = RTThreadCreate(&threadSnd, GuestDnDTarget::i_sendDataThread,
-                                (void *)pTask, 0, RTTHREADTYPE_MAIN_WORKER, 0, "dndTgtSndData");
+        /* pTask is responsible for deletion of pSendCtx after creating */
+        pTask = new SendDataTask(this, pSendCtx);
+        if (!pTask->isOk())
+        {
+            delete pTask;
+            LogRel2(("DnD: Could not create SendDataTask object \n"));
+            throw hr = E_FAIL;
+        }
+
+        //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
+        //pSendCtx is deleted in the pTask destructor
+        hr = pTask->createThread(&threadSnd);
+
+    }
+    catch(std::bad_alloc &)
+    {
+        hr = setError(E_OUTOFMEMORY);
+    }
+    catch(...)
+    {
+        LogRel2(("DnD: Could not create thread for SendDataTask \n"));
+        hr = E_FAIL;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        rc = RTThreadUserWait(threadSnd, 30 * 1000 /* 30s timeout */);
         if (RT_SUCCESS(rc))
         {
-            rc = RTThreadUserWait(threadSnd, 30 * 1000 /* 30s timeout */);
-            if (RT_SUCCESS(rc))
-            {
-                mDataBase.m_cTransfersPending++;
-
-                hr = pResp->queryProgressTo(aProgress.asOutParam());
-                ComAssertComRC(hr);
-
-                /* Note: pTask is now owned by the worker thread. */
-            }
-            else
-                hr = setError(VBOX_E_IPRT_ERROR, tr("Waiting for sending thread failed (%Rrc)"), rc);
+            mDataBase.m_cTransfersPending++;
+
+            hr = pResp->queryProgressTo(aProgress.asOutParam());
+            ComAssertComRC(hr);
+
+            /* Note: pTask is now owned by the worker thread. */
         }
         else
-            hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread failed (%Rrc)"), rc);
-
-        if (FAILED(hr))
-            delete pSendCtx;
-    }
-    catch(std::bad_alloc &)
-    {
-        hr = setError(E_OUTOFMEMORY);
-    }
+            hr = setError(VBOX_E_IPRT_ERROR, tr("Waiting for sending thread failed (%Rrc)"), rc);
+    }
+    else
+        hr = setError(VBOX_E_IPRT_ERROR, tr("Starting thread for GuestDnDTarget::i_sendDataThread (%Rrc)"), rc);
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));