Changeset 85537 in vbox for trunk

Timestamp:

Jul 30, 2020 6:55:32 AM (4 years ago)

Author:

vboxsync

Message:

DnD/Main: More fixes and cleanups.

Location:

trunk/src/VBox/Main

Files:

• include/GuestDnDPrivate.h (modified) (18 diffs)
• include/GuestDnDSourceImpl.h (modified) (2 diffs)
• include/GuestDnDTargetImpl.h (modified) (3 diffs)
• src-client/ConsoleImpl2.cpp (modified) (1 diff)
• src-client/GuestDnDPrivate.cpp (modified) (11 diffs)
• src-client/GuestDnDSourceImpl.cpp (modified) (29 diffs)
• src-client/GuestDnDTargetImpl.cpp (modified) (25 diffs)

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

@@ -89 +89 @@
         : pvData(NULL)
         , cbData(0)
-        , cbAllocated(0) { }
+        , cbAllocated(0)
+        , cbAnnounced(0) { }
 
     virtual ~GuestDnDMetaData(void)
@@ -98 +99 @@
     size_t add(const void *pvDataAdd, size_t cbDataAdd)
     {
-        LogFlowThisFunc(("pvDataAdd=%p, cbDataAdd=%zu\n", pvDataAdd, cbDataAdd));
-
+        LogFlowThisFunc(("cbAllocated=%zu, cbAnnounced=%zu, pvDataAdd=%p, cbDataAdd=%zu\n",
+                         cbAllocated, cbAnnounced, pvDataAdd, cbDataAdd));
         if (!cbDataAdd)
             return 0;
         AssertPtrReturn(pvDataAdd, 0);
 
-        int rc = resize(cbAllocated + cbDataAdd);
-        if (RT_FAILURE(rc))
-            return 0;
+        const size_t cbAllocatedTmp = cbData + cbDataAdd;
+        if (cbAllocatedTmp > cbAllocated)
+        {
+            int rc = resize(cbAllocatedTmp);
+            if (RT_FAILURE(rc))
+                return 0;
+        }
 
         Assert(cbAllocated >= cbData + cbDataAdd);
@@ -138 +143 @@
         }
 
+        cbData      = 0;
         cbAllocated = 0;
-        cbData      = 0;
+        cbAnnounced = 0;
     }
 
@@ -154 +160 @@
 
         if (cbSize > _32M) /* Meta data can be up to 32MB. */
-            return VERR_INVALID_PARAMETER;
+            return VERR_BUFFER_OVERFLOW;
 
         void *pvTmp = NULL;
@@ -160 +166 @@
         {
             Assert(cbData == 0);
-            pvTmp = RTMemAllocZ(cbSize);
+            pvTmp = RTMemAllocZ(RT_ALIGN_Z(cbSize, 4096));
         }
         else
         {
             AssertPtr(pvData);
-            pvTmp = RTMemRealloc(pvData, cbSize);
+            pvTmp = RTMemRealloc(pvData, RT_ALIGN_Z(cbSize, 4096));
             RT_BZERO(pvTmp, cbSize);
         }
@@ -187 +193 @@
     /** Size (in bytes) of allocated meta data. */
     size_t       cbAllocated;
+    /** Size (in bytes) of announced meta data. */
+    size_t       cbAnnounced;
 };
 
