Shared Clipboard: Renaming. bugref:9437

git-svn-id: https://www.virtualbox.org/svn/vbox/trunk@82846 cfe28804-0f27-0410-a406-dd0f0b0b656f

8 files changed, 115 insertions, 115 deletions

diff --git a/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp b/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
index e85e0c7059b..2fb5f6d844e 100644
--- a/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
+++ b/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp
@@ -160,16 +160,16 @@ static DECLCALLBACK(int) vboxClipboardOnTransferStartCallback(PSHCLTRANSFERCALLB
     {
         /* The IDataObject *must* be created on the same thread as our (proxy) window, so post a message to it
          * to do the stuff for us. */
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pTransfer->Events);
 
-        rc = ShClEventRegister(&pTransfer->Events, uEvent);
+        rc = ShClEventRegister(&pTransfer->Events, idEvent);
         if (RT_SUCCESS(rc))
         {
             /* Don't want to rely on SendMessage (synchronous) here, so just post and wait the event getting signalled. */
-            ::PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_TRANSFER_START, (WPARAM)pTransfer, (LPARAM)uEvent);
+            ::PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_TRANSFER_START, (WPARAM)pTransfer, (LPARAM)idEvent);
 
             PSHCLEVENTPAYLOAD pPayload;
-            rc = ShClEventWait(&pTransfer->Events, uEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
+            rc = ShClEventWait(&pTransfer->Events, idEvent, 30 * 1000 /* Timeout in ms */, &pPayload);
             if (RT_SUCCESS(rc))
             {
                 Assert(pPayload->cbData == sizeof(int));
@@ -178,7 +178,7 @@ static DECLCALLBACK(int) vboxClipboardOnTransferStartCallback(PSHCLTRANSFERCALLB
                 ShClPayloadFree(pPayload);
             }
 
-            ShClEventUnregister(&pTransfer->Events, uEvent);
+            ShClEventUnregister(&pTransfer->Events, idEvent);
         }
     }
     else
@@ -670,17 +670,17 @@ static LRESULT vboxClipboardWinProcessMsg(PSHCLCONTEXT pCtx, HWND hwnd, UINT msg
             PSHCLTRANSFER pTransfer  = (PSHCLTRANSFER)wParam;
             AssertPtr(pTransfer);
 
-            const SHCLEVENTID uEvent = (SHCLEVENTID)lParam;
+            const SHCLEVENTID idEvent = (SHCLEVENTID)lParam;
 
             Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
 
             int rcTransfer = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
 
             PSHCLEVENTPAYLOAD pPayload = NULL;
-            int rc = ShClPayloadAlloc(uEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
+            int rc = ShClPayloadAlloc(idEvent, &rcTransfer, sizeof(rcTransfer), &pPayload);
             if (RT_SUCCESS(rc))
             {
-                rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                 if (RT_FAILURE(rc))
                     ShClPayloadFree(pPayload);
             }
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
index 960e5c50f46..aab565b9132 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
@@ -207,7 +207,7 @@ int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient,
         return VINF_SUCCESS;
 #endif
 
-    return ShClSvcDataReadRequest(pClient, pFormats->Formats, NULL /* puEvent */);
+    return ShClSvcDataReadRequest(pClient, pFormats->Formats, NULL /* pidEvent */);
 }
 
 int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
index c030f3d4e0c..f0d661b8d61 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
@@ -250,7 +250,7 @@ void shClSvcClientTransfersReset(PSHCLCLIENT pClient);
  * Locking is between the (host) service thread and the platform-dependent (window) thread.
  * @{
  */
-int ShClSvcDataReadRequest(PSHCLCLIENT pClient, SHCLFORMAT fFormat, PSHCLEVENTID puEvent);
+int ShClSvcDataReadRequest(PSHCLCLIENT pClient, SHCLFORMAT fFormat, PSHCLEVENTID pidEvent);
 int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
 int ShClSvcHostReportFormats(PSHCLCLIENT pClient, SHCLFORMATS fFormats);
 uint32_t ShClSvcGetMode(void);
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp
index e45a6f45695..8d203506175 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp
@@ -124,23 +124,23 @@ DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTL
                                              VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
     if (pMsgHdr)
     {
-        SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsgHdr->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                     pCtx->pTransfer->State.uID, uEvent));
+                                                                     pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
 
         rc = shClSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayloadHdr;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent,
                                               pCtx->pTransfer->uTimeoutMs, &pPayloadHdr);
                 if (RT_SUCCESS(rc))
                 {
@@ -164,15 +164,15 @@ DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTL
                                     PSHCLCLIENTMSG pMsgEntry = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
                                                                                VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
 
-                                    uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+                                    idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
                                     HGCMSvcSetU64(&pMsgEntry->paParms[0],
                                                   VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uClientID,
-                                                                                       pCtx->pTransfer->State.uID, uEvent));
+                                                                                       pCtx->pTransfer->State.uID, idEvent));
                                     HGCMSvcSetU32(&pMsgEntry->paParms[1], 0 /* fRoots */);
                                     HGCMSvcSetU32(&pMsgEntry->paParms[2], i /* uIndex */);
 
