Changeset 80847 in vbox for trunk/src/VBox/HostServices/SharedClipboard

Timestamp:

Sep 17, 2019 9:38:16 AM (5 years ago)

Author:

vboxsync

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

133417

Message:

Shared Clipboard/URI: More renaming to make code base more uniform.

Location:

trunk/src/VBox/HostServices/SharedClipboard

Files:

• VBoxSharedClipboardSvc-darwin.cpp (modified) (2 diffs)
• VBoxSharedClipboardSvc-uri.cpp (modified) (59 diffs)
• VBoxSharedClipboardSvc-utils.cpp (modified) (4 diffs)
• VBoxSharedClipboardSvc-win.cpp (modified) (12 diffs)
• VBoxSharedClipboardSvc-x11-stubs.cpp (modified) (3 diffs)
• VBoxSharedClipboardSvc-x11.cpp (modified) (2 diffs)
• VBoxSharedClipboardSvc.cpp (modified) (46 diffs)
• darwin-pasteboard.cpp (modified) (5 diffs)
• testcase/tstClipboardServiceHost.cpp (modified) (8 diffs)

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

@@ -208 +208 @@
     LogFlowFunc(("uFormats=%02X\n", pFormats->uFormats));
 
-    if (pFormats->uFormats == VBOX_SHARED_CLIPBOARD_FMT_NONE)
+    if (pFormats->uFormats == VBOX_SHCL_FMT_NONE)
     {
         /* This is just an automatism, not a genuine announcement */
@@ -215 +215 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-    if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
+    if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST) /* No URI support yet. */
         return VINF_SUCCESS;
 #endif

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

@@ -83 +83 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
-                                                        VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
+    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ,
+                                                        VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     if (pMsgHdr)
     {
         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                    pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
@@ -124 +124 @@
                                 for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
                                 {
-                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
-                                                                                          VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
+                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
+                                                                                          VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
 
                                     uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
                                     HGCMSvcSetU32(&pMsgEntry->paParms[0],
-                                                  VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uClientID,
+                                                  VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uClientID,
                                                                                        pCtx->pTransfer->State.uID, uEvent));
                                     HGCMSvcSetU32(&pMsgEntry->paParms[1], 0 /* fRoots */);
@@ -202 +202 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_OPEN,
+                                                     VBOX_SHCL_CPARMS_LIST_OPEN);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
+        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
                                                                       uEvent);
 
@@ -260 +260 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE,
+                                                     VBOX_SHCL_CPARMS_LIST_CLOSE);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
+        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
                                                                     uEvent);
 
@@ -308 +308 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ,
+                                                     VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
@@ -369 +369 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ,
+                                                     VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
@@ -429 +429 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN,
+                                                     VBOX_SHCL_CPARMS_OBJ_OPEN);
     if (pMsg)
     {
@@ -439 +439 @@
         const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */
@@ -489 +489 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE,
+                                                     VBOX_SHCL_CPARMS_OBJ_CLOSE);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
@@ -543 +543 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_READ,
+                                                     VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
@@ -602 +602 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
-                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE,
+                                                     VBOX_SHCL_CPARMS_OBJ_WRITE);
     if (pMsg)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
@@ -703 +703 @@
     int rc;
 
