Changeset 85744 in vbox for trunk/src

Timestamp:

Aug 13, 2020 8:28:29 AM (5 years ago)

Author:

vboxsync

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

139892

Message:

DnD/Main: Renaming (GuestDnDResponse -> GuestDnDState).

Location:

trunk/src/VBox/Main

Files:

• include/GuestDnDPrivate.h (modified) (8 diffs)
• src-client/GuestDnDPrivate.cpp (modified) (25 diffs)
• src-client/GuestDnDSourceImpl.cpp (modified) (35 diffs)
• src-client/GuestDnDTargetImpl.cpp (modified) (37 diffs)

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

@@ -37 +37 @@
 class Guest;
 class GuestDnDBase;
-class GuestDnDResponse;
+class GuestDnDState;
 class GuestDnDSource;
 class GuestDnDTarget;
@@ -481 +481 @@
     /** Pointer to guest target class this context belongs to. */
     GuestDnDTarget                     *pTarget;
-    /** Pointer to guest response class this context belongs to. */
-    GuestDnDResponse                   *pResp;
+    /** Pointer to guest state this context belongs to. */
+    GuestDnDState                      *pState;
     /** Target (VM) screen ID. */
     uint32_t                            uScreenID;
@@ -558 +558 @@
     /** Pointer to guest source class this context belongs to. */
     GuestDnDSource                     *pSource;
-    /** Pointer to guest response class this context belongs to. */
-    GuestDnDResponse                   *pResp;
+    /** Pointer to guest state this context belongs to. */
+    GuestDnDState                      *pState;
     /** Formats offered by the guest (and supported by the host). */
     GuestDnDMIMEList                    lstFmtOffered;
@@ -797 +797 @@
 typedef std::map<uint32_t, GuestDnDCallback> GuestDnDCallbackMap;
 