-                                    rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+                                    rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
                                     AssertRC(rc2);
 
                                     rc = shClSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
@@ -180,7 +180,7 @@ DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTL
                                         break;
 
                                     PSHCLEVENTPAYLOAD pPayloadEntry;
-                                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
+                                    rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent,
                                                        pCtx->pTransfer->uTimeoutMs, &pPayloadEntry);
                                     if (RT_FAILURE(rc))
                                         break;
@@ -192,7 +192,7 @@ DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTL
 
                                     ShClPayloadFree(pPayloadEntry);
 
-                                    ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                                    ShClEventUnregister(&pCtx->pTransfer->Events, idEvent);
 
                                     if (RT_FAILURE(rc))
                                         break;
@@ -219,7 +219,7 @@ DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTL
                 }
             }
 
-            ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
+            ShClEventUnregister(&pCtx->pTransfer->Events, idEvent);
         }
     }
     else
@@ -243,10 +243,10 @@ DECLCALLBACK(int) shClSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
                                           VBOX_SHCL_CPARMS_LIST_OPEN);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
-                                                        uEvent);
+                                                        idEvent);
 
         rc = shClSvcTransferSetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
         if (RT_SUCCESS(rc))
@@ -254,14 +254,14 @@ DECLCALLBACK(int) shClSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
             rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
             if (RT_SUCCESS(rc))
             {
-                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
                 AssertRC(rc2);
 
                 rc = shClSvcClientWakeup(pClient);
                 if (RT_SUCCESS(rc))
                 {
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                    rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
                         Assert(pPayload->cbData == sizeof(SHCLREPLY));
@@ -279,7 +279,7 @@ DECLCALLBACK(int) shClSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
                     }
                 }
 
-                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                ShClEventUnregister(&pCtx->pTransfer->Events, idEvent);
             }
         }
     }
@@ -303,10 +303,10 @@ DECLCALLBACK(int) shClSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTH
                                           VBOX_SHCL_CPARMS_LIST_CLOSE);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
-                                                        uEvent);
+                                                        idEvent);
 
         rc = shClSvcTransferSetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
         if (RT_SUCCESS(rc))
@@ -314,19 +314,19 @@ DECLCALLBACK(int) shClSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTH
             rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
             if (RT_SUCCESS(rc))
             {
-                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+                int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
                 AssertRC(rc2);
 
                 rc = shClSvcClientWakeup(pClient);
                 if (RT_SUCCESS(rc))
                 {
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                    rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                     if (RT_SUCCESS(rc))
                         ShClPayloadFree(pPayload);
                 }
 
-                ShClEventUnregister(&pCtx->pTransfer->Events, uEvent);
+                ShClEventUnregister(&pCtx->pTransfer->Events, idEvent);
             }
         }
     }