-    if (cParms >= VBOX_SHARED_CLIPBOARD_CPARMS_REPLY_MIN)
+    if (cParms >= VBOX_SHCL_CPARMS_REPLY_MIN)
     {
         uint32_t cbPayload = 0;
@@ -779 +779 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_HDR)
     {
         rc = HGCMSvcGetU32(&paParms[1], &pRootLstHdr->fRoots);
@@ -805 +805 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY)
     {
         rc = HGCMSvcGetU32(&paParms[1], &pListEntry->fInfo);
@@ -842 +842 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
     {
         uint32_t cbPath   = 0;
@@ -889 +889 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
     {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
@@ -922 +922 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_CLOSE)
     {
         HGCMSvcSetU32(&paParms[0], pMsgCtx->uContextID);
@@ -950 +950 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
     {
         rc = HGCMSvcGetU64(&paParms[1], phList);
@@ -989 +989 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
     {
         /** @todo Set pvMetaFmt + cbMetaFmt. */
@@ -1024 +1024 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
     {
         rc = HGCMSvcGetU64(&paParms[1], phList);
@@ -1070 +1070 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+    if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
     {
         /** @todo Calculate chunk checksum. */
@@ -1104 +1104 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE)
+    if (cParms == VBOX_SHCL_CPARMS_OBJ_WRITE)
     {
         rc = HGCMSvcGetU64(&paParms[1], &pDataChunk->uHandle);
@@ -1142 +1142 @@
     int rc;
 
-    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ERROR)
+    if (cParms == VBOX_SHCL_CPARMS_ERROR)
     {
         rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */
@@ -1154 +1154 @@
 
 /**
- * Handles a guest reply (VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY) message.
+ * Handles a guest reply (VBOX_SHCL_GUEST_FN_REPLY) message.
  *
  * @returns VBox status code.
@@ -1199 +1199 @@
                         if (RT_SUCCESS(rc))
                         {
-                            const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                            const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                             LogFlowFunc(("uCID=%RU32 -> uEvent=%RU32\n", uCID, uEvent));
@@ -1257 +1257 @@
 
     LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
-                 pClient->State.uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
+                 pClient->State.uClientID, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
 
 #if 0
@@ -1289 +1289 @@
     switch (u32Function)
     {
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        case VBOX_SHCL_GUEST_FN_STATUS:
             break;
         default:
@@ -1329 +1329 @@
     {
 #if 0
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_STATUS)
+        case VBOX_SHCL_GUEST_FN_STATUS:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_STATUS)
                 break;
 
@@ -1409 +1409 @@
                         rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
                         if (RT_SUCCESS(rc))
-                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
+                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
                     }
 
@@ -1420 +1420 @@
             }
 
-            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
 
             if (RT_FAILURE(rc))
@@ -1429 +1429 @@
 #endif
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
+        case VBOX_SHCL_GUEST_FN_REPLY:
         {
             rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
@@ -1438 +1438 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ:
-        {
-            break;
-        }
-
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
+        {
+            break;
+        }
+
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE:
         {
             SHCLROOTLISTHDR lstHdr;
@@ -1452 +1452 @@
                 uint32_t cbData = sizeof(SHCLROOTLISTHDR);
 
-                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
@@ -1466 +1466 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
         {
     #if 0
@@ -1487 +1487 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
         {
             SHCLROOTLISTENTRY lstEntry;
@@ -1496 +1496 @@
                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
 
-                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
@@ -1510 +1510 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
+        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
         {
             SHCLLISTOPENPARMS listOpenParms;
@@ -1527 +1527 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
+        case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_CLOSE)
                 break;
 
@@ -1541 +1541 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_HDR)
                 break;
 
@@ -1558 +1558 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
         {
             SHCLLISTHDR hdrList;
@@ -1571 +1571 @@
                     uint32_t cbData = sizeof(SHCLLISTHDR);
 
-                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                     PSHCLEVENTPAYLOAD pPayload;
@@ -1586 +1586 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_LIST_ENTRY)
                 break;
 
@@ -1601 +1601 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
         {
             SHCLLISTENTRY entryList;
@@ -1614 +1614 @@
                     uint32_t cbData = sizeof(SHCLLISTENTRY);
 
-                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                    const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                     PSHCLEVENTPAYLOAD pPayload;
@@ -1630 +1630 @@
 
     #if 0
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
-        {
-            break;
-        }
-
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
-        {
-            break;
-        }
-
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
+        case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
+        {
+            break;
+        }
+
+        case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
+        {
+            break;
+        }
+
+        case VBOX_SHCL_GUEST_FN_OBJ_READ:
         {
             break;
@@ -1646 +1646 @@
     #endif
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
+        case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
         {
             SHCLOBJDATACHUNK dataChunk;
@@ -1655 +1655 @@
                 uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
 
-                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+                const SHCLEVENTID uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(uCID);
 
                 PSHCLEVENTPAYLOAD pPayload;
@@ -1671 +1671 @@
 
     #if 0
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
-        {
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_DIR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_WRITE_DIR\n"));
 
             SHCLDIRDATA dirData;
@@ -1704 +1704 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR:
-        {
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n"));
+        case VBOX_SHCL_GUEST_FN_READ_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_READ_FILE_HDR\n"));
 
             SHCLFILEHDR fileHdr;
@@ -1713 +1713 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
-        {
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHCL_GUEST_FN_WRITE_FILE_HDR\n"));
 
             if (!SharedClipboardURIObjCtxIsValid(SharedClipboardURITransferGetCurrentObjCtx(pTransfer)))
@@ -1790 +1790 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_DATA:
-        {
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
+        case VBOX_SHCL_GUEST_FN_READ_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHCL_FN_READ_FILE_DATA\n"));
 
             SHCLFILEDATA fileData;
@@ -1799 +1799 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA:
-        {
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
+        case VBOX_SHCL_GUEST_FN_WRITE_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHCL_FN_WRITE_FILE_DATA\n"));
 
             if (!SharedClipboardURIObjCtxIsValid(&pTransfer->State.ObjCtx))
@@ -1840 +1840 @@
         }
 #endif
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
+        case VBOX_SHCL_GUEST_FN_CANCEL:
         {
             LogRel2(("Shared Clipboard: Transfer canceled\n"));
@@ -1846 +1846 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
+        case VBOX_SHCL_GUEST_FN_ERROR:
         {
             int rcGuest;
@@ -1890 +1890 @@
     switch (u32Function)
     {
-        case VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL: /** @todo Implement this. */
-            break;
-
-        case VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR: /** @todo Implement this. */
+        case VBOX_SHCL_HOST_FN_CANCEL: /** @todo Implement this. */
+            break;
+
+        case VBOX_SHCL_HOST_FN_ERROR: /** @todo Implement this. */
             break;
 
@@ -2106 +2106 @@
     /* puEvent is optional. */
 
-    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS,
-                                                             VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS);
+    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS,
+                                                             VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     if (!pMsgReadData)
         return VERR_NO_MEMORY;
@@ -2113 +2113 @@
     const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
 
-    HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+    HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                   pTransfer->State.uID, uEvent));
     HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
@@ -2130 +2130 @@
             {
                 LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
-                         VBoxClipboardTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
+                         VBoxShClTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
 
                 if (puEvent)
@@ -2259 +2259 @@
                                     else
                                         LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n",
-                                                VBoxClipboardTransferStatusToStr(pReply->u.TransferStatus.uStatus),
+                                                VBoxShClTransferStatusToStr(pReply->u.TransferStatus.uStatus),
                                                 pReply->rc, pTransfer->State.uID));
                                 }

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp

@@ -42 +42 @@
 bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg)
 {
-    const bool fHostToGuest =    uMode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
-                              || uMode == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
+    const bool fHostToGuest =    uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
+                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
 
-    const bool fGuestToHost =    uMode == VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-                              || uMode == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL;
+    const bool fGuestToHost =    uMode == VBOX_SHCL_MODE_GUEST_TO_HOST
+                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
 
     bool fAllowed = false; /* If in doubt, don't allow. */
@@ -52 +52 @@
     switch (uMsg)
     {
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
+        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
+        case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
+        case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
+        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
+        case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
+        case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
+        case VBOX_SHCL_GUEST_FN_OBJ_READ:
             fAllowed = fHostToGuest;
             break;
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
+        case VBOX_SHCL_GUEST_FN_MSG_GET:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_STATUS:
+        case VBOX_SHCL_GUEST_FN_STATUS:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CANCEL:
+        case VBOX_SHCL_GUEST_FN_CANCEL:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR:
+        case VBOX_SHCL_GUEST_FN_ERROR:
             fAllowed = fHostToGuest || fGuestToHost;
             break;
@@ -101 +101 @@
     switch (uMsg)
     {
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START:
+        case VBOX_SHCL_HOST_MSG_URI_TRANSFER_START:
         {
             Assert(pClient->State.URI.fTransferStart == false);
 
-            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
+            LogFlowFunc(("VBOX_SHCL_HOST_MSG_URI_TRANSFER_START\n"));
 
-            if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
-                && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+            if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
             {
                 LogFlowFunc(("Wrong clipboard mode, skipping\n"));
@@ -139 +139 @@
         && cParms >= 2)
     {
-        HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START);
+        HGCMSvcSetU32(&paParms[0], VBOX_SHCL_HOST_MSG_URI_TRANSFER_START);
         HGCMSvcSetU32(&paParms[1], pClient->State.URI.enmTransferDir);
         pClient->State.URI.fTransferStart = false;

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp

@@ -72 +72 @@
     LogFlowFunc(("cbSrc = %d, cbDst = %d\n", cbSrc, cbDst));
 
-    if (   u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
+    if (   u32Format == VBOX_SHCL_FMT_HTML
         && SharedClipboardWinIsCFHTML((const char *)pvSrc))
     {
@@ -108 +108 @@
 
 #ifdef LOG_ENABLED
-    VBoxClipboardDbgDumpData(pvDst, cbSrc, u32Format);
+    VBoxShClDbgDumpData(pvDst, cbSrc, u32Format);
 #endif
 
@@ -288 +288 @@
             LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
 
-            if (   fFormat       == VBOX_SHARED_CLIPBOARD_FMT_NONE
+            if (   fFormat       == VBOX_SHCL_FMT_NONE
                 || pCtx->pClient == NULL)
             {
@@ -333 +333 @@
             LogFunc(("SHCL_WIN_WM_REPORT_FORMATS: fFormats=0x%x\n", fFormats));
 
-            if (fFormats == VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
+            if (fFormats == VBOX_SHCL_FMT_NONE) /* Could arrive with some older GA versions. */
                 break;
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-            if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+            if (fFormats & VBOX_SHCL_FMT_URI_LIST)
             {
                 PSHCLURITRANSFER pTransfer;
@@ -572 +572 @@
         rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
         if (   RT_SUCCESS(rc)
-            && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE)
+            && Formats.uFormats != VBOX_SHCL_FMT_NONE)
         {
             rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
@@ -741 +741 @@
         LogFunc(("Clipboard opened\n"));
 
-        if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        if (pData->uFormat & VBOX_SHCL_FMT_BITMAP)
         {
             hClip = GetClipboardData(CF_DIB);
@@ -752 +752 @@
                     LogFunc(("CF_DIB\n"));
 
-                    vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, lp, GlobalSize(hClip),
+                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_BITMAP, lp, GlobalSize(hClip),
                                                pData->pvData, pData->cbData, pcbActual);
 
@@ -763 +763 @@
             }
         }
-        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        else if (pData->uFormat & VBOX_SHCL_FMT_UNICODETEXT)
         {
             hClip = GetClipboardData(CF_UNICODETEXT);
@@ -774 +774 @@
                     LogFunc(("CF_UNICODETEXT\n"));
 
-                    vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
+                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
                                                pData->pvData, pData->cbData, pcbActual);
 
@@ -785 +785 @@
             }
         }
-        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        else if (pData->uFormat & VBOX_SHCL_FMT_HTML)
         {
             UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
@@ -797 +797 @@
                     {
                         /** @todo r=andy Add data overflow handling. */
-                        vboxClipboardSvcWinGetData(VBOX_SHARED_CLIPBOARD_FMT_HTML, lp, GlobalSize(hClip),
+                        vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_HTML, lp, GlobalSize(hClip),
                                                    pData->pvData, pData->cbData, pcbActual);
 #ifdef VBOX_STRICT
                         LogFlowFunc(("Raw HTML clipboard data from host:"));
-                        VBoxClipboardDbgDumpHtml((char *)pData->pvData, pData->cbData);
+                        VBoxShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
 #endif
                         GlobalUnlock(hClip);
@@ -813 +813 @@
         }
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+        else if (pData->uFormat & VBOX_SHCL_FMT_URI_LIST)
         {
             AssertFailed(); /** @todo */

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

@@ -39 +39 @@
 
 /** Initialise the host side of the shared clipboard - called by the hgcm layer. */
-int VBoxClipboardSvcImplInit(void)
+int VBoxShClSvcImplInit(void)
 {
     LogFlowFunc(("called, returning VINF_SUCCESS\n"));
@@ -46 +46 @@
 
 /** Terminate the host side of the shared clipboard - called by the hgcm layer. */
-void VBoxClipboardSvcImplDestroy(void)
+void VBoxShClSvcImplDestroy(void)
 {
     LogFlowFunc(("called, returning\n"));
@@ -58 +58 @@
   * @param   fHeadless          Whether headless.
   */
-int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int VBoxShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
 {
     RT_NOREF(pClient, fHeadless);

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

@@ -152 +152 @@
     RT_ZERO(formatData);
 
-    formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
+    formatData.uFormats = VBOX_SHCL_FMT_NONE;
 
     return sharedClipboardSvcFormatsReport(pClient, &formatData);
@@ -205 +205 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-    if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) /* No URI support yet. */
+    if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST) /* No URI support yet. */
         return VINF_SUCCESS;
 #endif

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

@@ -40 +40 @@
  *
  * There are currently four messages defined.  The first is
- * VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG, which waits for a message from the
+ * VBOX_SHCL_FN_GET_HOST_MSG, which waits for a message from the
  * host. If a host message is sent while the guest is not waiting, it will be
  * queued until the guest requests it. The host code only supports a single
- * simultaneous VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG call from one guest.
- *
- * The second guest message is VBOX_SHARED_CLIPBOARD_FN_FORMATS, which tells
+ * simultaneous VBOX_SHCL_FN_GET_HOST_MSG call from one guest.
+ *
+ * The second guest message is VBOX_SHCL_FN_FORMATS, which tells
  * the host that the guest has new clipboard data available.  The third is
- * VBOX_SHARED_CLIPBOARD_FN_READ_DATA, which asks the host to send its
+ * VBOX_SHCL_FN_READ_DATA, which asks the host to send its
  * clipboard data and waits until it arrives.  The host supports at most one
- * simultaneous VBOX_SHARED_CLIPBOARD_FN_READ_DATA call from a guest - if a
+ * simultaneous VBOX_SHCL_FN_READ_DATA call from a guest - if a
  * second call is made before the first has returned, the first will be
  * aborted.
  *
- * The last guest message is VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA, which is
+ * The last guest message is VBOX_SHCL_FN_WRITE_DATA, which is
  * used to send the contents of the guest clipboard to the host.  This call
  * should be used after the host has requested data from the guest.
@@ -66 +66 @@
  * Since VBox 6.1 a newer protocol (v1) has been established to also support
  * file transfers. This protocol uses a (per-client) message queue instead
- * (see VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD vs. VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG).
- *
- * To distinguish the old (legacy) or new(er) protocol, the VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT
+ * (see VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD vs. VBOX_SHCL_GUEST_FN_GET_HOST_MSG).
+ *
+ * To distinguish the old (legacy) or new(er) protocol, the VBOX_SHCL_GUEST_FN_CONNECT
  * message has been introduced. If an older guest does not send this message,
  * an appropriate translation will be done to serve older Guest Additions (< 6.1).
@@ -79 +79 @@
  * the host request.
  *
- * Also see the protocol changelog at VBoxClipboardSvc.h.
+ * Also see the protocol changelog at VBoxShClSvc.h.
  *
  * @section sec_uri_intro               Transferring files
@@ -276 +276 @@
     switch (uMode)
     {
-        case VBOX_SHARED_CLIPBOARD_MODE_OFF:
+        case VBOX_SHCL_MODE_OFF:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST:
+        case VBOX_SHCL_MODE_HOST_TO_GUEST:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST:
+        case VBOX_SHCL_MODE_GUEST_TO_HOST:
             RT_FALL_THROUGH();
-        case VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL:
+        case VBOX_SHCL_MODE_BIDIRECTIONAL:
         {
             g_uMode = uMode;
@@ -292 +292 @@
         default:
         {
-            g_uMode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+            g_uMode = VBOX_SHCL_MODE_OFF;
             break;
         }
@@ -373 +373 @@
 
 /**
- * Sets the VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT
+ * Sets the VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT
  * return parameters.
  *
@@ -401 +401 @@
 
 /**
- * Sets the VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD return parameters.
+ * Sets the VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD return parameters.
  *
  * This function does the necessary translation between the legacy protocol (v0) and the new protocols (>= v1),
@@ -421 +421 @@
     switch (pMsg->uMsg)
     {
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
-        {
-            HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
+        case VBOX_SHCL_HOST_MSG_QUIT:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_QUIT);
             HGCMSvcSetU32(&paDstParms[1], 0 /* Not used */);
             break;
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
-        {
-            HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
+        case VBOX_SHCL_HOST_MSG_READ_DATA:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_READ_DATA);
             AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */
             uint32_t uFmt;
@@ -439 +439 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
-        {
-            HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT);
+        case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
+        {
+            HGCMSvcSetU32(&paDstParms[0], VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
             AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */
             uint32_t uFmts;
@@ -473 +473 @@
 
     LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n",
-                 pMsg->uMsg, VBoxClipboardHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
+                 pMsg->uMsg, VBoxShClHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend));
 
     if (fAppend)
@@ -486 +486 @@
 
 /**
- * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT.
+ * Implements VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT and VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT.
  *
  * @returns VBox status code.
@@ -533 +533 @@
         {
             paParms[0].u.uint64 = idRestore;
-            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n",
                          pClient->State.uClientID, idRestoreCheck, idRestore));
             return VERR_VM_RESTORED;
@@ -549 +549 @@
         {
             sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
-            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
             return VINF_SUCCESS;
@@ -573 +573 @@
     pClient->Pending.cParms  = cParms;
     pClient->Pending.paParms = paParms;
-    pClient->Pending.uType   = VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT;
+    pClient->Pending.uType   = VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT;
     LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->State.uClientID));
     return VINF_HGCM_ASYNC_EXECUTE;
@@ -579 +579 @@
 
 /**
- * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD.
+ * Implements VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD.
  *
  * @returns VBox status code.
@@ -594 +594 @@
     int rc;
 
-    if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD)
+    if (cParms != VBOX_SHCL_CPARMS_GET_HOST_MSG_OLD)
     {
         rc = VERR_INVALID_PARAMETER;
@@ -611 +611 @@
 
             LogFlowFunc(("[Client %RU32] uMsg=%RU32 (%s), cParms=%RU32\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
 
@@ -636 +636 @@
             pClient->Pending.cParms  = cParms;
             pClient->Pending.paParms = paParms;
-            pClient->Pending.uType   = VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD;
+            pClient->Pending.uType   = VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD;
 
             rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
@@ -649 +649 @@
 
 /**
- * Implements VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET.
+ * Implements VBOX_SHCL_GUEST_FN_MSG_GET.
  *
  * @returns VBox status code.
@@ -684 +684 @@
         {
             LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n",
-                         pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
+                         pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms));
 
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                     pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
-                                     idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_MISMATCH);
             ASSERT_GUEST_MSG_RETURN(pFirstMsg->cParms == cParms,
                                     ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                     pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
-                                     idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms),
+                                     pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms,
+                                     idMsgExpected, VBoxShClHostMsgToStr(idMsgExpected), cParms),
                                     VERR_WRONG_PARAMETER_COUNT);
 
@@ -701 +701 @@
                 ASSERT_GUEST_MSG_RETURN(pFirstMsg->paParms[i].type == paParms[i].type,
                                         ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->paParms[i].type,
-                                         paParms[i].type, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg)),
+                                         paParms[i].type, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg)),
                                         VERR_WRONG_PARAMETER_TYPE);
             /*
@@ -797 +797 @@
             {
                 LogFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
-                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg),
+                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
                          pFirstMsg->cParms));
 
                 bool fDonePending = false;
 
-                if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
+                if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT)
                 {
                     sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
                     fDonePending = true;
                 }
-                else if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
+                else if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
                 {
                     rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
@@ -862 +862 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                                                             VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
+    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
+                                                             VBOX_SHCL_CPARMS_READ_DATA);
     if (pMsgReadData)
     {
         const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
 
-        HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                                       pClient->Events.uID, uEvent));
         HGCMSvcSetU32(&pMsgReadData->paParms[1], pDataReq->uFmt);
@@ -908 +908 @@
     }
     else
-        uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
+        uEvent = VBOX_SHCL_CONTEXTID_GET_EVENT(pCmdCtx->uContextID);
 
     int rc = VINF_SUCCESS;
@@ -934 +934 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
+    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
     if (pMsg)
     {
         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
 
-        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
+        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
                                                                               pClient->Events.uID, uEvent));
         HGCMSvcSetU32(&pMsg->paParms[1], pFormats->uFormats);
@@ -959 +959 @@
     LogFlowFuncEnter();
 
-    if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-        && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+    if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+        && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     {
         return VERR_NOT_SUPPORTED;
@@ -993 +993 @@
     else
     {
-        if (cParms < VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
+        if (cParms < VBOX_SHCL_CPARMS_WRITE_DATA)
         {
             rc = VERR_INVALID_PARAMETER;
@@ -1063 +1063 @@
     if (RT_SUCCESS(rc))
     {
-        sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
+        sharedClipboardSvcModeSet(VBOX_SHCL_MODE_OFF);
 
         rc = SharedClipboardSvcImplInit();
@@ -1189 +1189 @@
 
     LogFunc(("u32ClientID=%RU32 (proto %RU32), fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
-             u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, paParms));
+             u32ClientID, pClient->State.uProtocolVer, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, paParms));
 
 #ifdef DEBUG
@@ -1205 +1205 @@
     switch (u32Function)
     {
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD:
+        case VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD:
         {
             rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
@@ -1213 +1213 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_CONNECT:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_CONNECT)
+        case VBOX_SHCL_GUEST_FN_CONNECT:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_CONNECT)
             {
                 rc = VERR_INVALID_PARAMETER;
@@ -1227 +1227 @@
                 rc = VERR_INVALID_PARAMETER;
             }
-            else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
+            else if (sharedClipboardSvcGetMode() == VBOX_SHCL_MODE_OFF)
             {
                 rc = VERR_ACCESS_DENIED;
@@ -1250 +1250 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
         {
             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
@@ -1256 +1256 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
+        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
         {
             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
@@ -1264 +1264 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
+        case VBOX_SHCL_GUEST_FN_MSG_GET:
         {
             rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
@@ -1272 +1272 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_FORMATS_REPORT:
+        case VBOX_SHCL_GUEST_FN_FORMATS_REPORT:
         {
             uint32_t uFormats = 0;
@@ -1313 +1313 @@
             if (RT_SUCCESS(rc))
             {
-                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
                 {
                     rc = VERR_ACCESS_DENIED;
@@ -1349 +1349 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_READ:
-        {
-            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA)
+        case VBOX_SHCL_GUEST_FN_DATA_READ:
+        {
+            if (cParms != VBOX_SHCL_CPARMS_READ_DATA)
             {
                 rc = VERR_INVALID_PARAMETER;
@@ -1364 +1364 @@
             else
             {
-                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
-                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
                 {
                     rc = VERR_ACCESS_DENIED;
@@ -1376 +1376 @@
                 {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-                    if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+                    if (uFormat == VBOX_SHCL_FMT_URI_LIST)
                     {
                         rc = sharedClipboardSvcURITransferStart(pClient, SHCLURITRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
@@ -1467 +1467 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
+        case VBOX_SHCL_GUEST_FN_DATA_WRITE:
         {
             rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
@@ -1555 +1555 @@
 
     LogFlowFunc(("u32Function=%RU32 (%s), cParms=%RU32, paParms=%p\n",
-                 u32Function, VBoxClipboardHostMsgToStr(u32Function), cParms, paParms));
+                 u32Function, VBoxShClHostMsgToStr(u32Function), cParms, paParms));
 
     switch (u32Function)
     {
-        case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE:
+        case VBOX_SHCL_HOST_FN_SET_MODE:
         {
             if (cParms != 1)
@@ -1567 +1567 @@
             else
             {
-                uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+                uint32_t u32Mode = VBOX_SHCL_MODE_OFF;
 
                 rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
@@ -1577 +1577 @@
         }
 
-        case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS:
+        case VBOX_SHCL_HOST_FN_SET_HEADLESS:
         {
             if (cParms != 1)
@@ -1670 +1670 @@
 
     /* Write Shared Clipboard saved state version. */
-    SSMR3PutU32(pSSM, VBOX_SHARED_CLIPBOARD_SSM_VER_1);
+    SSMR3PutU32(pSSM, VBOX_SHCL_SSM_VER_1);
 
     int rc = SSMR3PutStructEx(pSSM, &pClient->State, sizeof(pClient->State), 0 /*fFlags*/, &s_aShClSSMClientState[0], NULL);
@@ -1755 +1755 @@
     int rc = SSMR3GetU32(pSSM, &lenOrVer);
     AssertRCReturn(rc, rc);
-    if (lenOrVer == VBOX_SHARED_CLIPBOARD_SSM_VER_0)
+    if (lenOrVer == VBOX_SHCL_SSM_VER_0)
     {
         return svcLoadStateV0(u32ClientID, pvClient, pSSM, uVersion);
     }
-    else if (lenOrVer == VBOX_SHARED_CLIPBOARD_SSM_VER_1)
+    else if (lenOrVer == VBOX_SHCL_SSM_VER_1)
     {
         rc = SSMR3GetStructEx(pSSM, &pClient->State, sizeof(pClient->State), 0 /*fFlags*/, &s_aShClSSMClientState[0], NULL);

trunk/src/VBox/HostServices/SharedClipboard/darwin-pasteboard.cpp

@@ -128 +128 @@
                 {
                     Log(("Unicode flavor detected.\n"));
-                    *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+                    *pfFormats |= VBOX_SHCL_FMT_UNICODETEXT;
                 }
                 else if (UTTypeConformsTo(flavorType, kUTTypeBMP))
                 {
                     Log(("BMP flavor detected.\n"));
-                    *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+                    *pfFormats |= VBOX_SHCL_FMT_BITMAP;
                 }
             }
@@ -177 +177 @@
     {
         /* The guest request unicode */
-        if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
         {
             CFDataRef outData;
@@ -238 +238 @@
         }
         /* The guest request BITMAP */
-        else if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        else if (fFormat & VBOX_SHCL_FMT_BITMAP)
         {
             CFDataRef outData;
@@ -305 +305 @@
     int rc = VERR_NOT_SUPPORTED;
     /* Handle the unicode text */
-    if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+    if (fFormat & VBOX_SHCL_FMT_UNICODETEXT)
     {
         PRTUTF16 pwszSrcText = static_cast <PRTUTF16>(pv);
@@ -372 +372 @@
     }
     /* Handle the bitmap */
-    else if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+    else if (fFormat & VBOX_SHCL_FMT_BITMAP)
     {
         /* Create a full BMP from it */

trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

@@ -63 +63 @@
     RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
     /* Reset global variable which doesn't reset itself. */
-    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_OFF);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_OFF);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
     u32Mode = TestClipSvcGetMode();
-    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_OFF,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            0, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            2, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU64(&parms[0], 99);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
-                           1, parms);
-    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
-    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
+                           1, parms);
+    RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_HOST_TO_GUEST);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
     u32Mode = TestClipSvcGetMode();
-    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_HOST_TO_GUEST,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
     HGCMSvcSetU32(&parms[0], 99);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            1, parms);
     RTTESTI_CHECK_RC(rc, VERR_NOT_SUPPORTED);
     u32Mode = TestClipSvcGetMode();
-    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHARED_CLIPBOARD_MODE_OFF,
+    RTTESTI_CHECK_MSG(u32Mode == VBOX_SHCL_MODE_OFF,
                       ("u32Mode=%u\n", (unsigned) u32Mode));
     table.pfnUnload(NULL);
@@ -105 +105 @@
     int rc;
 
-    RTTestISub("Setting up VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG test");
+    RTTestISub("Setting up VBOX_SHCL_FN_GET_HOST_MSG test");
     rc = setupTable(&table);
     RTTESTI_CHECK_MSG_RETV(RT_SUCCESS(rc), ("rc=%Rrc\n", rc));
     /* Unless we are bidirectional the host message requests will be dropped. */
-    HGCMSvcSetU32(&parms[0], VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE,
+    HGCMSvcSetU32(&parms[0], VBOX_SHCL_MODE_BIDIRECTIONAL);
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
@@ -120 +120 @@
     call.rc = VERR_TRY_AGAIN;
     table.pfnConnect(NULL, 1 /* clientId */, &g_Client, 0, 0);
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
-    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -135 +135 @@
     RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
     RT_ZERO(g_Client.State);
-    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                                   VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    HGCMSvcSetU32(&parms[0], 0);
-    HGCMSvcSetU32(&parms[1], 0);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
-                  2, parms, 0);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_HTML);
+    HGCMSvcSetU32(&parms[0], 0);
+    HGCMSvcSetU32(&parms[1], 0);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+                  2, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -155 +155 @@
     HGCMSvcSetU32(&parms[1], 0);
     call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
-    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
-                  2, parms, 0);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT | VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+                  2, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -176 +176 @@
     RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
     RT_ZERO(g_Client.State);
-    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
-                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    HGCMSvcSetU32(&parms[0], 0);
-    HGCMSvcSetU32(&parms[1], 0);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
-                  2, parms, 0);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
-                  2, parms, 0);
-    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
-    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_HTML);
-    RTTESTI_CHECK_RC_OK(call.rc);
-    call.rc = VERR_TRY_AGAIN;
-    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD,
+    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHCL_HOST_MSG_READ_DATA,
+                                   VBOX_SHCL_FMT_UNICODETEXT | VBOX_SHCL_FMT_HTML);
+    HGCMSvcSetU32(&parms[0], 0);
+    HGCMSvcSetU32(&parms[1], 0);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+                  2, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_UNICODETEXT);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
+                  2, parms, 0);
+    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHCL_HOST_MSG_READ_DATA);
+    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHCL_FMT_HTML);
+    RTTESTI_CHECK_RC_OK(call.rc);
+    call.rc = VERR_TRY_AGAIN;
+    table.pfnCall(NULL, &call, 1 /* clientId */, &g_Client, VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD,
                   2, parms, 0);
     RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This call should not complete yet. */
@@ -213 +213 @@
     /* Reset global variable which doesn't reset itself. */
     HGCMSvcSetU32(&parms[0], false);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
     fHeadless = VBoxSvcClipboardGetHeadless();
     RTTESTI_CHECK_MSG(fHeadless == false, ("fHeadless=%RTbool\n", fHeadless));
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            0, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            2, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU64(&parms[0], 99);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            1, parms);
     RTTESTI_CHECK_RC(rc, VERR_INVALID_PARAMETER);
     HGCMSvcSetU32(&parms[0], true);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);
@@ -235 +235 @@
     RTTESTI_CHECK_MSG(fHeadless == true, ("fHeadless=%RTbool\n", fHeadless));
     HGCMSvcSetU32(&parms[0], 99);
-    rc = table.pfnHostCall(NULL, VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS,
+    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_HEADLESS,
                            1, parms);
     RTTESTI_CHECK_RC_OK(rc);