@@ -205 +213 @@
     size_t addProcessed(size_t cbDataAdd)
     {
-        const size_t cbTotal = Meta.cbData + cbExtra; RT_NOREF(cbTotal);
+        const size_t cbTotal = getTotalAnnounced(); RT_NOREF(cbTotal);
         AssertReturn(cbProcessed + cbDataAdd <= cbTotal, 0);
         cbProcessed += cbDataAdd;
@@ -213 +221 @@
     bool isComplete(void) const
     {
-        const size_t cbTotal = Meta.cbData + cbExtra;
+        const size_t cbTotal = getTotalAnnounced();
         LogFlowFunc(("cbProcessed=%zu, cbTotal=%zu\n", cbProcessed, cbTotal));
         AssertReturn(cbProcessed <= cbTotal, true);
@@ -221 +229 @@
     uint8_t getPercentComplete(void) const
     {
-        const size_t cbTotal = Meta.cbData + cbExtra;
+        const size_t cbTotal = getTotalAnnounced();
         return (uint8_t)(cbProcessed * 100 / RT_MAX(cbTotal, 1));
     }
@@ -227 +235 @@
     size_t getRemaining(void) const
     {
-        const size_t cbTotal = Meta.cbData + cbExtra;
+        const size_t cbTotal = getTotalAnnounced();
         AssertReturn(cbProcessed <= cbTotal, 0);
         return cbTotal - cbProcessed;
     }
 
-    size_t getTotal(void) const
+    size_t getTotalAnnounced(void) const
+    {
+        return Meta.cbAnnounced + cbExtra;
+    }
+
+    size_t getTotalAvailable(void) const
     {
         return Meta.cbData + cbExtra;
@@ -373 +386 @@
 struct GuestDnDSendCtx : public GuestDnDData
 {
+    GuestDnDSendCtx(void);
+
+    void reset(void);
+
     /** Pointer to guest target class this context belongs to. */
     GuestDnDTarget                     *pTarget;
     /** Pointer to guest response class this context belongs to. */
     GuestDnDResponse                   *pResp;
-    /** Flag indicating whether a file transfer is active and
-     *  initiated by the host. */
-    bool                                fIsActive;
     /** Target (VM) screen ID. */
     uint32_t                            uScreenID;
@@ -440 +454 @@
 struct GuestDnDRecvCtx : public GuestDnDData
 {
+    GuestDnDRecvCtx(void);
+
+    void reset(void);
+
     /** Pointer to guest source class this context belongs to. */
     GuestDnDSource                     *pSource;
     /** Pointer to guest response class this context belongs to. */
     GuestDnDResponse                   *pResp;
-    /** Flag indicating whether a file transfer is active and
-     *  initiated by the host. */
-    bool                                fIsActive;
     /** Formats offered by the guest (and supported by the host). */
     GuestDnDMIMEList                    lstFmtOffered;
@@ -693 +708 @@
 
 /**
- * Private singleton class for the guest's DnD
- * implementation. Can't be instanciated directly, only via
- * the factory pattern.
+ * Private singleton class for the guest's DnD implementation.
  *
- ** @todo Move this into GuestDnDBase.
+ * Can't be instanciated directly, only via the factory pattern.
+ * Keeps track of all ongoing DnD transfers.
  */
 class GuestDnD
@@ -727 +741 @@
 protected:
 
+    /** List of registered DnD sources. */
+    typedef std::list< ComObjPtr<GuestDnDSource> > GuestDnDSrcList;
+    /** List of registered DnD targets. */
+    typedef std::list< ComObjPtr<GuestDnDTarget> > GuestDnDTgtList;
+
+    /** Constructor; will throw rc on failure. */
     GuestDnD(const ComObjPtr<Guest>& pGuest);
     virtual ~GuestDnD(void);
@@ -738 +758 @@
     GuestDnDResponse *response(void) { return m_pResponse; }
     GuestDnDMIMEList  defaultFormats(void) const { return m_strDefaultFormats; }
+    /** @}  */
+
+    /** @name Source / target management. */
+    int               registerSource(const ComObjPtr<GuestDnDSource> &Source);
+    int               unregisterSource(const ComObjPtr<GuestDnDSource> &Source);
+    size_t            getSourceCount(void);
+
+    int               registerTarget(const ComObjPtr<GuestDnDTarget> &Target);
+    int               unregisterTarget(const ComObjPtr<GuestDnDTarget> &Target);
+    size_t            getTargetCount(void);
     /** @}  */
 
@@ -765 +795 @@
      * @{ */
     /** List of supported default MIME/Content-type formats. */
-    GuestDnDMIMEList           m_strDefaultFormats;
+    GuestDnDMIMEList            m_strDefaultFormats;
     /** Pointer to guest implementation. */
-    const ComObjPtr<Guest>     m_pGuest;
+    const ComObjPtr<Guest>      m_pGuest;
     /** The current (last) response from the guest. At the
      *  moment we only support only response a time (ARQ-style). */
-    GuestDnDResponse          *m_pResponse;
+    GuestDnDResponse           *m_pResponse;
+    /** Critical section to serialize access. */
+    RTCRITSECT                  m_CritSect;
+    /** Number of active transfers (guest->host or host->guest). */
+    uint32_t                    m_cTransfersPending;
+    GuestDnDSrcList             m_lstSrc;
+    GuestDnDTgtList             m_lstTgt;
     /** @}  */
 
 private:
 
-    /** Staic pointer to singleton instance. */
+    /** Static pointer to singleton instance. */
     static GuestDnD           *s_pInstance;
 };
 
 /** Access to the GuestDnD's singleton instance. */
-#define GUESTDNDINST() GuestDnD::getInstance()
+#define GuestDnDInst() GuestDnD::getInstance()
 
 /** List of pointers to guest DnD Messages. */
@@ -833 +869 @@
     /** List of offered MIME types to the counterpart. */
     GuestDnDMIMEList                m_lstFmtOffered;
+    /** Whether the object still is in pending state. */
+    bool                            m_fIsPending;
     /** @}  */
 
@@ -840 +878 @@
     struct
     {
-        /** Number of active transfers (guest->host or host->guest). */
-        uint32_t                    cTransfersPending;
         /** The DnD protocol version to use, depending on the
          *  installed Guest Additions. See DragAndDropSvc.h for

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

@@ -70 +70 @@
 protected:
 
+    void i_reset(void);
+
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
     /** @name Dispatch handlers for the HGCM callbacks.
@@ -85 +87 @@
     static Utf8Str i_guestErrorToString(int guestRc);
     static Utf8Str i_hostErrorToString(int hostRc);
-
-    /** @name Thread task .
-     * @{ */
-    static void i_receiveDataThreadTask(GuestDnDRecvDataTask *pTask);
-    /** @}  */
 
     /** @name Callbacks for dispatch handler.

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

@@ -74 +74 @@
     static Utf8Str i_hostErrorToString(int hostRc);
 
-    /** @name Thread task workers.
-     * @{ */
-    static void i_sendDataThreadTask(GuestDnDSendDataTask *pTask);
-    /** @}  */
-
     /** @name Callbacks for dispatch handler.
      * @{ */
@@ -85 +80 @@
 
 protected:
+
+    void i_reset(void);
 
     int i_sendData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
@@ -104 +101 @@
     struct
     {
-        /** Flag indicating whether a data transfer currently is active. */
-        bool     mfTransferIsPending;
         /** Maximum data block size (in bytes) the target can handle. */
-        uint32_t mcbBlockSize;
+        uint32_t        mcbBlockSize;
+        /** The context for sending data to the guest.
+         *  At the moment only one transfer at a time is supported. */
+        GuestDnDSendCtx mSendCtx;
     } mData;
 

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

@@ -3186 +3186 @@
                 rc = HGCMHostRegisterServiceExtension(&m_hHgcmSvcExtDragAndDrop, "VBoxDragAndDropSvc",
                                                       &GuestDnD::notifyDnDDispatcher,
-                                                      GUESTDNDINST());
+                                                      GuestDnDInst());
                 if (RT_FAILURE(rc))
                     Log(("Cannot register VBoxDragAndDropSvc extension, rc=%Rrc\n", rc));

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

@@ -156 +156 @@
  */
 
+
+/********************************************************************************************************************************
+ *
+ ********************************************************************************************************************************/
+
+#define GUESTDND_LOCK() \
+    { \
+        int rcLock = RTCritSectEnter(&m_CritSect); \
+        if (RT_FAILURE(rcLock)) \
+            return rcLock; \
+    }
+
+#define GUESTDND_LOCK_RET(a_Ret) \
+    { \
+        int rcLock = RTCritSectEnter(&m_CritSect); \
+        if (RT_FAILURE(rcLock)) \
+            return a_Ret; \
+    }
+
+#define GUESTDND_UNLOCK() \
+    { \
+        int rcUnlock = RTCritSectLeave(&m_CritSect); RT_NOREF(rcUnlock); \
+        AssertRC(rcUnlock); \
+    }
+
+/********************************************************************************************************************************
+ *
+ ********************************************************************************************************************************/
+
+GuestDnDSendCtx::GuestDnDSendCtx(void)
+    : pTarget(NULL)
+    , pResp(NULL)
+{
+    reset();
+}
+
+void GuestDnDSendCtx::reset(void)
+{
+    if (pResp)
+        pResp->reset();
+
+    uScreenID  = 0;
+
+    Transfer.reset();
+
+    int rc2 = EventCallback.Reset();
+    AssertRC(rc2);
+
+    GuestDnDData::reset();
+}
+
+/*********************************************************************************************************************************
+ *                                                                                                                               *
+ ********************************************************************************************************************************/
+
+GuestDnDRecvCtx::GuestDnDRecvCtx(void)
+    : pSource(NULL)
+    , pResp(NULL)
+{
+    reset();
+}
+
+void GuestDnDRecvCtx::reset(void)
+{
+    if (pResp)
+        pResp->reset();
+
+    lstFmtOffered.clear();
+    strFmtReq  = "";
+    strFmtRecv = "";
+    enmAction  = 0;
+
+    Transfer.reset();
+
+    int rc2 = EventCallback.Reset();
+    AssertRC(rc2);
+
+    GuestDnDData::reset();
+}
+
+/*********************************************************************************************************************************
+ *                                                                                                                               *
+ ********************************************************************************************************************************/
+
 GuestDnDCallbackEvent::~GuestDnDCallbackEvent(void)
 {
@@ -184 +268 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////
+/********************************************************************************************************************************
+ *
+ ********************************************************************************************************************************/
 
 GuestDnDResponse::GuestDnDResponse(const ComObjPtr<Guest>& pGuest)
@@ -523 +609 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////
+/*********************************************************************************************************************************
+ *                                                                                                                               *
+ ********************************************************************************************************************************/
 
 GuestDnD* GuestDnD::s_pInstance = NULL;
@@ -529 +617 @@
 GuestDnD::GuestDnD(const ComObjPtr<Guest> &pGuest)
     : m_pGuest(pGuest)
+    , m_cTransfersPending(0)
 {
     LogFlowFuncEnter();
 
-    m_pResponse = new GuestDnDResponse(pGuest);
+    try
+    {
+        m_pResponse = new GuestDnDResponse(pGuest);
+    }
+    catch (std::bad_alloc &)
+    {
+        throw VERR_NO_MEMORY;
+    }
+
+    int rc = RTCritSectInit(&m_CritSect);
+    if (RT_FAILURE(rc))
+        throw rc;
 
     /* List of supported default MIME types. */
@@ -547 +647 @@
 {
     LogFlowFuncEnter();
+
+    Assert(m_cTransfersPending == 0); /* Sanity. */
+
+    RTCritSectDelete(&m_CritSect);
 
     if (m_pResponse)
@@ -596 +700 @@
 }
 
+int GuestDnD::registerSource(const ComObjPtr<GuestDnDSource> &Source)
+{
+    GUESTDND_LOCK();
+
+    Assert(m_lstSrc.size() == 0); /* We only support one source at a time at the moment. */
+    m_lstSrc.push_back(Source);
+
+    GUESTDND_UNLOCK();
+    return VINF_SUCCESS;
+}
+
+int GuestDnD::unregisterSource(const ComObjPtr<GuestDnDSource> &Source)
+{
+    GUESTDND_LOCK();
+
+    GuestDnDSrcList::iterator itSrc = std::find(m_lstSrc.begin(), m_lstSrc.end(), Source);
+    if (itSrc != m_lstSrc.end())
+        m_lstSrc.erase(itSrc);
+
+    GUESTDND_UNLOCK();
+    return VINF_SUCCESS;
+}
+
+size_t GuestDnD::getSourceCount(void)
+{
+    GUESTDND_LOCK_RET(0);
+
+    size_t cSources = m_lstSrc.size();
+
+    GUESTDND_UNLOCK();
+    return cSources;
+}
+
+int GuestDnD::registerTarget(const ComObjPtr<GuestDnDTarget> &Target)
+{
+    GUESTDND_LOCK();
+
+    Assert(m_lstTgt.size() == 0); /* We only support one target at a time at the moment. */
+    m_lstTgt.push_back(Target);
+
+    GUESTDND_UNLOCK();
+    return VINF_SUCCESS;
+}
+
+int GuestDnD::unregisterTarget(const ComObjPtr<GuestDnDTarget> &Target)
+{
+    GUESTDND_LOCK();
+
+    GuestDnDTgtList::iterator itTgt = std::find(m_lstTgt.begin(), m_lstTgt.end(), Target);
+    if (itTgt != m_lstTgt.end())
+        m_lstTgt.erase(itTgt);
+
+    GUESTDND_UNLOCK();
+    return VINF_SUCCESS;
+}
+
+size_t GuestDnD::getTargetCount(void)
+{
+    GUESTDND_LOCK_RET(0);
+
+    size_t cTargets = m_lstTgt.size();
+
+    GUESTDND_UNLOCK();
+    return cTargets;
+}
+
 /* static */
 DECLCALLBACK(int) GuestDnD::notifyDnDDispatcher(void *pvExtension, uint32_t u32Function,
@@ -626 +796 @@
 {
     GuestDnDMIMEList lstFormats;
-    RTCList<RTCString> lstFormatsTmp = strFormats.split("\r\n");
+    RTCList<RTCString> lstFormatsTmp = strFormats.split(DND_FORMATS_SEPARATOR);
 
     for (size_t i = 0; i < lstFormatsTmp.size(); i++)
@@ -641 +811 @@
     {
         const com::Utf8Str &f = lstFormats.at(i);
-        strFormat += f + "\r\n";
+        strFormat += f + DND_FORMATS_SEPARATOR;
     }
 
@@ -670 +840 @@
     GuestDnDMIMEList lstFmt;
 
-    RTCList<RTCString> lstFormats = strFormatsWanted.split("\r\n");
+    RTCList<RTCString> lstFormats = strFormatsWanted.split(DND_FORMATS_SEPARATOR);
     size_t i = 0;
     while (i < lstFormats.size())
@@ -775 +945 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////
+/*********************************************************************************************************************************
+ *                                                                                                                               *
+ ********************************************************************************************************************************/
 
 GuestDnDBase::GuestDnDBase(void)
+    : m_fIsPending(false)
 {
     /* Initialize public attributes. */
-    m_lstFmtSupported = GUESTDNDINST()->defaultFormats();
+    m_lstFmtSupported = GuestDnDInst()->defaultFormats();
 
     /* Initialzie private stuff. */
-    m_DataBase.cTransfersPending = 0;
     m_DataBase.uProtocolVersion  = 0;
 }
@@ -943 +1115 @@
         Msg.setNextUInt32(0); /** @todo ContextID not used yet. */
 
-    LogRel2(("DnD: Cancelling operation on guest ..."));
-
-    return GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+    LogRel2(("DnD: Cancelling operation on guest ...\n"));
+
+    int rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+    if (RT_FAILURE(rc))
+        LogRel(("DnD: Cancelling operation on guest failed with %Rrc\n", rc));
+
+    return rc;
 }
 

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

@@ -59 +59 @@
     int getRC(void) const { return mRC; }
     bool isOk(void) const { return RT_SUCCESS(mRC); }
-    const ComObjPtr<GuestDnDSource> &getSource(void) const { return mSource; }
 
 protected:
@@ -84 +83 @@
     void handler()
     {
-        GuestDnDSource::i_receiveDataThreadTask(this);
+        LogFlowThisFunc(("\n"));
+
+        const ComObjPtr<GuestDnDSource> pThis(mSource);
+        Assert(!pThis.isNull());
+
+        AutoCaller autoCaller(pThis);
+        if (FAILED(autoCaller.rc()))
+            return;
+
+        int vrc = pThis->i_receiveData(mpCtx, RT_INDEFINITE_WAIT /* msTimeout */);
+        if (RT_FAILURE(vrc)) /* In case we missed some error handling within i_receiveData(). */
+        {
+            if (vrc != VERR_CANCELLED)
+                LogRel(("DnD: Receiving data from guest failed with %Rrc\n", vrc));
+
+            /* Make sure to fire a cancel request to the guest side in case something went wrong. */
+            pThis->sendCancel();
+        }
     }
 
     virtual ~GuestDnDRecvDataTask(void) { }
-
-    GuestDnDRecvCtx *getCtx(void) { return mpCtx; }
 
 protected:
@@ -266 +280 @@
     Msg.setNextUInt32(uScreenId);
 
-    int rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+    int rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
     if (RT_SUCCESS(rc))
     {
-        GuestDnDResponse *pResp = GUESTDNDINST()->response();
+        GuestDnDResponse *pResp = GuestDnDInst()->response();
         AssertPtr(pResp);
 
@@ -337 +351 @@
         return setError(E_INVALIDARG, tr("Specified format '%s' is not supported"), aFormat.c_str());
 
+    /* Check that the given action is supported by us. */
     VBOXDNDACTION dndAction = GuestDnD::toHGCMAction(aAction);
     if (isDnDIgnoreAction(dndAction)) /* If there is no usable action, ignore this request. */
@@ -343 +358 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
+    /* Check if this object still is in a pending state and bail out if so. */
+    if (m_fIsPending)
+        return setError(E_FAIL, tr("Current drop operation to host still in progress"));
+
+    /* Reset our internal state. */
+    i_reset();
+
     /* At the moment we only support one transfer at a time. */
-    if (m_DataBase.cTransfersPending)
-        return setError(E_INVALIDARG, tr("Another drop operation already is in progress"));
-
-    /* Dito. */
-    GuestDnDResponse *pResp = GUESTDNDINST()->response();
+    if (GuestDnDInst()->getSourceCount())
+        return setError(E_INVALIDARG, tr("Another drag and drop operation to the host already is in progress"));
+
+    /* Reset progress object. */
+    GuestDnDResponse *pResp = GuestDnDInst()->response();
     AssertPtr(pResp);
-
     HRESULT hr = pResp->resetProgress(m_pGuest);
     if (FAILED(hr))
@@ -359 +380 @@
     try
     {
-        mData.mRecvCtx.fIsActive     = false;
         mData.mRecvCtx.pSource       = this;
         mData.mRecvCtx.pResp         = pResp;
+        mData.mRecvCtx.enmAction     = dndAction;
         mData.mRecvCtx.strFmtReq     = aFormat;
         mData.mRecvCtx.lstFmtOffered = m_lstFmtOffered;
 
-        LogRel2(("DnD: Requesting data from guest in format: %s\n", aFormat.c_str()));
+        LogRel2(("DnD: Requesting data from guest in format '%s'\n", aFormat.c_str()));
 
         pTask = new GuestDnDRecvDataTask(this, &mData.mRecvCtx);
@@ -371 +392 @@
         {
             delete pTask;
-            LogRel2(("DnD: Could not create RecvDataTask object \n"));
+            LogRel2(("DnD: Receive data task failed to initialize\n"));
             throw hr = E_FAIL;
         }
@@ -395 +416 @@
     if (SUCCEEDED(hr))
     {
-        /* Re-acquire write lock. */
-        alock.acquire();
-
-        m_DataBase.cTransfersPending++;
+        /* Register ourselves at the DnD manager. */
+        GuestDnDInst()->registerSource(this);
 
         hr = pResp->queryProgressTo(aProgress.asOutParam());
@@ -405 +424 @@
     }
     else
-        hr = setError(hr, tr("Starting thread for GuestDnDSource::i_receiveDataThread failed (%Rhrc)"), hr);
-    /* Note: m_DataBase.mfTransferIsPending will be set to false again by i_receiveDataThread. */
+        hr = setError(hr, tr("Starting thread for GuestDnDSource failed (%Rhrc)"), hr);
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));
@@ -422 +440 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    LogFlowThisFunc(("cTransfersPending=%RU32\n", m_DataBase.cTransfersPending));
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     /* Don't allow receiving the actual data until our current transfer is complete. */
-    if (m_DataBase.cTransfersPending)
-        return setError(E_FAIL, tr("Current drop operation still in progress"));
+    if (m_fIsPending)
+        return setError(E_FAIL, tr("Current drop operation to host still in progress"));
 
     HRESULT hr = S_OK;
@@ -442 +458 @@
             AssertPtr(pcszDropDirAbs);
 
-            LogRel2(("DnD: Using drop directory '%s'\n", pcszDropDirAbs));
-
-            char  *pszBuf;
-            size_t cbBuf;
-            int rc = DnDTransferListGetRootsEx(&pCtx->Transfer.List, DNDTRANSFERLISTFMT_NATIVE,
-                                               pcszDropDirAbs, "\n" /* On all platforms */, &pszBuf, &cbBuf);
+            LogRel2(("DnD: Using drop directory '%s', got %RU64 root entries\n",
+                     pcszDropDirAbs, DnDTransferListGetRootCount(&pCtx->Transfer.List)));
+
+            /* We return the data as "text/uri-list" MIME data here. */
+            char  *pszBuf = NULL;
+            size_t cbBuf  = 0;
+            int rc = DnDTransferListGetRootsEx(&pCtx->Transfer.List, DNDTRANSFERLISTFMT_URI,
+                                               pcszDropDirAbs, DND_PATH_SEPARATOR, &pszBuf, &cbBuf);
             if (RT_SUCCESS(rc))
             {
+                Assert(cbBuf);
+                AssertPtr(pszBuf);
+
                 aData.resize(cbBuf);
                 memcpy(&aData.front(), pszBuf, cbBuf);
@@ -457 +478 @@
                 LogRel(("DnD: Unable to build source root list, rc=%Rrc\n", rc));
         }
-        else
+        else /* Raw data. */
         {
             if (pCtx->Meta.cbData)
@@ -558 +579 @@
 }
 
+void GuestDnDSource::i_reset(void)
+{
+    LogFlowThisFunc(("\n"));
+
+    mData.mRecvCtx.reset();
+
+    m_fIsPending = false;
+
+    /* Unregister ourselves from the DnD manager. */
+    GuestDnDInst()->unregisterSource(this);
+}
+
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
+
 /**
  * Handles receiving a send data header from the guest.
@@ -576 +610 @@
     AssertReturn(pDataHdr->cbTotal >= pDataHdr->cbMeta, VERR_INVALID_PARAMETER);
 
-    int rc = pCtx->Meta.resize(pDataHdr->cbMeta);
-    AssertRCReturn(rc, rc);
-
-    pCtx->cbExtra = pDataHdr->cbTotal - pDataHdr->cbMeta;
+    pCtx->Meta.cbAnnounced = pDataHdr->cbMeta;
+    pCtx->cbExtra          = pDataHdr->cbTotal - pDataHdr->cbMeta;
 
     Assert(pCtx->Transfer.cObjToProcess == 0); /* Sanity. */
@@ -615 +647 @@
         size_t  cbData;
         void   *pvData;
-        size_t  cbTotal;
-        size_t  cbMeta;
+        size_t  cbTotalAnnounced;
+        size_t  cbMetaAnnounced;
 
         if (m_DataBase.uProtocolVersion < 3)
@@ -624 +656 @@
 
             /* Sends the total data size to receive for every data chunk. */
-            cbTotal = pSndData->u.v1.cbTotalSize;
+            cbTotalAnnounced = pSndData->u.v1.cbTotalSize;
 
             /* Meta data size always is cbData, meaning there cannot be an
              * extended data chunk transfer by sending further data. */
-            cbMeta  = cbData;
+            cbMetaAnnounced  = cbData;
         }
         else
@@ -637 +669 @@
             /* Note: Data sizes get initialized in i_onReceiveDataHdr().
              *       So just use the set values here. */
-            cbTotal = pCtx->getTotal();
-            cbMeta  = pCtx->Meta.cbData;
-        }
-
-        if (   cbData == 0
-            || cbData > cbTotal /* Paranoia */)
-        {
-            LogFlowFunc(("Incoming data size invalid: cbData=%zu, cbToProcess=%zu\n", cbData, cbTotal));
+            cbTotalAnnounced = pCtx->getTotalAnnounced();
+            cbMetaAnnounced  = pCtx->Meta.cbAnnounced;
+        }
+
+        if (cbData > cbTotalAnnounced)
+        {
+            AssertMsgFailed(("Incoming data size invalid: cbData=%zu, cbTotal=%zu\n", cbData, cbTotalAnnounced));
             rc = VERR_INVALID_PARAMETER;
         }
-        else if (   cbTotal == 0
-                 || cbTotal  < cbMeta)
-        {
-            AssertMsgFailed(("cbTotal (%zu) is smaller than cbMeta (%zu)\n", cbTotal, cbMeta));
+        else if (   cbTotalAnnounced == 0
+                 || cbTotalAnnounced  < cbMetaAnnounced)
+        {
+            AssertMsgFailed(("cbTotal (%zu) is smaller than cbMeta (%zu)\n", cbTotalAnnounced, cbMetaAnnounced));
             rc = VERR_INVALID_PARAMETER;
         }
@@ -659 +690 @@
         AssertReturn(cbData <= mData.mcbBlockSize, VERR_BUFFER_OVERFLOW);
 
-        cbMeta = pCtx->Meta.add(pvData, cbData);
-        AssertReturn(cbMeta <= pCtx->Meta.cbData, VERR_BUFFER_OVERFLOW);
-
-        LogFlowThisFunc(("cbData=%zu, cbMeta=%zu, cbTotal=%zu\n", cbData, cbMeta, cbTotal));
+        const size_t cbMetaRecv = pCtx->Meta.add(pvData, cbData);
+        AssertReturn(cbMetaRecv <= pCtx->Meta.cbData, VERR_BUFFER_OVERFLOW);
+
+        LogFlowThisFunc(("cbData=%zu, cbMetaRecv=%zu, cbMetaAnnounced=%zu, cbTotalAnnounced=%zu\n",
+                         cbData, cbMetaRecv, cbMetaAnnounced, cbTotalAnnounced));
+
+        LogRel2(("DnD: %RU8%% of meta data complete (%zu/%zu bytes)\n",
+                 (uint8_t)(cbMetaRecv * 100 / RT_MAX(cbMetaAnnounced, 1)), cbMetaRecv, cbMetaAnnounced));
 
         /*
          * (Meta) Data transfer complete?
          */
-        if (cbMeta == pCtx->Meta.cbData)
+        if (cbMetaAnnounced == cbMetaRecv)
         {
             LogRel2(("DnD: Receiving meta data complete\n"));
@@ -673 +708 @@
             if (DnDMIMENeedsDropDir(pCtx->strFmtRecv.c_str(), pCtx->strFmtRecv.length()))
             {
-                LogRel2(("DnD: Building root entry list from meta data ...\n"));
-
                 rc = DnDTransferListInitEx(&pTransfer->List,
-                                           DnDDroppedFilesGetDirAbs(&pCtx->Transfer.DroppedFiles));
+                                           DnDDroppedFilesGetDirAbs(&pTransfer->DroppedFiles), DNDTRANSFERLISTFMT_NATIVE);
                 if (RT_SUCCESS(rc))
                     rc = DnDTransferListAppendRootsFromBuffer(&pTransfer->List, DNDTRANSFERLISTFMT_URI,
@@ -685 +718 @@
                 {
                     uint64_t cRoots = DnDTransferListGetRootCount(&pTransfer->List);
+
+                    LogRel2(("DnD: Received %RU64 root entries from guest\n", cRoots));
+
                     if (   cRoots == 0
                         || cRoots > pTransfer->cObjToProcess)
+                    {
+                        LogRel(("DnD: Number of root entries invalid / mismatch: Got %RU64, expected %RU64\n",
+                                cRoots, pTransfer->cObjToProcess));
                         rc = VERR_INVALID_PARAMETER;
+                    }
                 }
 
@@ -693 +733 @@
                 {
                     /* Update our process with the data we already received. */
-                    rc = updateProgress(pCtx, pCtx->pResp, cbMeta);
+                    rc = updateProgress(pCtx, pCtx->pResp, cbMetaAnnounced);
                     AssertRC(rc);
                 }
@@ -727 +767 @@
     LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pszPath, cbPath, fMode));
 
-    AssertMsgReturn(pCtx->isComplete() == false,
-                    ("Data transfer already complete, bailing out\n"), VERR_INVALID_PARAMETER);
-
     const PDNDTRANSFEROBJECT pObj = &pCtx->Transfer.ObjCur;
     const PDNDDROPPEDFILES   pDF  = &pCtx->Transfer.DroppedFiles;
@@ -753 +790 @@
             DnDTransferObjectDestroy(pObj);
 
-            if (RT_SUCCESS(rc))
+            if (RT_FAILURE(rc))
                 LogRel2(("DnD: Created guest directory '%s' on host\n", pcszPathAbs));
         }
@@ -937 +974 @@
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
-    GuestDnD *pInst = GUESTDNDINST();
-    if (!pInst)
-        return VERR_INVALID_POINTER;
-
-    GuestDnDResponse *pResp = pCtx->pResp;
-    AssertPtr(pCtx->pResp);
-
-    int rc = pCtx->EventCallback.Reset();
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /* Is this context already in receiving state? */
-    if (ASMAtomicReadBool(&pCtx->fIsActive))
-        return VERR_WRONG_ORDER;
-    ASMAtomicWriteBool(&pCtx->fIsActive, true);
-
-    /*
-     * Reset any old data.
-     */
-    pCtx->reset();
-    pCtx->Transfer.reset();
-    pResp->reset();
+    /* Sanity. */
+    AssertMsgReturn(pCtx->enmAction,
+                    ("Action to perform is none when it shouldn't\n"), VERR_INVALID_PARAMETER);
+    AssertMsgReturn(pCtx->strFmtReq.isNotEmpty(),
+                    ("Requested format from host is empty when it shouldn't\n"), VERR_INVALID_PARAMETER);
 
     /*
@@ -996 +1016 @@
     }
 
+    int rc = VINF_SUCCESS;
+
     if (fFoundFormat)
     {
-        Assert(!pCtx->strFmtReq.isEmpty());
-        Assert(!pCtx->strFmtRecv.isEmpty());
-
         if (!pCtx->strFmtRecv.equals(pCtx->strFmtReq))
             LogRel2(("DnD: Requested data in format '%s', receiving in intermediate format '%s' now\n",
@@ -1024 +1043 @@
         for (size_t i = 0; i < pCtx->lstFmtOffered.size(); i++)
             LogRel(("DnD:\tFormat #%zu: %s\n", i, pCtx->lstFmtOffered.at(i).c_str()));
-    }
-
-    ASMAtomicWriteBool(&pCtx->fIsActive, false);
+
+        rc = VERR_NOT_SUPPORTED;
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("DnD: Receiving data from guest failed with %Rrc\n", rc));
+
+        /* Reset state. */
+        i_reset();
+    }
 
     LogFlowFuncLeaveRC(rc);
@@ -1032 +1059 @@
 }
 
-/* static */
-void GuestDnDSource::i_receiveDataThreadTask(GuestDnDRecvDataTask *pTask)
-{
-    LogFlowFunc(("pTask=%p\n", pTask));
-    AssertPtrReturnVoid(pTask);
-
-    const ComObjPtr<GuestDnDSource> pThis(pTask->getSource());
-    Assert(!pThis.isNull());
-
-    AutoCaller autoCaller(pThis);
-    if (FAILED(autoCaller.rc()))
-        return;
-
-    int vrc = pThis->i_receiveData(pTask->getCtx(), RT_INDEFINITE_WAIT /* msTimeout */);
-    if (RT_FAILURE(vrc)) /* In case we missed some error handling within i_receiveData(). */
-    {
-        AssertFailed();
-        LogRel(("DnD: Receiving data from guest failed with %Rrc\n", vrc));
-    }
-
-    AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
-
-    Assert(pThis->m_DataBase.cTransfersPending);
-    if (pThis->m_DataBase.cTransfersPending)
-        pThis->m_DataBase.cTransfersPending--;
-
-    LogFlowFunc(("pSource=%p, vrc=%Rrc (ignored)\n", (GuestDnDSource *)pThis, vrc));
-}
-
 int GuestDnDSource::i_receiveRawData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
 {
@@ -1072 +1070 @@
     AssertPtr(pCtx->pResp);
 
-    GuestDnD *pInst = GUESTDNDINST();
+    GuestDnD *pInst = GuestDnDInst();
     if (!pInst)
         return VERR_INVALID_POINTER;
@@ -1177 +1175 @@
     AssertPtr(pCtx->pResp);
 
-    GuestDnD *pInst = GUESTDNDINST();
+    GuestDnD *pInst = GuestDnDInst();
     if (!pInst)
         return VERR_INVALID_POINTER;

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

@@ -62 +62 @@
     int getRC(void) const { return mRC; }
     bool isOk(void) const { return RT_SUCCESS(mRC); }
-    const ComObjPtr<GuestDnDTarget> &getTarget(void) const { return mTarget; }
 
 protected:
@@ -87 +86 @@
     void handler()
     {
-        GuestDnDTarget::i_sendDataThreadTask(this);
-    }
-
-    virtual ~GuestDnDSendDataTask(void)
-    {
-        if (mpCtx)
-        {
-            delete mpCtx;
-            mpCtx = NULL;
-        }
-    }
-
-
-    GuestDnDSendCtx *getCtx(void) { return mpCtx; }
+        const ComObjPtr<GuestDnDTarget> pThis(mTarget);
+        Assert(!pThis.isNull());
+
+        AutoCaller autoCaller(pThis);
+        if (FAILED(autoCaller.rc()))
+            return;
+
+        int vrc = pThis->i_sendData(mpCtx, RT_INDEFINITE_WAIT /* msTimeout */);
+        if (RT_FAILURE(vrc)) /* In case we missed some error handling within i_sendData(). */
+        {
+            if (vrc != VERR_CANCELLED)
+                LogRel(("DnD: Sending data to guest failed with %Rrc\n", vrc));
+
+            /* Make sure to fire a cancel request to the guest side in case something went wrong. */
+            pThis->sendCancel();
+        }
+    }
+
+    virtual ~GuestDnDSendDataTask(void) { }
 
 protected:
@@ -295 +299 @@
 
     LogRel2(("DnD: Offered formats to guest:\n"));
-    RTCList<RTCString> lstFormats = strFormats.split("\r\n");
+    RTCList<RTCString> lstFormats = strFormats.split(DND_PATH_SEPARATOR);
     for (size_t i = 0; i < lstFormats.size(); i++)
         LogRel2(("DnD: \t%s\n", lstFormats[i].c_str()));
@@ -307 +311 @@
 
     /* Adjust the coordinates in a multi-monitor setup. */
-    int rc = GUESTDNDINST()->adjustScreenCoordinates(aScreenId, &aX, &aY);
+    int rc = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
     if (RT_SUCCESS(rc))
     {
@@ -322 +326 @@
         Msg.setNextUInt32(cbFormats);
 
-        rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
         if (RT_SUCCESS(rc))
         {
-            GuestDnDResponse *pResp = GUESTDNDINST()->response();
+            GuestDnDResponse *pResp = GuestDnDInst()->response();
             if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
                 resAction = GuestDnD::toMainAction(pResp->getActionDefault());
@@ -385 +389 @@
     HRESULT hr = S_OK;
 
-    int rc = GUESTDNDINST()->adjustScreenCoordinates(aScreenId, &aX, &aY);
+    int rc = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
     if (RT_SUCCESS(rc))
     {
@@ -400 +404 @@
         Msg.setNextUInt32(cbFormats);
 
-        rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
         if (RT_SUCCESS(rc))
         {
-            GuestDnDResponse *pResp = GUESTDNDINST()->response();
+            GuestDnDResponse *pResp = GuestDnDInst()->response();
             if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
                 resAction = GuestDnD::toMainAction(pResp->getActionDefault());
@@ -440 +444 @@
         Msg.setNextUInt32(0); /** @todo ContextID not used yet. */
 
-    int rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+    int rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
     if (RT_SUCCESS(rc))
     {
-        GuestDnDResponse *pResp = GUESTDNDINST()->response();
+        GuestDnDResponse *pResp = GuestDnDInst()->response();
         if (pResp)
             pResp->waitForGuestResponse();
@@ -479 +483 @@
 
     /* Default action is ignoring. */
-    DnDAction_T resAction    = DnDAction_Ignore;
+    DnDAction_T resAct = DnDAction_Ignore;
+    Utf8Str     resFmt;
 
     /* Check & convert the drag & drop actions to HGCM codes. */
@@ -507 +512 @@
 
     /* Adjust the coordinates in a multi-monitor setup. */
-    HRESULT hr = GUESTDNDINST()->adjustScreenCoordinates(aScreenId, &aX, &aY);
+    HRESULT hr = GuestDnDInst()->adjustScreenCoordinates(aScreenId, &aX, &aY);
     if (SUCCEEDED(hr))
     {
@@ -522 +527 @@
         Msg.setNextUInt32(cbFormats);
 
-        int vrc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        int vrc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
         if (RT_SUCCESS(vrc))
         {
-            GuestDnDResponse *pResp = GUESTDNDINST()->response();
-            AssertPtr(pResp);
-
-            vrc = pResp->waitForGuestResponse();
-            if (RT_SUCCESS(vrc))
+            GuestDnDResponse *pResp = GuestDnDInst()->response();
+            if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
             {
-                resAction = GuestDnD::toMainAction(pResp->getActionDefault());
+                resAct = GuestDnD::toMainAction(pResp->getActionDefault());
 
                 GuestDnDMIMEList lstFormats = pResp->formats();
                 if (lstFormats.size() == 1) /* Exactly one format to use specified? */
                 {
-                    aFormat = lstFormats.at(0);
-                    LogFlowFunc(("resFormat=%s, resAction=%RU32\n", aFormat.c_str(), pResp->getActionDefault()));
+                    resFmt = lstFormats.at(0);
                 }
                 else
@@ -552 +553 @@
         hr = setError(hr, tr("Retrieving drop coordinates failed"));
 
+    LogFlowFunc(("resFmt=%s, resAct=%RU32, vrc=%Rhrc\n", resFmt.c_str(), resAct, hr));
+
     if (SUCCEEDED(hr))
     {
+        aFormat = resFmt;
         if (aResultAction)
-            *aResultAction = resAction;
-    }
-
-    LogFlowFunc(("Returning hr=%Rhrc\n", hr));
+            *aResultAction = resAct;
+    }
+
     return hr;
 #endif /* VBOX_WITH_DRAG_AND_DROP */
-}
-
-/**
- * Thread handler function for sending data to the guest.
- *
- * @param   pTask               Thread task this handler is associated with.
- */
-/* static */
-void GuestDnDTarget::i_sendDataThreadTask(GuestDnDSendDataTask *pTask)
-{
-    LogFlowFunc(("pTask=%p\n", pTask));
-    AssertPtrReturnVoid(pTask);
-
-    const ComObjPtr<GuestDnDTarget> pThis(pTask->getTarget());
-    Assert(!pThis.isNull());
-
-    AutoCaller autoCaller(pThis);
-    if (FAILED(autoCaller.rc()))
-        return;
-
-    int vrc = pThis->i_sendData(pTask->getCtx(), RT_INDEFINITE_WAIT /* msTimeout */);
-    if (RT_FAILURE(vrc)) /* In case we missed some error handling within i_sendData(). */
-    {
-        AssertFailed();
-        LogRel(("DnD: Sending data to guest failed with %Rrc\n", vrc));
-    }
-
-    AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
-
-    Assert(pThis->m_DataBase.cTransfersPending);
-    if (pThis->m_DataBase.cTransfersPending)
-        pThis->m_DataBase.cTransfersPending--;
-
-    LogFlowFunc(("pTarget=%p, vrc=%Rrc (ignored)\n", (GuestDnDTarget *)pThis, vrc));
 }
 
@@ -626 +595 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
+    /* Check if this object still is in a pending state and bail out if so. */
+    if (m_fIsPending)
+        return setError(E_FAIL, tr("Current drop operation to guest still in progress"));
+
+    /* Reset our internal state. */
+    i_reset();
+
     /* At the moment we only support one transfer at a time. */
-    if (m_DataBase.cTransfersPending)
-        return setError(E_INVALIDARG, tr("Another drop operation already is in progress"));
-
-    /* Ditto. */
-    GuestDnDResponse *pResp = GUESTDNDINST()->response();
+    if (GuestDnDInst()->getTargetCount())
+        return setError(E_INVALIDARG, tr("Another drag and drop operation to the guest already is in progress"));
+
+    /* Reset progress object. */
+    GuestDnDResponse *pResp = GuestDnDInst()->response();
     AssertPtr(pResp);
-
     HRESULT hr = pResp->resetProgress(m_pGuest);
     if (FAILED(hr))
         return hr;
 
-    GuestDnDSendDataTask *pTask    = NULL;
-    GuestDnDSendCtx      *pSendCtx = NULL;
+    GuestDnDSendDataTask *pTask = NULL;
 
     try
     {
-        /* pSendCtx is passed into SendDataTask where one is deleted in destructor. */
-        pSendCtx = new GuestDnDSendCtx();
-        pSendCtx->pTarget   = this;
-        pSendCtx->pResp     = pResp;
-        pSendCtx->uScreenID = aScreenId;
-
-        pSendCtx->Meta.strFmt = aFormat;
-        pSendCtx->Meta.add(aData);
-
-        /* pTask is responsible for deletion of pSendCtx after creating */
-        pTask = new GuestDnDSendDataTask(this, pSendCtx);
+        mData.mSendCtx.reset();
+
+        mData.mSendCtx.pTarget   = this;
+        mData.mSendCtx.pResp     = pResp;
+        mData.mSendCtx.uScreenID = aScreenId;
+
+        mData.mSendCtx.Meta.strFmt = aFormat;
+        mData.mSendCtx.Meta.add(aData);
+
+        pTask = new GuestDnDSendDataTask(this, &mData.mSendCtx);
         if (!pTask->isOk())
         {
@@ -660 +633 @@
             throw hr = E_FAIL;
         }
-
-        /* Drop write lock before creating thread. */
-        alock.release();
 
         /* This function delete pTask in case of exceptions,
@@ -681 +651 @@
     if (SUCCEEDED(hr))
     {
-        /* Re-acquire write lock. */
-        alock.acquire();
-
-        m_DataBase.cTransfersPending++;
-
+        /* Register ourselves at the DnD manager. */
+        GuestDnDInst()->registerTarget(this);
+
+        /* Return progress to caller. */
         hr = pResp->queryProgressTo(aProgress.asOutParam());
         ComAssertComRC(hr);
     }
     else
-        hr = setError(hr, tr("Starting thread for GuestDnDTarget::i_sendDataThread (%Rhrc)"), hr);
+        hr = setError(hr, tr("Starting thread for GuestDnDTarget failed (%Rhrc)"), hr);
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));
@@ -767 +736 @@
 
     return strError;
+}
+
+void GuestDnDTarget::i_reset(void)
+{
+    LogFlowThisFunc(("\n"));
+
+    mData.mSendCtx.reset();
+
+    m_fIsPending = false;
+
+    /* Unregister ourselves from the DnD manager. */
+    GuestDnDInst()->unregisterTarget(this);
 }
 
@@ -780 +761 @@
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
-    /* Is this context already in sending state? */
-    if (ASMAtomicReadBool(&pCtx->fIsActive))
-        return VERR_WRONG_ORDER;
-    ASMAtomicWriteBool(&pCtx->fIsActive, true);
+    /* Don't allow receiving the actual data until our current transfer is complete. */
+    if (m_fIsPending)
+        return setError(E_FAIL, tr("Current drop operation to guest still in progress"));
 
     /* Clear all remaining outgoing messages. */
@@ -810 +790 @@
     }
 
-    ASMAtomicWriteBool(&pCtx->fIsActive, false);
+    if (RT_FAILURE(rc))
+        LogRel(("DnD: Sending data to guest failed with %Rrc\n", rc));
+
+    /* Reset state. */
+    i_reset();
 
     LogFlowFuncLeaveRC(rc);
@@ -839 +823 @@
 
 #ifdef DEBUG
-    RTCList<RTCString> lstFilesURI = RTCString((char *)pvData, cbData).split("\r\n");
+    RTCList<RTCString> lstFilesURI = RTCString((char *)pvData, cbData).split(DND_PATH_SEPARATOR);
     LogFlowFunc(("lstFilesURI=%zu\n", lstFilesURI.size()));
     for (size_t i = 0; i < lstFilesURI.size(); i++)
@@ -871 +855 @@
         }
 
-        rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
         if (RT_FAILURE(rc))
             break;
@@ -907 +891 @@
 
     LogRel2(("DnD: Sending meta data header to guest (%RU64 bytes total data, %RU32 bytes meta data, %RU64 objects)\n",
-             pCtx->getTotal(), pCtx->Meta.cbData, pCtx->Transfer.cObjToProcess));
+             pCtx->getTotalAnnounced(), pCtx->Meta.cbData, pCtx->Transfer.cObjToProcess));
 
     Msg.setNextUInt32(0);                                                /** @todo uContext; not used yet. */
     Msg.setNextUInt32(0);                                                /** @todo uFlags; not used yet. */
     Msg.setNextUInt32(pCtx->uScreenID);                                  /* uScreen */
-    Msg.setNextUInt64(pCtx->getTotal());                                 /* cbTotal */
+    Msg.setNextUInt64(pCtx->getTotalAnnounced());                        /* cbTotal */
     Msg.setNextUInt32((uint32_t)pCtx->Meta.cbData);                      /* cbMeta*/
     Msg.setNextPointer(unconst(pCtx->Meta.strFmt.c_str()), (uint32_t)pCtx->Meta.strFmt.length() + 1); /* pvMetaFmt */
@@ -922 +906 @@
     Msg.setNextUInt32(0);                                                /** @todo cbChecksum; not used yet. */
 
-    int rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+    int rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
 
     LogFlowFuncLeaveRC(rc);
@@ -1398 +1382 @@
          * Update internal state to reflect everything we need to work with it.
          */
-        pCtx->cbExtra               = DnDTransferListObjTotalBytes(&pCtx->Transfer.List);
+        pCtx->cbExtra                = DnDTransferListObjTotalBytes(&pCtx->Transfer.List);
         /* cbExtra can be 0, if all files are of 0 bytes size. */
         pCtx->Transfer.cObjToProcess = DnDTransferListObjCount(&pCtx->Transfer.List);
@@ -1431 +1415 @@
             pCtx->Meta.cbData      = cbData;
             pCtx->Meta.cbAllocated = cbData;
+            pCtx->Meta.cbAnnounced = cbData;
         }
 
@@ -1530 +1515 @@
     AssertRCReturn(rc, rc);
 
-    if (pCtx->isComplete())
-    {
-        Assert(pCtx->Transfer.isComplete());
+    PDNDTRANSFEROBJECT pObj = DnDTransferListObjGetFirst(pList);
+    if (!pObj) /* Transfer complete? */
         return VINF_EOF;
-    }
-
-    PDNDTRANSFEROBJECT pObj = DnDTransferListObjGetFirst(pList);
-    AssertPtrReturn(pObj, VERR_WRONG_ORDER);
 
     switch (DnDTransferObjectGetType(pObj))