@@ -351,24 +351,24 @@ DECLCALLBACK(int) shClSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
                                           VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
         HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
 
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent,
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent,
                                    pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -412,24 +412,24 @@ DECLCALLBACK(int) shClSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
                                           VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
         HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fInfo */);
 
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(pPayload->cbData == sizeof(SHCLLISTENTRY));
@@ -472,14 +472,14 @@ int shClSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS p
                                           VBOX_SHCL_CPARMS_OBJ_OPEN);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
 
         const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */
         HGCMSvcSetU32(&pMsg->paParms[2], cbPath);
         HGCMSvcSetPv (&pMsg->paParms[3], pCreateParms->pszPath, cbPath);
@@ -488,14 +488,14 @@ int shClSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS p
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(pPayload->cbData == sizeof(SHCLREPLY));
@@ -534,23 +534,23 @@ int shClSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
                                           VBOX_SHCL_CPARMS_OBJ_CLOSE);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
 
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(pPayload->cbData == sizeof(SHCLREPLY));
@@ -590,10 +590,10 @@ int shClSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
                                           VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
         HGCMSvcSetU32(&pMsg->paParms[2], cbData);
         HGCMSvcSetU32(&pMsg->paParms[3], fFlags);
@@ -601,14 +601,14 @@ int shClSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     Assert(pPayload->cbData == sizeof(SHCLOBJDATACHUNK));
@@ -649,10 +649,10 @@ int shClSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
                                           VBOX_SHCL_CPARMS_OBJ_WRITE);
     if (pMsg)
     {
-        const SHCLEVENTID uEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
+        const SHCLEVENTID idEvent = ShClEventIDGenerate(&pCtx->pTransfer->Events);
 
         HGCMSvcSetU64(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                  pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, idEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
         HGCMSvcSetU64(&pMsg->paParms[2], cbData);
         HGCMSvcSetU64(&pMsg->paParms[3], fFlags);
@@ -660,14 +660,14 @@ int shClSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
         rc = shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
-            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, uEvent);
+            int rc2 = ShClEventRegister(&pCtx->pTransfer->Events, idEvent);
             AssertRC(rc2);
 
             rc = shClSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pCtx->pTransfer->Events, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                rc = ShClEventWait(&pCtx->pTransfer->Events, idEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     const uint32_t cbRead = RT_MIN(cbData, pPayload->cbData);
@@ -1261,11 +1261,11 @@ static int shClSvcTransferHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransf
                         rc = HGCMSvcGetU64(&paParms[0], &uCID);
                         if (RT_SUCCESS(rc))
                         {
-                            const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                            const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
-                            LogFlowFunc(("uCID=%RU64 -> uEvent=%RU32\n", uCID, uEvent));
+                            LogFlowFunc(("uCID=%RU64 -> idEvent=%RU32\n", uCID, idEvent));
 
-                            rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                            rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                         }
                         break;
                     }
@@ -1429,13 +1429,13 @@ int shClSvcTransferHandler(PSHCLCLIENT pClient,
                 void    *pvData = ShClTransferRootListHdrDup(&lstHdr);
                 uint32_t cbData = sizeof(SHCLROOTLISTHDR);
 
-                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                     if (RT_FAILURE(rc))
                         ShClPayloadFree(pPayload);
                 }
@@ -1474,13 +1474,13 @@ int shClSvcTransferHandler(PSHCLCLIENT pClient,
                 void    *pvData = ShClTransferRootListEntryDup(&lstEntry);
                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
 
-                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                     if (RT_FAILURE(rc))
                         ShClPayloadFree(pPayload);
                 }
@@ -1549,13 +1549,13 @@ int shClSvcTransferHandler(PSHCLCLIENT pClient,
                     void    *pvData = ShClTransferListHdrDup(&hdrList);
                     uint32_t cbData = sizeof(SHCLLISTHDR);
 
-                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                    rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                        rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                         if (RT_FAILURE(rc))
                             ShClPayloadFree(pPayload);
                     }
@@ -1598,13 +1598,13 @@ int shClSvcTransferHandler(PSHCLCLIENT pClient,
                     void    *pvData = ShClTransferListEntryDup(&entryList);
                     uint32_t cbData = sizeof(SHCLLISTENTRY);
 
-                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                     PSHCLEVENTPAYLOAD pPayload;
-                    rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                    rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
                     {
-                        rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                        rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                         if (RT_FAILURE(rc))
                             ShClPayloadFree(pPayload);
                     }
@@ -1710,13 +1710,13 @@ int shClSvcTransferHandler(PSHCLCLIENT pClient,
                 void    *pvData = ShClTransferObjDataChunkDup(&dataChunk);
                 uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
 
-                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = ShClEventSignal(&pTransfer->Events, uEvent, pPayload);
+                    rc = ShClEventSignal(&pTransfer->Events, idEvent, pPayload);
                     if (RT_FAILURE(rc))
                         ShClPayloadFree(pPayload);
                 }
@@ -1976,24 +1976,24 @@ int shClSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTran
  * @param   pTransfer           Transfer to report status for.
  * @param   uStatus             Status to report.
  * @param   rcTransfer          Result code to report. Optional and depending on status.
- * @param   puEvent             Where to store the created wait event. Optional.
+ * @param   pidEvent             Where to store the created wait event. Optional.
  */
 int shClSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus,
-                              int rcTransfer, PSHCLEVENTID puEvent)
+                              int rcTransfer, PSHCLEVENTID pidEvent)
 {
     AssertPtrReturn(pClient,   VERR_INVALID_POINTER);
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
-    /* puEvent is optional. */
+    /* pidEvent is optional. */
 
     PSHCLCLIENTMSG pMsgReadData = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
                                                   VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     if (!pMsgReadData)
         return VERR_NO_MEMORY;
 
-    const SHCLEVENTID uEvent = ShClEventIDGenerate(&pTransfer->Events);
+    const SHCLEVENTID idEvent = ShClEventIDGenerate(&pTransfer->Events);
 
     HGCMSvcSetU64(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                      pTransfer->State.uID, uEvent));