-/** @todo r=andy This class needs to go, as this now is too inflexible when it comes to all
- *               the callback handling/dispatching. It's part of the initial code and only adds
- *               unnecessary complexity. */
-class GuestDnDResponse
-{
-
-public:
-
-    GuestDnDResponse(const ComObjPtr<Guest>& pGuest);
-    virtual ~GuestDnDResponse(void);
+/**
+ * Class for keeping a DnD guest state around.
+ */
+class GuestDnDState
+{
+
+public:
+
+    GuestDnDState(const ComObjPtr<Guest>& pGuest);
+    virtual ~GuestDnDState(void);
 
 public:
@@ -925 +925 @@
      * @{ */
     HRESULT           adjustScreenCoordinates(ULONG uScreenId, ULONG *puX, ULONG *puY) const;
+    GuestDnDState    *getState(uint32_t = 0) const;
     int               hostCall(uint32_t u32Function, uint32_t cParms, PVBOXHGCMSVCPARM paParms) const;
-    GuestDnDResponse *response(void) { return m_pResponse; }
     GuestDnDMIMEList  defaultFormats(void) const { return m_strDefaultFormats; }
     /** @}  */
@@ -968 +968 @@
     /** Pointer to guest implementation. */
     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;
+    /** The current state from the guest. At the
+     *  moment we only support only state a time (ARQ-style). */
+    GuestDnDState              *m_pState;
     /** Critical section to serialize access. */
     RTCRITSECT                  m_CritSect;
@@ -1022 +1022 @@
 
     int sendCancel(void);
-    int updateProgress(GuestDnDData *pData, GuestDnDResponse *pResp, size_t cbDataAdd = 0);
-    int waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDResponse *pResp, RTMSINTERVAL msTimeout);
+    int updateProgress(GuestDnDData *pData, GuestDnDState *pState, size_t cbDataAdd = 0);
+    int waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDState *pState, RTMSINTERVAL msTimeout);
 
 protected:
@@ -1037 +1037 @@
     /** Whether the object still is in pending state. */
     bool                            m_fIsPending;
-    /** Pointer to response bound to this object. */
-    GuestDnDResponse               *m_pResp;
+    /** Pointer to state bound to this object. */
+    GuestDnDState                  *m_pState;
     /** @}  */
 

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

@@ -184 +184 @@
 GuestDnDSendCtx::GuestDnDSendCtx(void)
     : pTarget(NULL)
-    , pResp(NULL)
+    , pState(NULL)
 {
     reset();
@@ -194 +194 @@
 void GuestDnDSendCtx::reset(void)
 {
-    if (pResp)
-        pResp->reset();
+    if (pState)
+        pState->reset();
 
     uScreenID  = 0;
@@ -213 +213 @@
 GuestDnDRecvCtx::GuestDnDRecvCtx(void)
     : pSource(NULL)
-    , pResp(NULL)
+    , pState(NULL)
 {
     reset();
@@ -223 +223 @@
 void GuestDnDRecvCtx::reset(void)
 {
-    if (pResp)
-        pResp->reset();
+    if (pState)
+        pState->reset();
 
     lstFmtOffered.clear();
@@ -290 +290 @@
  ********************************************************************************************************************************/
 
-GuestDnDResponse::GuestDnDResponse(const ComObjPtr<Guest>& pGuest)
+GuestDnDState::GuestDnDState(const ComObjPtr<Guest>& pGuest)
     : m_uProtocolVersion(0)
     , m_fGuestFeatures0(VBOX_DND_GF_NONE)
@@ -303 +303 @@
 }
 
-GuestDnDResponse::~GuestDnDResponse(void)
+GuestDnDState::~GuestDnDState(void)
 {
     reset();
@@ -314 +314 @@
  * Notifies the waiting side about a guest notification response.
  */
-int GuestDnDResponse::notifyAboutGuestResponse(void) const
+int GuestDnDState::notifyAboutGuestResponse(void) const
 {
     return RTSemEventSignal(m_EventSem);
@@ -322 +322 @@
  * Resets a GuestDnDResponse object.
  */
-void GuestDnDResponse::reset(void)
+void GuestDnDState::reset(void)
 {
     LogFlowThisFuncEnter();
@@ -338 +338 @@
  * @param   pParent             Parent to set for the progress object.
  */
-HRESULT GuestDnDResponse::resetProgress(const ComObjPtr<Guest>& pParent)
+HRESULT GuestDnDState::resetProgress(const ComObjPtr<Guest>& pParent)
 {
     m_pProgress.setNull();
@@ -358 +358 @@
  * @returns \c true if canceled, \c false if not.
  */
-bool GuestDnDResponse::isProgressCanceled(void) const
+bool GuestDnDState::isProgressCanceled(void) const
 {
     BOOL fCanceled;
@@ -380 +380 @@
  * @param   pvUser              User-provided arguments for the callback function. Optional and can be NULL.
  */
-int GuestDnDResponse::setCallback(uint32_t uMsg, PFNGUESTDNDCALLBACK pfnCallback, void *pvUser /* = NULL */)
+int GuestDnDState::setCallback(uint32_t uMsg, PFNGUESTDNDCALLBACK pfnCallback, void *pvUser /* = NULL */)
 {
     GuestDnDCallbackMap::iterator it = m_mapCallbacks.find(uMsg);
@@ -413 +413 @@
  * @param   strMsg              Message to set. Optional.
  */
-int GuestDnDResponse::setProgress(unsigned uPercentage, uint32_t uStatus,
-                                  int rcOp /* = VINF_SUCCESS */, const Utf8Str &strMsg /* = "" */)
+int GuestDnDState::setProgress(unsigned uPercentage, uint32_t uStatus,
+                               int rcOp /* = VINF_SUCCESS */, const Utf8Str &strMsg /* = "" */)
 {
     LogFlowFunc(("uPercentage=%u, uStatus=%RU32, , rcOp=%Rrc, strMsg=%s\n",
@@ -516 +516 @@
  * @param   cbParms             Size (in bytes) of \a pvParms.
  */
-int GuestDnDResponse::onDispatch(uint32_t u32Function, void *pvParms, uint32_t cbParms)
+int GuestDnDState::onDispatch(uint32_t u32Function, void *pvParms, uint32_t cbParms)
 {
     LogFlowFunc(("u32Function=%RU32, pvParms=%p, cbParms=%RU32\n", u32Function, pvParms, cbParms));
@@ -687 +687 @@
  * @param   ppProgress          Where to query the progress object to.
  */
-HRESULT GuestDnDResponse::queryProgressTo(IProgress **ppProgress)
+HRESULT GuestDnDState::queryProgressTo(IProgress **ppProgress)
 {
     return m_pProgress.queryInterfaceTo(ppProgress);
@@ -698 +698 @@
  * @param   msTimeout           Timeout (in ms) for waiting. Optional, waits 500 ms if not specified.
  */
-int GuestDnDResponse::waitForGuestResponse(RTMSINTERVAL msTimeout /*= 500 */) const
+int GuestDnDState::waitForGuestResponse(RTMSINTERVAL msTimeout /*= 500 */) const
 {
     int rc = RTSemEventWait(m_EventSem, msTimeout);
@@ -722 +722 @@
     try
     {
-        m_pResponse = new GuestDnDResponse(pGuest);
+        m_pState = new GuestDnDState(pGuest);
     }
     catch (std::bad_alloc &)
@@ -751 +751 @@
     RTCritSectDelete(&m_CritSect);
 
-    if (m_pResponse)
-        delete m_pResponse;
+    if (m_pState)
+        delete m_pState;
 }
 
@@ -794 +794 @@
 
 /**
+ * Returns a DnD guest state.
+ *
+ * @returns Pointer to DnD guest state, or NULL if not found / invalid.
+ * @param   uID                 ID of DnD guest state to return.
+ */
+GuestDnDState *GuestDnD::getState(uint32_t uID /* = 0 */) const
+{
+    AssertMsgReturn(uID == 0, ("Only one state (0) is supported at the moment\n"), NULL);
+
+    return m_pState;
+}
+
+/**
  * Sends a (blocking) message to the host side of the host service.
  *
@@ -941 +954 @@
      *        would be the place to lookup and dispatch to those. For the moment we
      *        only have one response -- simple. */
-    GuestDnDResponse *pResp = pGuestDnD->m_pResponse;
-    if (pResp)
-        return pResp->onDispatch(u32Function, pvParms, cbParms);
+    if (pGuestDnD->m_pState)
+        return pGuestDnD->m_pState->onDispatch(u32Function, pvParms, cbParms);
 
     return VERR_NOT_SUPPORTED;
@@ -1308 +1320 @@
     GuestDnDMsg Msg;
     Msg.setType(HOST_DND_CANCEL);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         Msg.appendUInt32(0); /** @todo ContextID not used yet. */
 
@@ -1325 +1337 @@
  * @returns VBox status code.
  * @param   pData               GuestDnDData object to use for accounting.
- * @param   pResp               GuestDnDResponse to update its progress object for.
+ * @param   pState              Guest state to update its progress object for.
  * @param   cbDataAdd           By how much data (in bytes) to update the progress.
  */
-int GuestDnDBase::updateProgress(GuestDnDData *pData, GuestDnDResponse *pResp,
+int GuestDnDBase::updateProgress(GuestDnDData *pData, GuestDnDState *pState,
                                  size_t cbDataAdd /* = 0 */)
 {
     AssertPtrReturn(pData, VERR_INVALID_POINTER);
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
+    AssertPtrReturn(pState, VERR_INVALID_POINTER);
     /* cbDataAdd is optional. */
 
@@ -1338 +1350 @@
                  pData->cbExtra, pData->cbProcessed, pData->getRemaining(), cbDataAdd));
 
-    if (   !pResp
+    if (   !pState
         || !cbDataAdd) /* Only update if something really changes. */
         return VINF_SUCCESS;
@@ -1349 +1361 @@
     LogRel2(("DnD: Transfer %RU8%% complete\n", uPercent));
 
-    int rc = pResp->setProgress(uPercent,
-                                  pData->isComplete()
-                                ? DND_PROGRESS_COMPLETE
-                                : DND_PROGRESS_RUNNING);
+    int rc = pState->setProgress(uPercent,
+                                   pData->isComplete()
+                                 ? DND_PROGRESS_COMPLETE
+                                 : DND_PROGRESS_RUNNING);
     LogFlowFuncLeaveRC(rc);
     return rc;
@@ -1360 +1372 @@
  * Waits for a specific guest callback event to get signalled.
  *
- ** @todo GuestDnDResponse *pResp needs to go.
- *
  * @returns VBox status code. Will return VERR_CANCELLED if the user has cancelled the progress object.
  * @param   pEvent                  Callback event to wait for.
- * @param   pResp                   Response to update.
+ * @param   pState                  Guest state to update.
  * @param   msTimeout               Timeout (in ms) to wait.
  */
-int GuestDnDBase::waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDResponse *pResp, RTMSINTERVAL msTimeout)
+int GuestDnDBase::waitForEvent(GuestDnDCallbackEvent *pEvent, GuestDnDState *pState, RTMSINTERVAL msTimeout)
 {
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
+    AssertPtrReturn(pState, VERR_INVALID_POINTER);
 
     int rc;
@@ -1400 +1410 @@
             LogRel2(("DnD: Error: Guest did not respond within time\n"));
         }
-        else if (pResp->isProgressCanceled()) /** @todo GuestDnDResponse *pResp needs to go. */
+        else if (pState->isProgressCanceled())
         {
             LogRel2(("DnD: Operation was canceled by user\n"));

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

@@ -163 +163 @@
      *  nor 2) mixed transfers (G->H + H->G at the same time).
      */
-    m_pResp = GuestDnDInst()->response();
-    AssertPtrReturn(m_pResp, E_POINTER);
+    m_pState = GuestDnDInst()->getState();
+    AssertPtrReturn(m_pState, E_POINTER);
 
     /* Confirm a successful initialization when it's the case. */
@@ -276 +276 @@
     GuestDnDMsg Msg;
     Msg.setType(HOST_DND_GH_REQ_PENDING);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         Msg.appendUInt32(0); /** @todo ContextID not used yet. */
     Msg.appendUInt32(uScreenId);
@@ -283 +283 @@
     if (RT_SUCCESS(rc))
     {
-        GuestDnDResponse *pResp = GuestDnDInst()->response();
-        AssertPtr(pResp);
+        GuestDnDState *pState = GuestDnDInst()->getState();
+        AssertPtr(pState);
 
         bool fFetchResult = true;
 
-        rc = pResp->waitForGuestResponse(100 /* Timeout in ms */);
+        rc = pState->waitForGuestResponse(100 /* Timeout in ms */);
         if (RT_FAILURE(rc))
             fFetchResult = false;
 
         if (   fFetchResult
-            && isDnDIgnoreAction(pResp->getActionDefault()))
+            && isDnDIgnoreAction(pState->getActionDefault()))
             fFetchResult = false;
 
@@ -305 +305 @@
              * which are not supported by the host.
              */
-            GuestDnDMIMEList lstFiltered  = GuestDnD::toFilteredFormatList(m_lstFmtSupported, pResp->formats());
+            GuestDnDMIMEList lstFiltered  = GuestDnD::toFilteredFormatList(m_lstFmtSupported, pState->formats());
             if (lstFiltered.size())
             {
@@ -313 +313 @@
 
                 aFormats            = lstFiltered;
-                aAllowedActions     = GuestDnD::toMainActions(pResp->getActionsAllowed());
+                aAllowedActions     = GuestDnD::toMainActions(pState->getActionsAllowed());
                 if (aDefaultAction)
-                    *aDefaultAction = GuestDnD::toMainAction(pResp->getActionDefault());
+                    *aDefaultAction = GuestDnD::toMainAction(pState->getActionDefault());
 
                 /* Apply the (filtered) formats list. */
@@ -324 +324 @@
         }
 
-        LogFlowFunc(("fFetchResult=%RTbool, lstActionsAllowed=0x%x\n", fFetchResult, pResp->getActionsAllowed()));
+        LogFlowFunc(("fFetchResult=%RTbool, lstActionsAllowed=0x%x\n", fFetchResult, pState->getActionsAllowed()));
     }
 
@@ -370 +370 @@
 
     /* Reset progress object. */
-    GuestDnDResponse *pResp = GuestDnDInst()->response();
-    AssertPtr(pResp);
-    HRESULT hr = pResp->resetProgress(m_pGuest);
+    GuestDnDState *pState = GuestDnDInst()->getState();
+    AssertPtr(pState);
+    HRESULT hr = pState->resetProgress(m_pGuest);
     if (FAILED(hr))
         return hr;
@@ -381 +381 @@
     {
         mData.mRecvCtx.pSource       = this;
-        mData.mRecvCtx.pResp         = pResp;
+        mData.mRecvCtx.pState        = pState;
         mData.mRecvCtx.enmAction     = dndAction;
         mData.mRecvCtx.strFmtReq     = aFormat;
@@ -419 +419 @@
         GuestDnDInst()->registerSource(this);
 
-        hr = pResp->queryProgressTo(aProgress.asOutParam());
+        hr = pState->queryProgressTo(aProgress.asOutParam());
         ComAssertComRC(hr);
 
@@ -665 +665 @@
         size_t  cbMetaAnnounced;
 
-        if (m_pResp->m_uProtocolVersion < 3)
+        if (m_pState->m_uProtocolVersion < 3)
         {
             cbData  = pSndData->u.v1.cbData;
@@ -748 +748 @@
                 {
                     /* Update our process with the data we already received. */
-                    rc = updateProgress(pCtx, pCtx->pResp, cbMetaAnnounced);
+                    rc = updateProgress(pCtx, pCtx->pState, cbMetaAnnounced);
                     AssertRC(rc);
                 }
@@ -757 +757 @@
             else /* Raw data. */
             {
-                rc = updateProgress(pCtx, pCtx->pResp, cbData);
+                rc = updateProgress(pCtx, pCtx->pState, cbData);
                 AssertRC(rc);
             }
@@ -882 +882 @@
 
         /* Note: Protocol v1 does not send any file sizes, so always 0. */
-        if (m_pResp->m_uProtocolVersion >= 2)
+        if (m_pState->m_uProtocolVersion >= 2)
             rc = DnDTransferObjectSetSize(pObj, cbSize);
 
@@ -966 +966 @@
         }
 
-        rc = updateProgress(pCtx, pCtx->pResp, cbWritten);
+        rc = updateProgress(pCtx, pCtx->pState, cbWritten);
         AssertRCBreak(rc);
 
@@ -1104 +1104 @@
     LogFlowFuncEnter();
 
-    GuestDnDResponse *pResp = pCtx->pResp;
-    AssertPtr(pCtx->pResp);
+    GuestDnDState *pState = pCtx->pState;
+    AssertPtr(pCtx->pState);
 
     GuestDnD *pInst = GuestDnDInst();
@@ -1112 +1112 @@
 
 #define REGISTER_CALLBACK(x) \
-    do {                                                            \
-        rc = pResp->setCallback(x, i_receiveRawDataCallback, pCtx); \
-        if (RT_FAILURE(rc))                                         \
-            return rc;                                              \
+    do {                                                             \
+        rc = pState->setCallback(x, i_receiveRawDataCallback, pCtx); \
+        if (RT_FAILURE(rc))                                          \
+            return rc;                                               \
     } while (0)
 
 #define UNREGISTER_CALLBACK(x)                                      \
     do {                                                            \
-        int rc2 = pResp->setCallback(x, NULL);                      \
+        int rc2 = pState->setCallback(x, NULL);                     \
         AssertRC(rc2);                                              \
     } while (0)
@@ -1130 +1130 @@
     REGISTER_CALLBACK(GUEST_DND_DISCONNECT);
     REGISTER_CALLBACK(GUEST_DND_GH_EVT_ERROR);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         REGISTER_CALLBACK(GUEST_DND_GH_SND_DATA_HDR);
     REGISTER_CALLBACK(GUEST_DND_GH_SND_DATA);
@@ -1141 +1141 @@
         GuestDnDMsg Msg;
         Msg.setType(HOST_DND_GH_EVT_DROPPED);
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             Msg.appendUInt32(0); /** @todo ContextID not used yet. */
         Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
@@ -1152 +1152 @@
         if (RT_SUCCESS(rc))
         {
-            rc = waitForEvent(&pCtx->EventCallback, pCtx->pResp, msTimeout);
+            rc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
             if (RT_SUCCESS(rc))
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
         }
 
@@ -1165 +1165 @@
     UNREGISTER_CALLBACK(GUEST_DND_DISCONNECT);
     UNREGISTER_CALLBACK(GUEST_DND_GH_EVT_ERROR);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         UNREGISTER_CALLBACK(GUEST_DND_GH_SND_DATA_HDR);
     UNREGISTER_CALLBACK(GUEST_DND_GH_SND_DATA);
@@ -1184 +1184 @@
             AssertRC(rc2);
 
-            rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_CANCELLED);
+            rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
             AssertRC(rc2);
         }
         else if (rc != VERR_GSTDND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
         {
-            int rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR,
-                                               rc, GuestDnDSource::i_hostErrorToString(rc));
+            int rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR,
+                                                rc, GuestDnDSource::i_hostErrorToString(rc));
             AssertRC(rc2);
         }
@@ -1216 +1216 @@
     LogFlowFuncEnter();
 
-    GuestDnDResponse *pResp = pCtx->pResp;
-    AssertPtr(pCtx->pResp);
+    GuestDnDState *pState = pCtx->pState;
+    AssertPtr(pCtx->pState);
 
     GuestDnD *pInst = GuestDnDInst();
@@ -1223 +1223 @@
         return VERR_INVALID_POINTER;
 
-#define REGISTER_CALLBACK(x)                                             \
-    do {                                                                 \
-        rc = pResp->setCallback(x, i_receiveTransferDataCallback, pCtx); \
-        if (RT_FAILURE(rc))                                              \
-            return rc;                                                   \
+#define REGISTER_CALLBACK(x)                                              \
+    do {                                                                  \
+        rc = pState->setCallback(x, i_receiveTransferDataCallback, pCtx); \
+        if (RT_FAILURE(rc))                                               \
+            return rc;                                                    \
     } while (0)
 
-#define UNREGISTER_CALLBACK(x)                                      \
-    do {                                                            \
-        int rc2 = pResp->setCallback(x, NULL);                      \
-        AssertRC(rc2);                                              \
+#define UNREGISTER_CALLBACK(x)                                       \
+    do {                                                             \
+        int rc2 = pState->setCallback(x, NULL);                      \
+        AssertRC(rc2);                                               \
     } while (0)
 
@@ -1243 +1243 @@
     REGISTER_CALLBACK(GUEST_DND_DISCONNECT);
     REGISTER_CALLBACK(GUEST_DND_GH_EVT_ERROR);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         REGISTER_CALLBACK(GUEST_DND_GH_SND_DATA_HDR);
     REGISTER_CALLBACK(GUEST_DND_GH_SND_DATA);
     REGISTER_CALLBACK(GUEST_DND_GH_SND_DIR);
-    if (m_pResp->m_uProtocolVersion >= 2)
+    if (m_pState->m_uProtocolVersion >= 2)
         REGISTER_CALLBACK(GUEST_DND_GH_SND_FILE_HDR);
     REGISTER_CALLBACK(GUEST_DND_GH_SND_FILE_DATA);
@@ -1268 +1268 @@
         GuestDnDMsg Msg;
         Msg.setType(HOST_DND_GH_EVT_DROPPED);
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             Msg.appendUInt32(0); /** @todo ContextID not used yet. */
         Msg.appendPointer((void*)pCtx->strFmtRecv.c_str(), (uint32_t)pCtx->strFmtRecv.length() + 1);
@@ -1281 +1281 @@
             LogFlowFunc(("Waiting ...\n"));
 
-            rc = waitForEvent(&pCtx->EventCallback, pCtx->pResp, msTimeout);
+            rc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
             if (RT_SUCCESS(rc))
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
 
             LogFlowFunc(("Waiting ended with rc=%Rrc\n", rc));
@@ -1322 +1322 @@
             AssertRC(rc2);
 
-            rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_CANCELLED);
+            rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
             AssertRC(rc2);
 
@@ -1330 +1330 @@
         else if (rc != VERR_GSTDND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
         {
-            rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR,
-                                           rc, GuestDnDSource::i_hostErrorToString(rc));
+            rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR,
+                                            rc, GuestDnDSource::i_hostErrorToString(rc));
             AssertRC(rc2);
         }
@@ -1405 +1405 @@
             AssertReturn(CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
 
-            pCtx->pResp->reset();
+            pCtx->pState->reset();
 
             if (RT_SUCCESS(pCBData->rc))
@@ -1414 +1414 @@
             else if (pCBData->rc == VERR_WRONG_ORDER)
             {
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_CANCELLED);
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
             }
             else
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
-                                              GuestDnDSource::i_guestErrorToString(pCBData->rc));
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
+                                               GuestDnDSource::i_guestErrorToString(pCBData->rc));
 
             LogRel3(("DnD: Guest reported data transfer error: %Rrc\n", pCBData->rc));
@@ -1458 +1458 @@
 
         /* Unregister this callback. */
-        AssertPtr(pCtx->pResp);
-        int rc2 = pCtx->pResp->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
+        AssertPtr(pCtx->pState);
+        int rc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
         AssertRC(rc2);
     }
@@ -1564 +1564 @@
             AssertReturn(CB_MAGIC_DND_GH_SND_FILE_DATA == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
 
-            if (pThis->m_pResp->m_uProtocolVersion <= 1)
+            if (pThis->m_pState->m_uProtocolVersion <= 1)
             {
                 /**
@@ -1589 +1589 @@
             AssertReturn(CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
 
-            pCtx->pResp->reset();
+            pCtx->pState->reset();
 
             if (RT_SUCCESS(pCBData->rc))
@@ -1598 +1598 @@
             else if (pCBData->rc == VERR_WRONG_ORDER)
             {
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_CANCELLED);
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED);
             }
             else
-                rc = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
-                                              GuestDnDSource::i_guestErrorToString(pCBData->rc));
+                rc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
+                                               GuestDnDSource::i_guestErrorToString(pCBData->rc));
 
             LogRel3(("DnD: Guest reported file transfer error: %Rrc\n", pCBData->rc));
@@ -1642 +1642 @@
 
         /* Unregister this callback. */
-        AssertPtr(pCtx->pResp);
-        int rc2 = pCtx->pResp->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
+        AssertPtr(pCtx->pState);
+        int rc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
         AssertRC(rc2);
     }

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

@@ -161 +161 @@
      *  nor 2) mixed transfers (G->H + H->G at the same time).
      */
-    m_pResp = GuestDnDInst()->response();
-    AssertPtrReturn(m_pResp, E_POINTER);
+    m_pState = GuestDnDInst()->getState();
+    AssertPtrReturn(m_pState, E_POINTER);
 
     /* Confirm a successful initialization when it's the case. */
@@ -316 +316 @@
         GuestDnDMsg Msg;
         Msg.setType(HOST_DND_HG_EVT_ENTER);
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             Msg.appendUInt32(0); /** @todo ContextID not used yet. */
         Msg.appendUInt32(aScreenId);
@@ -329 +329 @@
         if (RT_SUCCESS(rc))
         {
-            if (RT_SUCCESS(m_pResp->waitForGuestResponse()))
-                resAction = GuestDnD::toMainAction(m_pResp->getActionDefault());
+            if (RT_SUCCESS(m_pState->waitForGuestResponse()))
+                resAction = GuestDnD::toMainAction(m_pState->getActionDefault());
         }
     }
@@ -393 +393 @@
         GuestDnDMsg Msg;
         Msg.setType(HOST_DND_HG_EVT_MOVE);
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             Msg.appendUInt32(0); /** @todo ContextID not used yet. */
         Msg.appendUInt32(aScreenId);
@@ -406 +406 @@
         if (RT_SUCCESS(rc))
         {
-            GuestDnDResponse *pResp = GuestDnDInst()->response();
-            if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
-                resAction = GuestDnD::toMainAction(pResp->getActionDefault());
+            GuestDnDState *pState = GuestDnDInst()->getState();
+            if (pState && RT_SUCCESS(pState->waitForGuestResponse()))
+                resAction = GuestDnD::toMainAction(pState->getActionDefault());
         }
     }
@@ -440 +440 @@
     GuestDnDMsg Msg;
     Msg.setType(HOST_DND_HG_EVT_LEAVE);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         Msg.appendUInt32(0); /** @todo ContextID not used yet. */
 
@@ -446 +446 @@
     if (RT_SUCCESS(rc))
     {
-        GuestDnDResponse *pResp = GuestDnDInst()->response();
-        if (pResp)
-            pResp->waitForGuestResponse();
+        GuestDnDState *pState = GuestDnDInst()->getState();
+        if (pState)
+            pState->waitForGuestResponse();
     }
 
@@ -516 +516 @@
         GuestDnDMsg Msg;
         Msg.setType(HOST_DND_HG_EVT_DROPPED);
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             Msg.appendUInt32(0); /** @todo ContextID not used yet. */
         Msg.appendUInt32(aScreenId);
@@ -529 +529 @@
         if (RT_SUCCESS(vrc))
         {
-            GuestDnDResponse *pResp = GuestDnDInst()->response();
-            if (pResp && RT_SUCCESS(pResp->waitForGuestResponse()))
+            GuestDnDState *pState = GuestDnDInst()->getState();
+            if (pState && RT_SUCCESS(pState->waitForGuestResponse()))
             {
-                resAct = GuestDnD::toMainAction(pResp->getActionDefault());
-
-                GuestDnDMIMEList lstFormats = pResp->formats();
+                resAct = GuestDnD::toMainAction(pState->getActionDefault());
+
+                GuestDnDMIMEList lstFormats = pState->formats();
                 if (lstFormats.size() == 1) /* Exactly one format to use specified? */
                 {
@@ -606 +606 @@
 
     /* Reset progress object. */
-    GuestDnDResponse *pResp = GuestDnDInst()->response();
-    AssertPtr(pResp);
-    HRESULT hr = pResp->resetProgress(m_pGuest);
+    GuestDnDState *pState = GuestDnDInst()->getState();
+    AssertPtr(pState);
+    HRESULT hr = pState->resetProgress(m_pGuest);
     if (FAILED(hr))
         return hr;
@@ -619 +619 @@
 
         mData.mSendCtx.pTarget   = this;
-        mData.mSendCtx.pResp     = pResp;
+        mData.mSendCtx.pState    = pState;
         mData.mSendCtx.uScreenID = aScreenId;
 
@@ -654 +654 @@
 
         /* Return progress to caller. */
-        hr = pResp->queryProgressTo(aProgress.asOutParam());
+        hr = pState->queryProgressTo(aProgress.asOutParam());
         ComAssertComRC(hr);
     }
@@ -835 +835 @@
     const char   *pcszFmt = pCtx->Meta.strFmt.c_str();
 
-    LogFlowFunc(("uProtoVer=%RU32, szFmt=%s, cbFmt=%RU32, cbData=%zu\n", m_pResp->m_uProtocolVersion, pcszFmt, cbFmt, cbData));
+    LogFlowFunc(("uProtoVer=%RU32, szFmt=%s, cbFmt=%RU32, cbData=%zu\n", m_pState->m_uProtocolVersion, pcszFmt, cbFmt, cbData));
 
     LogRel2(("DnD: Sending meta data to guest as '%s' (%zu bytes)\n", pcszFmt, cbData));
@@ -853 +853 @@
         Msg.setType(HOST_DND_HG_SND_DATA);
 
-        if (m_pResp->m_uProtocolVersion < 3)
+        if (m_pState->m_uProtocolVersion < 3)
         {
             Msg.appendUInt32(pCtx->uScreenID);                                 /* uScreenId */
@@ -883 +883 @@
     if (RT_SUCCESS(rc))
     {
-        rc = updateProgress(pCtx, pCtx->pResp, (uint32_t)pCtx->Meta.cbData);
+        rc = updateProgress(pCtx, pCtx->pState, (uint32_t)pCtx->Meta.cbData);
         AssertRC(rc);
     }
@@ -901 +901 @@
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
-    if (m_pResp->m_uProtocolVersion < 3) /* Protocol < v3 did not support this, skip. */
+    if (m_pState->m_uProtocolVersion < 3) /* Protocol < v3 did not support this, skip. */
         return VINF_SUCCESS;
 
@@ -950 +950 @@
 
     pMsg->setType(HOST_DND_HG_SND_DIR);
-    if (m_pResp->m_uProtocolVersion >= 3)
+    if (m_pState->m_uProtocolVersion >= 3)
         pMsg->appendUInt32(0); /** @todo ContextID not used yet. */
     pMsg->appendString(pcszDstPath);                    /* path */
@@ -997 +997 @@
     if (RT_SUCCESS(rc))
     {
-        if (m_pResp->m_uProtocolVersion >= 2)
+        if (m_pState->m_uProtocolVersion >= 2)
         {
             if (!(pCtx->Transfer.fObjState & DND_OBJ_STATE_HAS_HDR))
@@ -1067 +1067 @@
     AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
 
-    AssertPtrReturn(pCtx->pResp, VERR_WRONG_ORDER);
+    AssertPtrReturn(pCtx->pState, VERR_WRONG_ORDER);
 
     /** @todo Don't allow concurrent reads per context! */
@@ -1079 +1079 @@
     /* Protocol version 1 sends the file path *every* time with a new file chunk.
      * In protocol version 2 we only do this once with HOST_DND_HG_SND_FILE_HDR. */
-    if (m_pResp->m_uProtocolVersion <= 1)
+    if (m_pState->m_uProtocolVersion <= 1)
     {
         const size_t cchDstPath = RTStrNLen(pcszDstPath, RTPATH_MAX);
@@ -1086 +1086 @@
         pMsg->appendUInt32((uint32_t)cchDstPath + 1); /* cbName */
     }
-    else if (m_pResp->m_uProtocolVersion >= 2)
+    else if (m_pState->m_uProtocolVersion >= 2)
     {
         pMsg->appendUInt32(0);                        /** @todo ContextID not used yet. */
@@ -1103 +1103 @@
         LogFlowFunc(("cbBufe=%zu, cbRead=%RU32\n", cbBuf, cbRead));
 
-        if (m_pResp->m_uProtocolVersion <= 1)
+        if (m_pState->m_uProtocolVersion <= 1)
         {
             pMsg->appendPointer(pvBuf, cbRead);                            /* pvData */
@@ -1114 +1114 @@
             pMsg->appendUInt32(cbRead);                                    /* cbData */
 
-            if (m_pResp->m_uProtocolVersion >= 3)
+            if (m_pState->m_uProtocolVersion >= 3)
             {
                 /** @todo Calculate checksum. */
@@ -1122 +1122 @@
         }
 
-        int rc2 = updateProgress(pCtx, pCtx->pResp, (uint32_t)cbRead);
+        int rc2 = updateProgress(pCtx, pCtx->pState, (uint32_t)cbRead);
         AssertRC(rc2);
 
@@ -1223 +1223 @@
             AssertReturn(CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.uMagic, VERR_INVALID_PARAMETER);
 
-            pCtx->pResp->reset();
+            pCtx->pState->reset();
 
             if (RT_SUCCESS(pCBData->rc))
@@ -1231 +1231 @@
             }
 
-            rc = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
-                                          GuestDnDTarget::i_guestErrorToString(pCBData->rc));
+            rc = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, pCBData->rc,
+                                           GuestDnDTarget::i_guestErrorToString(pCBData->rc));
             if (RT_SUCCESS(rc))
             {
@@ -1343 +1343 @@
     {
         /* Unregister this callback. */
-        AssertPtr(pCtx->pResp);
-        int rc2 = pCtx->pResp->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
+        AssertPtr(pCtx->pState);
+        int rc2 = pCtx->pState->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
         AssertRC(rc2);
 
@@ -1373 +1373 @@
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
-    AssertPtr(pCtx->pResp);
+    AssertPtr(pCtx->pState);
 
 #define REGISTER_CALLBACK(x)                                                 \
     do {                                                                     \
-        rc = pCtx->pResp->setCallback(x, i_sendTransferDataCallback, pCtx); \
+        rc = pCtx->pState->setCallback(x, i_sendTransferDataCallback, pCtx); \
         if (RT_FAILURE(rc))                                                  \
             return rc;                                                       \
@@ -1384 +1384 @@
 #define UNREGISTER_CALLBACK(x)                        \
     do {                                              \
-        int rc2 = pCtx->pResp->setCallback(x, NULL); \
+        int rc2 = pCtx->pState->setCallback(x, NULL); \
         AssertRC(rc2);                                \
     } while (0)
@@ -1406 +1406 @@
     /* Host callbacks. */
     REGISTER_CALLBACK(HOST_DND_HG_SND_DIR);
-    if (m_pResp->m_uProtocolVersion >= 2)
+    if (m_pState->m_uProtocolVersion >= 2)
         REGISTER_CALLBACK(HOST_DND_HG_SND_FILE_HDR);
     REGISTER_CALLBACK(HOST_DND_HG_SND_FILE_DATA);
@@ -1473 +1473 @@
          * Send the data header first.
          */
-        if (m_pResp->m_uProtocolVersion >= 3)
+        if (m_pState->m_uProtocolVersion >= 3)
             rc = i_sendMetaDataHeader(pCtx);
 
@@ -1484 +1484 @@
         if (RT_SUCCESS(rc))
         {
-            rc = waitForEvent(&pCtx->EventCallback, pCtx->pResp, msTimeout);
+            rc = waitForEvent(&pCtx->EventCallback, pCtx->pState, msTimeout);
             if (RT_SUCCESS(rc))
-                pCtx->pResp->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
+                pCtx->pState->setProgress(100, DND_PROGRESS_COMPLETE, VINF_SUCCESS);
         }
 
@@ -1501 +1501 @@
     /* Host callbacks. */
     UNREGISTER_CALLBACK(HOST_DND_HG_SND_DIR);
-    if (m_pResp->m_uProtocolVersion >= 2)
+    if (m_pState->m_uProtocolVersion >= 2)
         UNREGISTER_CALLBACK(HOST_DND_HG_SND_FILE_HDR);
     UNREGISTER_CALLBACK(HOST_DND_HG_SND_FILE_DATA);
@@ -1522 +1522 @@
             LogRel2(("DnD: Sending transfer data to guest cancelled by user\n"));
 
-            rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_CANCELLED, VINF_SUCCESS);
+            rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_CANCELLED, VINF_SUCCESS);
             AssertRC(rc2);
 
@@ -1531 +1531 @@
         {
             LogRel(("DnD: Sending transfer data to guest failed with rc=%Rrc\n", rc));
-            int rc2 = pCtx->pResp->setProgress(100, DND_PROGRESS_ERROR, rc,
-                                               GuestDnDTarget::i_hostErrorToString(rc));
+            int rc2 = pCtx->pState->setProgress(100, DND_PROGRESS_ERROR, rc,
+                                                GuestDnDTarget::i_hostErrorToString(rc));
             AssertRC(rc2);
         }
@@ -1555 +1555 @@
     AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
 
-    int rc = updateProgress(pCtx, pCtx->pResp);
+    int rc = updateProgress(pCtx, pCtx->pState);
     AssertRCReturn(rc, rc);
 
@@ -1619 +1619 @@
     {
         LogRel(("DnD: Sending raw data to guest failed with rc=%Rrc\n", rc));
-        rc2 = pCtx->pResp->setProgress(100 /* Percent */, DND_PROGRESS_ERROR, rc,
-                                       GuestDnDTarget::i_hostErrorToString(rc));
+        rc2 = pCtx->pState->setProgress(100 /* Percent */, DND_PROGRESS_ERROR, rc,
+                                        GuestDnDTarget::i_hostErrorToString(rc));
     }
     else
-        rc2 = pCtx->pResp->setProgress(100 /* Percent */, DND_PROGRESS_COMPLETE, rc);
+        rc2 = pCtx->pState->setProgress(100 /* Percent */, DND_PROGRESS_COMPLETE, rc);
     AssertRC(rc2);