+                                                                      pTransfer->State.uID, idEvent));
     HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
     HGCMSvcSetU32(&pMsgReadData->paParms[2], uStatus);
     HGCMSvcSetU32(&pMsgReadData->paParms[3], (uint32_t)rcTransfer); /** @todo uint32_t vs. int. */
@@ -2002,7 +2002,7 @@ int shClSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCL
     int rc = shClSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     if (RT_SUCCESS(rc))
     {
-        rc = ShClEventRegister(&pTransfer->Events, uEvent);
+        rc = ShClEventRegister(&pTransfer->Events, idEvent);
         if (RT_SUCCESS(rc))
         {
             rc = shClSvcClientWakeup(pClient);
@@ -2011,11 +2011,11 @@ int shClSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCL
                 LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
                          ShClTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
 
-                if (puEvent)
-                    *puEvent = uEvent;
+                if (pidEvent)
+                    *pidEvent = idEvent;
             }
             else
-                ShClEventUnregister(&pTransfer->Events, uEvent);
+                ShClEventUnregister(&pTransfer->Events, idEvent);
         }
     }
 
@@ -2107,17 +2107,17 @@ int shClSvcTransferStart(PSHCLCLIENT pClient,
 
                             if (RT_SUCCESS(rc))
                             {
-                                SHCLEVENTID uEvent;
+                                SHCLEVENTID idEvent;
                                 rc = shClSvcTransferSendStatus(pClient, pTransfer,
                                                                SHCLTRANSFERSTATUS_INITIALIZED, VINF_SUCCESS,
-                                                               &uEvent);
+                                                               &idEvent);
                                 if (RT_SUCCESS(rc))
                                 {
                                     LogRel2(("Shared Clipboard: Waiting for start of transfer %RU32 on guest ...\n",
                                              pTransfer->State.uID));
 
                                     PSHCLEVENTPAYLOAD pPayload;
-                                    rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
+                                    rc = ShClEventWait(&pTransfer->Events, idEvent, pTransfer->uTimeoutMs, &pPayload);
                                     if (RT_SUCCESS(rc))
                                     {
                                         Assert(pPayload->cbData == sizeof(SHCLREPLY));
@@ -2182,15 +2182,15 @@ int shClSvcTransferStart(PSHCLCLIENT pClient,
  */
 int shClSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
-    SHCLEVENTID uEvent;
+    SHCLEVENTID idEvent;
     int rc = shClSvcTransferSendStatus(pClient, pTransfer,
                                        SHCLTRANSFERSTATUS_STOPPED, VINF_SUCCESS,
-                                       &uEvent);
+                                       &idEvent);
     if (RT_SUCCESS(rc))
     {
         LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU32 on guest ...\n", pTransfer->State.uID));
 
-        rc = ShClEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
+        rc = ShClEventWait(&pTransfer->Events, idEvent, pTransfer->uTimeoutMs, NULL);
         if (RT_SUCCESS(rc))
             LogRel2(("Shared Clipboard: Stopped transfer %RU32 on guest\n", pTransfer->State.uID));
     }
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
index 2c4d7a22392..286c9ccfc03 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
@@ -177,19 +177,19 @@ static int vboxClipboardSvcWinDataRead(PSHCLCONTEXT pCtx, UINT uFormat, void **p
         return VERR_NOT_SUPPORTED;
     }
 
-    SHCLEVENTID uEvent = 0;
-    int rc = ShClSvcDataReadRequest(pCtx->pClient, fFormat, &uEvent);
+    SHCLEVENTID idEvent = 0;
+    int rc = ShClSvcDataReadRequest(pCtx->pClient, fFormat, &idEvent);
     if (RT_SUCCESS(rc))
     {
         PSHCLEVENTPAYLOAD pPayload;
-        rc = ShClEventWait(&pCtx->pClient->EventSrc, uEvent, 30 * 1000, &pPayload);
+        rc = ShClEventWait(&pCtx->pClient->EventSrc, idEvent, 30 * 1000, &pPayload);
         if (RT_SUCCESS(rc))
         {
             *ppvData = pPayload ? pPayload->pvData : NULL;
             *pcbData = pPayload ? pPayload->cbData : 0;
 
             /* Detach the payload, as the caller then will own the data. */
-            ShClEventPayloadDetach(&pCtx->pClient->EventSrc, uEvent);
+            ShClEventPayloadDetach(&pCtx->pClient->EventSrc, idEvent);
             /**
              * @todo r=bird: The payload has already been detached,
              * ShClEventPayloadDetach and ShClEventWait does the exact same
@@ -197,7 +197,7 @@ static int vboxClipboardSvcWinDataRead(PSHCLCONTEXT pCtx, UINT uFormat, void **p
              */
         }
 
-        ShClEventUnregister(&pCtx->pClient->EventSrc, uEvent);
+        ShClEventUnregister(&pCtx->pClient->EventSrc, idEvent);
     }
 
     LogFlowFuncLeaveRC(rc);
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
index e84531c6de3..ab7a203878b 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
@@ -166,7 +166,7 @@ struct CLIPREADCBREQ
     /** The actual size of the data written. */
     uint32_t            *pcbActual;
     /** The request's event ID. */
-    SHCLEVENTID          uEvent;
+    SHCLEVENTID          idEvent;
 };
 
 /**
@@ -192,7 +192,7 @@ int ShClSvcImplReadData(PSHCLCLIENT pClient,
         pReq->cb        = pData->cbData;
         pReq->pcbActual = pcbActual;
         const SHCLEVENTID idEvent = ShClEventIdGenerateAndRegister(&pClient->EventSrc);
-        pReq->uEvent    = idEvent;
+        pReq->idEvent    = idEvent;
         if (idEvent)
         {
             rc = ShClX11ReadDataFromX11(&pClient->State.pCtx->X11, pData->uFormat, pReq);
@@ -282,23 +282,23 @@ DECLCALLBACK(void) ShClX11RequestFromX11CompleteCallback(PSHCLCONTEXT pCtx, int
 {
     RT_NOREF(rcCompletion);
 
-    LogFlowFunc(("rcCompletion=%Rrc, pReq=%p, pv=%p, cb=%RU32, uEvent=%RU32\n", rcCompletion, pReq, pv, cb, pReq->uEvent));
+    LogFlowFunc(("rcCompletion=%Rrc, pReq=%p, pv=%p, cb=%RU32, idEvent=%RU32\n", rcCompletion, pReq, pv, cb, pReq->idEvent));
 
     AssertMsgRC(rcCompletion, ("Clipboard data completion from X11 failed with %Rrc\n", rcCompletion));
 
-    if (pReq->uEvent != NIL_SHCLEVENTID)
+    if (pReq->idEvent != NIL_SHCLEVENTID)
     {
         int rc2;
 
         PSHCLEVENTPAYLOAD pPayload = NULL;
         if (pv && cb)
         {
-            rc2 = ShClPayloadAlloc(pReq->uEvent, pv, cb, &pPayload);
+            rc2 = ShClPayloadAlloc(pReq->idEvent, pv, cb, &pPayload);
             AssertRC(rc2);
         }
 
         RTCritSectEnter(&pCtx->pClient->CritSect);
-        rc2 = ShClEventSignal(&pCtx->pClient->EventSrc, pReq->uEvent, pPayload);
+        rc2 = ShClEventSignal(&pCtx->pClient->EventSrc, pReq->idEvent, pPayload);
         AssertRC(rc2);
         RTCritSectLeave(&pCtx->pClient->CritSect);
     }
@@ -339,22 +339,22 @@ DECLCALLBACK(int) ShClX11RequestDataForX11Callback(PSHCLCONTEXT pCtx, SHCLFORMAT
 #endif
     {
         /* Request data from the guest. */
-        SHCLEVENTID uEvent;
-        rc = ShClSvcDataReadRequest(pCtx->pClient, fFormat, &uEvent);
+        SHCLEVENTID idEvent;
+        rc = ShClSvcDataReadRequest(pCtx->pClient, fFormat, &idEvent);
         if (RT_SUCCESS(rc))
         {
             PSHCLEVENTPAYLOAD pPayload;
-            rc = ShClEventWait(&pCtx->pClient->EventSrc, uEvent, 30 * 1000, &pPayload);
+            rc = ShClEventWait(&pCtx->pClient->EventSrc, idEvent, 30 * 1000, &pPayload);
             if (RT_SUCCESS(rc))
             {
                 *ppv = pPayload ? pPayload->pvData : NULL;
                 *pcb = pPayload ? pPayload->cbData : 0;
 
                 /* Detach the payload, as the caller then will own the data. */
-                ShClEventPayloadDetach(&pCtx->pClient->EventSrc, uEvent);
+                ShClEventPayloadDetach(&pCtx->pClient->EventSrc, idEvent);
             }
 
-            ShClEventUnregister(&pCtx->pClient->EventSrc, uEvent);
+            ShClEventUnregister(&pCtx->pClient->EventSrc, idEvent);
         }
     }
 
@@ -388,22 +388,22 @@ int ShClSvcImplTransferGetRoots(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     LogFlowFuncEnter();
 
-    SHCLEVENTID uEvent = ShClEventIDGenerate(&pClient->EventSrc);
+    SHCLEVENTID idEvent = ShClEventIDGenerate(&pClient->EventSrc);
 
-    int rc = ShClEventRegister(&pClient->EventSrc, uEvent);
+    int rc = ShClEventRegister(&pClient->EventSrc, idEvent);
     if (RT_SUCCESS(rc))
     {
         CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)RTMemAllocZ(sizeof(CLIPREADCBREQ));
         if (pReq)
         {
-            pReq->uEvent = uEvent;
+            pReq->idEvent = idEvent;
 
             rc = ShClX11ReadDataFromX11(&pClient->State.pCtx->X11, VBOX_SHCL_FMT_URI_LIST, pReq);
             if (RT_SUCCESS(rc))
             {
                 /* X supplies the data asynchronously, so we need to wait for data to arrive first. */
                 PSHCLEVENTPAYLOAD pPayload;
-                rc = ShClEventWait(&pClient->EventSrc, uEvent, 30 * 1000, &pPayload);
+                rc = ShClEventWait(&pClient->EventSrc, idEvent, 30 * 1000, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
                     rc = ShClTransferRootsSet(pTransfer,
@@ -412,7 +412,7 @@ int ShClSvcImplTransferGetRoots(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
             }
         }
 
-        ShClEventUnregister(&pClient->EventSrc, uEvent);
+        ShClEventUnregister(&pClient->EventSrc, idEvent);
     }
 
     LogFlowFuncLeaveRC(rc);
diff --git a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
index 1d66df278db..d1dbe8a7be0 100644
--- a/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
+++ b/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
@@ -1217,26 +1217,26 @@ int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
 
     LogFlowFuncEnter();
 
-    SHCLEVENTID uEvent;
+    SHCLEVENTID idEvent;
     if (!(pClient->State.fGuestFeatures0 & VBOX_SHCL_GF_0_CONTEXT_ID)) /* Legacy, Guest Additions < 6.1. */
     {
         /* Older Guest Additions (<= VBox 6.0) did not have any context ID handling, so we ASSUME that the last event registered
          * is the one we want to handle (as this all was a synchronous protocol anyway). */
-        uEvent = ShClEventGetLast(&pClient->EventSrc);
+        idEvent = ShClEventGetLast(&pClient->EventSrc);
     }
     else
-        uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
+        idEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
 
     int rc = VINF_SUCCESS;
 
     PSHCLEVENTPAYLOAD pPayload = NULL;
     if (pData->cbData)
-        rc = ShClPayloadAlloc(uEvent, pData->pvData, pData->cbData, &pPayload);
+        rc = ShClPayloadAlloc(idEvent, pData->pvData, pData->cbData, &pPayload);
 
     if (RT_SUCCESS(rc))
     {
         RTCritSectEnter(&pClient->CritSect);
-        rc = ShClEventSignal(&pClient->EventSrc, uEvent, pPayload);
+        rc = ShClEventSignal(&pClient->EventSrc, idEvent, pPayload);
         RTCritSectLeave(&pClient->CritSect);
         if (RT_FAILURE(rc))
             ShClPayloadFree(pPayload);
@@ -2391,7 +2391,7 @@ static DECLCALLBACK(int) extCallback(uint32_t u32Function, uint32_t u32Format, v
 
             /* The service extension wants read data from the guest. */
             case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
-                rc = ShClSvcDataReadRequest(pClient, u32Format, NULL /* puEvent */);
+                rc = ShClSvcDataReadRequest(pClient, u32Format, NULL /* pidEvent */);
                 break;
 
             default:
diff --git a/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp b/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp
index d27393d5e17..ed57b0c762c 100644
--- a/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp
+++ b/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp
@@ -129,7 +129,7 @@ static void testSetTransferMode(void)
 /* Adds a host data read request message to the client's message queue. */
 static void testMsgAddReadData(PSHCLCLIENT pClient, uint32_t fFormat)
 {
-    int rc = ShClSvcDataReadRequest(pClient, fFormat, NULL /* puEvent */);
+    int rc = ShClSvcDataReadRequest(pClient, fFormat, NULL /* pidEvent */);
     RTTESTI_CHECK_RC_OK(rc);
 }