Changeset 80858 in vbox for trunk/src/VBox/GuestHost/SharedClipboard

Timestamp:

Sep 17, 2019 1:03:39 PM (6 years ago)

Author:

vboxsync

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

133428

Message:

Shared Clipboard/URI: More renaming (URI -> transfer).

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• ClipboardDataObjectImpl-win.cpp (modified) (13 diffs)
• ClipboardStreamImpl-win.cpp (modified) (8 diffs)
• clipboard-common.cpp (modified) (1 diff)
• clipboard-uri.cpp (modified) (132 diffs)
• clipboard-win.cpp (modified) (5 diffs)

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp

@@ -41 +41 @@
 //#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 0
 
-SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
+SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLTRANSFER pTransfer,
                                                            LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
     : m_enmStatus(Uninitialized)
@@ -226 +226 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI transfer object to handle.
+ * @param   pTransfer           Shared Clipboard transfer object to handle.
  * @param   strDir              Directory path to handle.
  */
-int SharedClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir)
+int SharedClipboardWinDataObject::readDir(PSHCLTRANSFER pTransfer, const Utf8Str &strDir)
 {
     LogFlowFunc(("strDir=%s\n", strDir.c_str()));
 
     SHCLLISTOPENPARMS openParmsList;
-    int rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
+    int rc = SharedClipboardTransferListOpenParmsInit(&openParmsList);
     if (RT_SUCCESS(rc))
     {
@@ -241 +241 @@
         {
             SHCLLISTHANDLE hList;
-            rc = SharedClipboardURITransferListOpen(pTransfer, &openParmsList, &hList);
+            rc = SharedClipboardTransferListOpen(pTransfer, &openParmsList, &hList);
             if (RT_SUCCESS(rc))
             {
@@ -247 +247 @@
 
                 SHCLLISTHDR hdrList;
-                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
+                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
                 if (RT_SUCCESS(rc))
                 {
@@ -256 +256 @@
                     {
                         SHCLLISTENTRY entryList;
-                        rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
+                        rc = SharedClipboardTransferListRead(pTransfer, hList, &entryList);
                         if (RT_SUCCESS(rc))
                         {
@@ -291 +291 @@
                 }
 
-                SharedClipboardURITransferListClose(pTransfer, hList);
+                SharedClipboardTransferListClose(pTransfer, hList);
             }
         }
 
-        SharedClipboardURIListOpenParmsDestroy(&openParmsList);
+        SharedClipboardTransferListOpenParmsDestroy(&openParmsList);
     }
 
@@ -303 +303 @@
 
 /**
- * Thread for reading URI data.
- * The data object needs the (high level, root) URI listing at the time of ::GetData(), so we need
+ * Thread for reading transfer data.
+ * The data object needs the (high level, root) transfer listing at the time of ::GetData(), so we need
  * to block and wait until we have this data (via this thread) and continue.
  *
@@ -320 +320 @@
     SharedClipboardWinDataObject *pThis = (SharedClipboardWinDataObject *)pvUser;
 
-    PSHCLURITRANSFER pTransfer = pThis->m_pTransfer;
+    PSHCLTRANSFER pTransfer = pThis->m_pTransfer;
     AssertPtr(pTransfer);
 
@@ -330 +330 @@
     LogRel2(("Shared Clipboard: Calculating transfer ...\n"));
 
-    int rc = SharedClipboardURITransferOpen(pTransfer);
+    int rc = SharedClipboardTransferOpen(pTransfer);
     if (RT_SUCCESS(rc))
     {
         PSHCLROOTLIST pRootList;
-        rc = SharedClipboardURILTransferRootsAsList(pTransfer, &pRootList);
+        rc = SharedClipboardTransferLTransferRootsAsList(pTransfer, &pRootList);
         if (RT_SUCCESS(rc))
         {
@@ -368 +368 @@
             }
 
-            SharedClipboardURIRootListFree(pRootList);
+            SharedClipboardTransferRootListFree(pRootList);
             pRootList = NULL;
 
@@ -390 +390 @@
         }
 
-        SharedClipboardURITransferClose(pTransfer);
+        SharedClipboardTransferClose(pTransfer);
     }
 
@@ -398 +398 @@
 
 /**
- * Creates a FILEGROUPDESCRIPTOR object from a given URI transfer and stores the result into an HGLOBAL object.
+ * Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard transfer and stores the result into an HGLOBAL object.
  *
  * @returns VBox status code.
- * @param   pTransfer           URI transfer to create file grou desciprtor for.
+ * @param   pTransfer           Shared Clipboard transfer to create file grou desciprtor for.
  * @param   fUnicode            Whether the FILEGROUPDESCRIPTOR object shall contain Unicode data or not.
  * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
  */
-int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer,
+int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLTRANSFER pTransfer,
                                                                         bool fUnicode, HGLOBAL *phGlobal)
 {
@@ -558 +558 @@
 
         /* The caller can call GetData() several times, so make sure we don't do the same transfer multiple times. */
-        if (SharedClipboardURITransferGetStatus(m_pTransfer) == SHCLURITRANSFERSTATUS_NONE)
-        {
-            rc = SharedClipboardURITransferPrepare(m_pTransfer);
+        if (SharedClipboardTransferGetStatus(m_pTransfer) == SHCLTRANSFERSTATUS_NONE)
+        {
+            rc = SharedClipboardTransferPrepare(m_pTransfer);
             if (RT_SUCCESS(rc))
             {
                 /* Start the transfer asynchronously in a separate thread. */
-                rc = SharedClipboardURITransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
+                rc = SharedClipboardTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
                 if (RT_SUCCESS(rc))
                 {

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp

@@ -46 +46 @@
 
 
-SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
+SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer,
                                                            const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
     : m_pParent(pParent)
     , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */
-    , m_pURITransfer(pTransfer)
+    , m_pTransfer(pTransfer)
     , m_strPath(strPath)
     , m_hObj(SHCLOBJHANDLE_INVALID)
@@ -57 +57 @@
     , m_fNotifiedComplete(false)
 {
-    AssertPtr(m_pURITransfer);
+    AssertPtr(m_pTransfer);
 
     LogFunc(("m_strPath=%s\n", m_strPath.c_str()));
@@ -185 +185 @@
     {
         if (   m_hObj == SHCLOBJHANDLE_INVALID
-            && m_pURITransfer->ProviderIface.pfnObjOpen)
+            && m_pTransfer->ProviderIface.pfnObjOpen)
         {
             SHCLOBJOPENCREATEPARMS openParms;
-            rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
+            rc = SharedClipboardTransferObjectOpenParmsInit(&openParms);
             if (RT_SUCCESS(rc))
             {
@@ -199 +199 @@
                 if (RT_SUCCESS(rc))
                 {
-                    rc = m_pURITransfer->ProviderIface.pfnObjOpen(&m_pURITransfer->ProviderCtx, &openParms, &m_hObj);
+                    rc = m_pTransfer->ProviderIface.pfnObjOpen(&m_pTransfer->ProviderCtx, &openParms, &m_hObj);
                 }
 
-                SharedClipboardURIObjectOpenParmsDestroy(&openParms);
+                SharedClipboardTransferObjectOpenParmsDestroy(&openParms);
             }
         }
@@ -219 +219 @@
             if (cbToRead)
             {
-                rc = m_pURITransfer->ProviderIface.pfnObjRead(&m_pURITransfer->ProviderCtx, m_hObj,
-                                                              pvBuffer, cbToRead, 0 /* fFlags */, &cbRead);
+                rc = m_pTransfer->ProviderIface.pfnObjRead(&m_pTransfer->ProviderCtx, m_hObj,
+                                                           pvBuffer, cbToRead, 0 /* fFlags */, &cbRead);
                 if (RT_SUCCESS(rc))
                 {
@@ -233 +233 @@
             if (fComplete)
             {
-                if (m_pURITransfer->ProviderIface.pfnObjClose)
+                if (m_pTransfer->ProviderIface.pfnObjClose)
                 {
-                    int rc2 = m_pURITransfer->ProviderIface.pfnObjClose(&m_pURITransfer->ProviderCtx, m_hObj);
+                    int rc2 = m_pTransfer->ProviderIface.pfnObjClose(&m_pTransfer->ProviderCtx, m_hObj);
                     AssertRC(rc2);
                 }
@@ -356 +356 @@
  * @returns HRESULT
  * @param   pParent             Pointer to the parent data object.
- * @param   pTransfer           Pointer to URI transfer object to use.
+ * @param   pTransfer           Pointer to Shared Clipboard transfer object to use.
  * @param   strPath             Path of object to handle for the stream.
  * @param   pObjInfo            Pointer to object information.
@@ -362 +362 @@
  */
 /* static */
-HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
+HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer,
                                              const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo,
                                              IStream **ppStream)

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

@@ -829 +829 @@
         RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA);
         RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_FORMATS_REPORT);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_TRANSFER_STATUS);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_READ);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_HDR_WRITE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_READ);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ROOT_LIST_ENTRY_WRITE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_OPEN);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_CLOSE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_READ);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_HDR_WRITE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_READ);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_LIST_ENTRY_WRITE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_OPEN);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_CLOSE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_READ);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_OBJ_WRITE);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_CANCEL);
-        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_URI_ERROR);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_STATUS);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_CANCEL);
+        RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ERROR);
     }
     return "Unknown";

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * Shared Clipboard: Common URI transfer handling code.
+ * Shared Clipboard: Common Shared Clipboard transfer handling code.
  */
 
@@ -31 +31 @@
 
 
-static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
-static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
-static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uIdx);
+static int sharedClipboardTransferThreadCreate(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
+static int sharedClipboardTransferThreadDestroy(PSHCLTRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
+static PSHCLTRANSFER sharedClipboardTransferCtxGetTransferInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
 static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
                                                  SHCLOBJHANDLE handleInitial, uint64_t *pfOpen);
@@ -40 +40 @@
 
 /**
- * Allocates a new URI root list.
- *
- * @returns Allocated URI root list on success, or NULL on failure.
- */
-PSHCLROOTLIST SharedClipboardURIRootListAlloc(void)
+ * Allocates a new transfer root list.
+ *
+ * @returns Allocated transfer root list on success, or NULL on failure.
+ */
+PSHCLROOTLIST SharedClipboardTransferRootListAlloc(void)
 {
     PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST));
@@ -52 +52 @@
 
 /**
- * Frees an URI root list.
- *
- * @param   pRootList           URI root list to free. The pointer will be
+ * Frees a transfer root list.
+ *
+ * @param   pRootList           transfer root list to free. The pointer will be
  *                              invalid after returning from this function.
  */
-void SharedClipboardURIRootListFree(PSHCLROOTLIST pRootList)
+void SharedClipboardTransferRootListFree(PSHCLROOTLIST pRootList)
 {
     if (!pRootList)
@@ -63 +63 @@
 
     for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
-        SharedClipboardURIListEntryDestroy(&pRootList->paEntries[i]);
+        SharedClipboardTransferListEntryDestroy(&pRootList->paEntries[i]);
 
     RTMemFree(pRootList);
@@ -70 +70 @@
 
 /**
- * Initializes an URI root list header.
+ * Initializes a transfer root list header.
  *
  * @returns VBox status code.
  * @param   pRootLstHdr         Root list header to initialize.
  */
-int SharedClipboardURIRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
+int SharedClipboardTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER);
@@ -85 +85 @@
 
 /**
- * Destroys an URI root list header.
+ * Destroys a transfer root list header.
  *
  * @param   pRootLstHdr         Root list header to destroy.
  */
-void SharedClipboardURIRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
+void SharedClipboardTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr)
 {
     if (!pRootLstHdr)
@@ -99 +99 @@
 
 /**
- * Duplicates an URI list header.
- *
- * @returns Duplicated URI list header on success, or NULL on failure.
+ * Duplicates a transfer list header.
+ *
+ * @returns Duplicated transfer list header on success, or NULL on failure.
  * @param   pRootLstHdr         Root list header to duplicate.
  */
-PSHCLROOTLISTHDR SharedClipboardURIRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
+PSHCLROOTLISTHDR SharedClipboardTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr)
 {
     AssertPtrReturn(pRootLstHdr, NULL);
@@ -120 +120 @@
     if (RT_FAILURE(rc))
     {
-        SharedClipboardURIRootListHdrDestroy(pRootsDup);
+        SharedClipboardTransferRootListHdrDestroy(pRootsDup);
         pRootsDup = NULL;
     }
@@ -133 +133 @@
  * @param   pListEntry          Clipboard root list entry to copy.
  */
-int SharedClipboardURIRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
-{
-    return SharedClipboardURIListEntryCopy(pDst, pSrc);
+int SharedClipboardTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc)
+{
+    return SharedClipboardTransferListEntryCopy(pDst, pSrc);
 }
 
@@ -144 +144 @@
  * @param   pListEntry          Clipboard root list entry to duplicate.
  */
-PSHCLROOTLISTENTRY SharedClipboardURIRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardURIListEntryDup(pRootListEntry);
+PSHCLROOTLISTENTRY SharedClipboardTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return SharedClipboardTransferListEntryDup(pRootListEntry);
 }
 
@@ -154 +154 @@
  * @param   pListEntry          Clipboard root list entry structure to destroy.
  */
-void SharedClipboardURIRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
-{
-    return SharedClipboardURIListEntryDestroy(pRootListEntry);
+void SharedClipboardTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry)
+{
+    return SharedClipboardTransferListEntryDestroy(pRootListEntry);
 }
 
@@ -164 +164 @@
  * @param   pInfo               List handle info structure to destroy.
  */
-void SharedClipboardURIListHandleInfoDestroy(PSHCLURILISTHANDLEINFO pInfo)
+void SharedClipboardTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -177 +177 @@
 
 /**
- * Allocates a URI list header structure.
- *
- * @returns VBox status code.
- * @param   ppListHdr           Where to store the allocated URI list header structure on success.
- */
-int SharedClipboardURIListHdrAlloc(PSHCLLISTHDR *ppListHdr)
+ * Allocates a transfer list header structure.
+ *
+ * @returns VBox status code.
+ * @param   ppListHdr           Where to store the allocated transfer list header structure on success.
+ */
+int SharedClipboardTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr)
 {
     int rc;
@@ -200 +200 @@
 
 /**
- * Frees an URI list header structure.
- *
- * @param   pListEntry          URI list header structure to free.
- */
-void SharedClipboardURIListHdrFree(PSHCLLISTHDR pListHdr)
+ * Frees a transfer list header structure.
+ *
+ * @param   pListEntry          transfer list header structure to free.
+ */
+void SharedClipboardTransferListHdrFree(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -211 +211 @@
     LogFlowFuncEnter();
 
-    SharedClipboardURIListHdrDestroy(pListHdr);
+    SharedClipboardTransferListHdrDestroy(pListHdr);
 
     RTMemFree(pListHdr);
@@ -218 +218 @@
 
 /**
- * Duplicates (allocates) an URI list header structure.
- *
- * @returns Duplicated URI list header structure on success.
- * @param   pListHdr            URI list header to duplicate.
- */
-PSHCLLISTHDR SharedClipboardURIListHdrDup(PSHCLLISTHDR pListHdr)
+ * Duplicates (allocates) a transfer list header structure.
+ *
+ * @returns Duplicated transfer list header structure on success.
+ * @param   pListHdr            transfer list header to duplicate.
+ */
+PSHCLLISTHDR SharedClipboardTransferListHdrDup(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, NULL);
@@ -237 +237 @@
 
 /**
- * Initializes an URI data header struct.
+ * Initializes a transfer data  header struct.
  *
  * @returns VBox status code.
  * @param   pListHdr            Data header struct to initialize.
  */
-int SharedClipboardURIListHdrInit(PSHCLLISTHDR pListHdr)
+int SharedClipboardTransferListHdrInit(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
@@ -248 +248 @@
     LogFlowFuncEnter();
 
-    SharedClipboardURIListHdrReset(pListHdr);
+    SharedClipboardTransferListHdrReset(pListHdr);
 
     return VINF_SUCCESS;
@@ -254 +254 @@
 
 /**
- * Destroys an URI data header struct.
+ * Destroys a transfer data  header struct.
  *
  * @param   pListHdr            Data header struct to destroy.
  */
-void SharedClipboardURIListHdrDestroy(PSHCLLISTHDR pListHdr)
+void SharedClipboardTransferListHdrDestroy(PSHCLLISTHDR pListHdr)
 {
     if (!pListHdr)
@@ -272 +272 @@
  * @param   pListHdr            SHCLListHdr structture to reset.
  */
-void SharedClipboardURIListHdrReset(PSHCLLISTHDR pListHdr)
+void SharedClipboardTransferListHdrReset(PSHCLLISTHDR pListHdr)
 {
     AssertPtrReturnVoid(pListHdr);
@@ -287 +287 @@
  * @param   pListHdr            Clipboard data header to validate.
  */
-bool SharedClipboardURIListHdrIsValid(PSHCLLISTHDR pListHdr)
+bool SharedClipboardTransferListHdrIsValid(PSHCLLISTHDR pListHdr)
 {
     RT_NOREF(pListHdr);
@@ -293 +293 @@
 }
 
-int SharedClipboardURIListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
+int SharedClipboardTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -326 +326 @@
 
 /**
- * Duplicates an URI list open parameters structure.
- *
- * @returns Duplicated URI list open parameters structure on success, or NULL on failure.
- * @param   pParms              URI list open parameters structure to duplicate.
- */
-PSHCLLISTOPENPARMS SharedClipboardURIListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
+ * Duplicates a transfer list open parameters structure.
+ *
+ * @returns Duplicated transfer list open parameters structure on success, or NULL on failure.
+ * @param   pParms              transfer list open parameters structure to duplicate.
+ */
+PSHCLLISTOPENPARMS SharedClipboardTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, NULL);
@@ -339 +339 @@
         return NULL;
 
-    int rc = SharedClipboardURIListOpenParmsCopy(pParmsDup, pParms);
+    int rc = SharedClipboardTransferListOpenParmsCopy(pParmsDup, pParms);
     if (RT_FAILURE(rc))
     {
-        SharedClipboardURIListOpenParmsDestroy(pParmsDup);
+        SharedClipboardTransferListOpenParmsDestroy(pParmsDup);
 
         RTMemFree(pParmsDup);
@@ -352 +352 @@
 
 /**
- * Initializes an URI list open parameters structure.
- *
- * @returns VBox status code.
- * @param   pParms              URI list open parameters structure to initialize.
- */
-int SharedClipboardURIListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
+ * Initializes a transfer list open parameters structure.
+ *
+ * @returns VBox status code.
+ * @param   pParms              transfer list open parameters structure to initialize.
+ */
+int SharedClipboardTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -374 +374 @@
 
 /**
- * Destroys an URI list open parameters structure.
- *
- * @param   pParms              URI list open parameters structure to destroy.
- */
-void SharedClipboardURIListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
+ * Destroys a transfer list open parameters structure.
+ *
+ * @param   pParms              transfer list open parameters structure to destroy.
+ */
+void SharedClipboardTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms)
 {
     if (!pParms)
@@ -401 +401 @@
  * @param   ppDirData           Where to return the created clipboard list entry structure on success.
  */
-int SharedClipboardURIListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
+int SharedClipboardTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry)
 {
     PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY));
@@ -407 +407 @@
         return VERR_NO_MEMORY;
 
-    int rc = SharedClipboardURIListEntryInit(pListEntry);
+    int rc = SharedClipboardTransferListEntryInit(pListEntry);
     if (RT_SUCCESS(rc))
         *ppListEntry = pListEntry;
@@ -419 +419 @@
  * @param   pListEntry         Clipboard list entry structure to free.
  */
-void SharedClipboardURIListEntryFree(PSHCLLISTENTRY pListEntry)
+void SharedClipboardTransferListEntryFree(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
         return;
 
-    SharedClipboardURIListEntryDestroy(pListEntry);
+    SharedClipboardTransferListEntryDestroy(pListEntry);
     RTMemFree(pListEntry);
 }
@@ -434 +434 @@
  * @param   pListEntry          Clipboard list entry to copy.
  */
-int SharedClipboardURIListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
+int SharedClipboardTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc)
 {
     AssertPtrReturn(pDst, VERR_INVALID_POINTER);
@@ -481 +481 @@
  * @param   pListEntry          Clipboard list entry to duplicate.
  */
-PSHCLLISTENTRY SharedClipboardURIListEntryDup(PSHCLLISTENTRY pListEntry)
+PSHCLLISTENTRY SharedClipboardTransferListEntryDup(PSHCLLISTENTRY pListEntry)
 {
     AssertPtrReturn(pListEntry, NULL);
@@ -489 +489 @@
     PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY));
     if (pListEntryDup)
-        rc = SharedClipboardURIListEntryCopy(pListEntryDup, pListEntry);
+        rc = SharedClipboardTransferListEntryCopy(pListEntryDup, pListEntry);
 
     if (RT_FAILURE(rc))
     {
-        SharedClipboardURIListEntryDestroy(pListEntryDup);
+        SharedClipboardTransferListEntryDestroy(pListEntryDup);
 
         RTMemFree(pListEntryDup);
@@ -508 +508 @@
  * @param   pListEntry          Clipboard list entry structure to initialize.
  */
-int SharedClipboardURIListEntryInit(PSHCLLISTENTRY pListEntry)
+int SharedClipboardTransferListEntryInit(PSHCLLISTENTRY pListEntry)
 {
     RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY));
@@ -529 +529 @@
  * @param   pListEntry          Clipboard list entry structure to destroy.
  */
-void SharedClipboardURIListEntryDestroy(PSHCLLISTENTRY pListEntry)
+void SharedClipboardTransferListEntryDestroy(PSHCLLISTENTRY pListEntry)
 {
     if (!pListEntry)
@@ -556 +556 @@
  * @param   pListEntry          Clipboard data chunk to validate.
  */
-bool SharedClipboardURIListEntryIsValid(PSHCLLISTENTRY pListEntry)
+bool SharedClipboardTransferListEntryIsValid(PSHCLLISTENTRY pListEntry)
 {
     RT_NOREF(pListEntry);
@@ -566 +566 @@
 
 /**
- * Initializes an URI object context.
- *
- * @returns VBox status code.
- * @param   pObjCtx             URI object context to initialize.
- */
-int SharedClipboardURIObjCtxInit(PSHCLCLIENTURIOBJCTX pObjCtx)
+ * Initializes a transfer object context.
+ *
+ * @returns VBox status code.
+ * @param   pObjCtx             transfer object context to initialize.
+ */
+int SharedClipboardTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
@@ -583 +583 @@
 
 /**
- * Destroys an URI object context.
- *
- * @param   pObjCtx             URI object context to destroy.
- */
-void SharedClipboardURIObjCtxDestroy(PSHCLCLIENTURIOBJCTX pObjCtx)
+ * Destroys a transfer object context.
+ *
+ * @param   pObjCtx             transfer object context to destroy.
+ */
+void SharedClipboardTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     AssertPtrReturnVoid(pObjCtx);
@@ -595 +595 @@
 
 /**
- * Returns if an URI object context is valid or not.
+ * Returns if a transfer object context is valid or not.
  *
  * @returns \c true if valid, \c false if not.
- * @param   pObjCtx             URI object context to check.
- */
-bool SharedClipboardURIObjCtxIsValid(PSHCLCLIENTURIOBJCTX pObjCtx)
+ * @param   pObjCtx             transfer object context to check.
+ */
+bool SharedClipboardTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx)
 {
     return (   pObjCtx
@@ -611 +611 @@
  * @param   pInfo               Object handle info structure to destroy.
  */
-void SharedClipboardURIObjectHandleInfoDestroy(PSHCLURIOBJHANDLEINFO pInfo)
+void SharedClipboardTransferObjectHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo)
 {
     if (!pInfo)
@@ -624 +624 @@
 
 /**
- * Initializes an URI object open parameters structure.
- *
- * @returns VBox status code.
- * @param   pParms              URI object open parameters structure to initialize.
- */
-int SharedClipboardURIObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
+ * Initializes a transfer object open parameters structure.
+ *
+ * @returns VBox status code.
+ * @param   pParms              transfer object open parameters structure to initialize.
+ */
+int SharedClipboardTransferObjectOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms)
 {
     AssertPtrReturn(pParms, VERR_INVALID_POINTER);
@@ -651 +651 @@
 
 /**
- * Copies an URI object open parameters structure from source to destination.
- *
- * @returns VBox status code.
- * @param   pParmsDst           Where to copy the source URI object open parameters to.
- * @param   pParmsSrc           Which source URI object open parameters to copy.
- */
-int SharedClipboardURIObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
+ * Copies a transfer object open parameters structure from source to destination.
+ *
+ * @returns VBox status code.
+ * @param   pParmsDst           Where to copy the source transfer object open parameters to.
+ * @param   pParmsSrc           Which source transfer object open parameters to copy.
+ */
+int SharedClipboardTransferObjectOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc)
 {
     int rc;
@@ -682 +682 @@
 
 /**
- * Destroys an URI object open parameters structure.
- *
- * @param   pParms              URI object open parameters structure to destroy.
- */
-void SharedClipboardURIObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
+ * Destroys a transfer object open parameters structure.
+ *
+ * @param   pParms              transfer object open parameters structure to destroy.
+ */
+void SharedClipboardTransferObjectOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms)
 {
     if (!pParms)
@@ -702 +702 @@
  *
  * @returns Pointer to object handle info if found, or NULL if not found.
- * @param   pTransfer           URI clipboard transfer to get object handle info from.
+ * @param   pTransfer           Clipboard transfer to get object handle info from.
  * @param   hObj                Object handle of the object to get handle info for.
  */
-inline PSHCLURIOBJHANDLEINFO sharedClipboardURIObjectGet(PSHCLURITRANSFER pTransfer,
-                                                                    SHCLOBJHANDLE hObj)
-{
-    PSHCLURIOBJHANDLEINFO pIt;
-    RTListForEach(&pTransfer->lstObj, pIt, SHCLURIOBJHANDLEINFO, Node)
+inline PSHCLOBJHANDLEINFO sharedClipboardTransferObjectGet(PSHCLTRANSFER pTransfer,
+                                                           SHCLOBJHANDLE hObj)
+{
+    PSHCLOBJHANDLEINFO pIt;
+    RTListForEach(&pTransfer->lstObj, pIt, SHCLOBJHANDLEINFO, Node)
     {
         if (pIt->hObj == hObj)
@@ -719 +719 @@
 
 /**
- * Opens an URI object.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to open the object for.
- * @param   pOpenCreateParms    Open / create parameters of URI object to open / create.
- * @param   phObj               Where to store the handle of URI object opened on success.
- */
-int SharedClipboardURIObjectOpen(PSHCLURITRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
-                                 PSHCLOBJHANDLE phObj)
+ * Opens a transfer object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to open the object for.
+ * @param   pOpenCreateParms    Open / create parameters of transfer object to open / create.
+ * @param   phObj               Where to store the handle of transfer object opened on success.
+ */
+int SharedClipboardTransferObjectOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms,
+                                      PSHCLOBJHANDLE phObj)
 {
     AssertPtrReturn(pTransfer,        VERR_INVALID_POINTER);
@@ -739 +739 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURIOBJHANDLEINFO pInfo
-            = (PSHCLURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHCLURIOBJHANDLEINFO));
+        PSHCLOBJHANDLEINFO pInfo
+            = (PSHCLOBJHANDLEINFO)RTMemAlloc(sizeof(SHCLOBJHANDLEINFO));
         if (pInfo)
         {
@@ -766 +766 @@
             {
                 pInfo->hObj    = pTransfer->uObjHandleNext++;
-                pInfo->enmType = SHCLURIOBJTYPE_FILE;
+                pInfo->enmType = SHCLOBJTYPE_FILE;
 
                 RTListAppend(&pTransfer->lstObj, &pInfo->Node);
@@ -794 +794 @@
 
 /**
- * Closes an URI object.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer that contains the object to close.
- * @param   hObj                Handle of URI object to close.
- */
-int SharedClipboardURIObjectClose(PSHCLURITRANSFER pTransfer, SHCLOBJHANDLE hObj)
+ * Closes a transfer object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer that contains the object to close.
+ * @param   hObj                Handle of transfer object to close.
+ */
+int SharedClipboardTransferObjectClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -808 +808 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+        PSHCLOBJHANDLEINFO pInfo = sharedClipboardTransferObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHCLURIOBJTYPE_DIRECTORY:
+                case SHCLOBJTYPE_DIRECTORY:
                 {
                     rc = RTDirClose(pInfo->u.Local.hDir);
@@ -821 +821 @@
                 }
 
-                case SHCLURIOBJTYPE_FILE:
+                case SHCLOBJTYPE_FILE:
                 {
                     rc = RTFileClose(pInfo->u.Local.hFile);
@@ -856 +856 @@
 
 /**
- * Reads from an URI object.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer that contains the object to read from.
- * @param   hObj                Handle of URI object to read from.
+ * Reads from a transfer object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer that contains the object to read from.
+ * @param   hObj                Handle of transfer object to read from.
  * @param   pvBuf               Buffer for where to store the read data.
  * @param   cbBuf               Size (in bytes) of buffer.
  * @param   pcbRead             How much bytes were read on success. Optional.
  */
-int SharedClipboardURIObjectRead(PSHCLURITRANSFER pTransfer,
-                                 SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
+int SharedClipboardTransferObjectRead(PSHCLTRANSFER pTransfer,
+                                      SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -878 +878 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+        PSHCLOBJHANDLEINFO pInfo = sharedClipboardTransferObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHCLURIOBJTYPE_FILE:
+                case SHCLOBJTYPE_FILE:
                 {
                     size_t cbRead;
@@ -918 +918 @@
 
 /**
- * Writes to an URI object.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer that contains the object to write to.
- * @param   hObj                Handle of URI object to write to.
+ * Writes to a transfer object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer that contains the object to write to.
+ * @param   hObj                Handle of transfer object to write to.
  * @param   pvBuf               Buffer of data to write.
  * @param   cbBuf               Size (in bytes) of buffer to write.
  * @param   pcbWritten          How much bytes were writtenon success. Optional.
  */
-int SharedClipboardURIObjectWrite(PSHCLURITRANSFER pTransfer,
-                                  SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
-                                  uint32_t fFlags)
+int SharedClipboardTransferObjectWrite(PSHCLTRANSFER pTransfer,
+                                       SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
+                                       uint32_t fFlags)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -940 +940 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURIOBJHANDLEINFO pInfo = sharedClipboardURIObjectGet(pTransfer, hObj);
+        PSHCLOBJHANDLEINFO pInfo = sharedClipboardTransferObjectGet(pTransfer, hObj);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHCLURIOBJTYPE_FILE:
+                case SHCLOBJTYPE_FILE:
                 {
                     rc = RTFileWrite(pInfo->u.Local.hFile, pvBuf, cbBuf, (size_t *)pcbWritten);
@@ -974 +974 @@
 
 /**
- * Duplicaates an URI object data chunk.
+ * Duplicaates a transfer object data chunk.
  *
  * @returns Duplicated object data chunk on success, or NULL on failure.
- * @param   pDataChunk          URI object data chunk to duplicate.
- */
-PSHCLOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
+ * @param   pDataChunk          transfer object data chunk to duplicate.
+ */
+PSHCLOBJDATACHUNK SharedClipboardTransferObjectDataChunkDup(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1001 +1001 @@
 
 /**
- * Destroys an URI object data chunk.
- *
- * @param   pDataChunk          URI object data chunk to destroy.
- */
-void SharedClipboardURIObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
+ * Destroys a transfer object data chunk.
+ *
+ * @param   pDataChunk          transfer object data chunk to destroy.
+ */
+void SharedClipboardTransferObjectDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
@@ -1024 +1024 @@
 
 /**
- * Frees an URI object data chunk.
- *
- * @param   pDataChunk          URI object data chunk to free. The handed-in pointer will
+ * Frees a transfer object data chunk.
+ *
+ * @param   pDataChunk          transfer object data chunk to free. The handed-in pointer will
  *                              be invalid after calling this function.
  */
-void SharedClipboardURIObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
+void SharedClipboardTransferObjectDataChunkFree(PSHCLOBJDATACHUNK pDataChunk)
 {
     if (!pDataChunk)
         return;
 
-    SharedClipboardURIObjectDataChunkDestroy(pDataChunk);
+    SharedClipboardTransferObjectDataChunkDestroy(pDataChunk);
 
     RTMemFree(pDataChunk);
@@ -1041 +1041 @@
 
 /**
- * Creates an URI clipboard transfer.
- *
- * @returns VBox status code.
- * @param   ppTransfer          Where to return the created URI transfer struct.
- *                              Must be destroyed by SharedClipboardURITransferDestroy().
- */
-int SharedClipboardURITransferCreate(PSHCLURITRANSFER *ppTransfer)
+ * Creates an Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   ppTransfer          Where to return the created Shared Clipboard transfer struct.
+ *                              Must be destroyed by SharedClipboardTransferDestroy().
+ */
+int SharedClipboardTransferCreate(PSHCLTRANSFER *ppTransfer)
 {
     AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER);
@@ -1053 +1053 @@
     LogFlowFuncEnter();
 
-    PSHCLURITRANSFER pTransfer = (PSHCLURITRANSFER)RTMemAlloc(sizeof(SHCLURITRANSFER));
+    PSHCLTRANSFER pTransfer = (PSHCLTRANSFER)RTMemAlloc(sizeof(SHCLTRANSFER));
     if (!pTransfer)
         return VERR_NO_MEMORY;
@@ -1060 +1060 @@
 
     pTransfer->State.uID       = 0;
-    pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_NONE;
-    pTransfer->State.enmDir    = SHCLURITRANSFERDIR_UNKNOWN;
+    pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_NONE;
+    pTransfer->State.enmDir    = SHCLTRANSFERDIR_UNKNOWN;
     pTransfer->State.enmSource = SHCLSOURCE_INVALID;
 
@@ -1102 +1102 @@
         if (pTransfer)
         {
-            SharedClipboardURITransferDestroy(pTransfer);
+            SharedClipboardTransferDestroy(pTransfer);
             RTMemFree(pTransfer);
         }
@@ -1112 +1112 @@
 
 /**
- * Destroys an URI clipboard transfer context struct.
- *
- * @returns VBox status code.
- * @param   pURI                URI clipboard transfer to destroy.
- */
-int SharedClipboardURITransferDestroy(PSHCLURITRANSFER pTransfer)
+ * Destroys an Clipboard transfer context struct.
+ *
+ * @returns VBox status code.
+ * @param   pTransferCtx                Clipboard transfer to destroy.
+ */
+int SharedClipboardTransferDestroy(PSHCLTRANSFER pTransfer)
 {
     if (!pTransfer)
@@ -1124 +1124 @@
     LogFlowFuncEnter();
 
-    int rc = sharedClipboardURITransferThreadDestroy(pTransfer, 30 * 1000 /* Timeout in ms */);
+    int rc = sharedClipboardTransferThreadDestroy(pTransfer, 30 * 1000 /* Timeout in ms */);
     if (RT_FAILURE(rc))
         return rc;
@@ -1132 +1132 @@
     SharedClipboardEventSourceDestroy(&pTransfer->Events);
 
-    PSHCLURILISTHANDLEINFO pItList, pItListNext;
-    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLURILISTHANDLEINFO, Node)
-    {
-        SharedClipboardURIListHandleInfoDestroy(pItList);
+    PSHCLLISTHANDLEINFO pItList, pItListNext;
+    RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLLISTHANDLEINFO, Node)
+    {
+        SharedClipboardTransferListHandleInfoDestroy(pItList);
 
         RTListNodeRemove(&pItList->Node);
@@ -1142 +1142 @@
     }
 
-    PSHCLURIOBJHANDLEINFO pItObj, pItObjNext;
-    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLURIOBJHANDLEINFO, Node)
-    {
-        SharedClipboardURIObjectHandleInfoDestroy(pItObj);
+    PSHCLOBJHANDLEINFO pItObj, pItObjNext;
+    RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLOBJHANDLEINFO, Node)
+    {
+        SharedClipboardTransferObjectHandleInfoDestroy(pItObj);
 
         RTListNodeRemove(&pItObj->Node);
@@ -1157 +1157 @@
 
 /**
- * Initializes an URI transfer object.
+ * Initializes an Shared Clipboard transfer object.
  *
  * @returns VBox status code.
@@ -1165 +1165 @@
  * @param   enmSource           Specifies the data source of the transfer.
  */
-int SharedClipboardURITransferInit(PSHCLURITRANSFER pTransfer,
-                                   uint32_t uID, SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource)
+int SharedClipboardTransferInit(PSHCLTRANSFER pTransfer,
+                                uint32_t uID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource)
 {
     pTransfer->State.uID       = uID;
@@ -1178 +1178 @@
 }
 
-int SharedClipboardURITransferOpen(PSHCLURITRANSFER pTransfer)
+int SharedClipboardTransferOpen(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1189 +1189 @@
 }
 
-int SharedClipboardURITransferClose(PSHCLURITRANSFER pTransfer)
+int SharedClipboardTransferClose(PSHCLTRANSFER pTransfer)
 {
     int rc = VINF_SUCCESS;
@@ -1204 +1204 @@
  *
  * @returns Pointer to list handle info if found, or NULL if not found.
- * @param   pTransfer           URI clipboard transfer to get list handle info from.
+ * @param   pTransfer           Clipboard transfer to get list handle info from.
  * @param   hList               List handle of the list to get handle info for.
  */
-inline PSHCLURILISTHANDLEINFO sharedClipboardURITransferListGet(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList)
-{
-    PSHCLURILISTHANDLEINFO pIt;
-    RTListForEach(&pTransfer->lstList, pIt, SHCLURILISTHANDLEINFO, Node)
+inline PSHCLLISTHANDLEINFO sharedClipboardTransferListGet(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
+{
+    PSHCLLISTHANDLEINFO pIt;
+    RTListForEach(&pTransfer->lstList, pIt, SHCLLISTHANDLEINFO, Node)
     {
         if (pIt->hList == hList)
@@ -1223 +1223 @@
  *
  * @returns New List handle on success, or SHCLLISTHANDLE_INVALID on error.
- * @param   pTransfer           URI clipboard transfer to create new list handle for.
- */
-inline SHCLLISTHANDLE sharedClipboardURITransferListHandleNew(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to create new list handle for.
+ */
+inline SHCLLISTHANDLE sharedClipboardTransferListHandleNew(PSHCLTRANSFER pTransfer)
 {
     return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */
@@ -1234 +1234 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   pTransfer           Clipboard transfer to handle.
  * @param   pOpenParms          List open parameters to use for opening.
  * @param   phList              Where to store the List handle of opened list on success.
  */
-int SharedClipboardURITransferListOpen(PSHCLURITRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
-                                       PSHCLLISTHANDLE phList)
+int SharedClipboardTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms,
+                                    PSHCLLISTHANDLE phList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -1251 +1251 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURILISTHANDLEINFO pInfo
-            = (PSHCLURILISTHANDLEINFO)RTMemAlloc(sizeof(SHCLURILISTHANDLEINFO));
+        PSHCLLISTHANDLEINFO pInfo
+            = (PSHCLLISTHANDLEINFO)RTMemAlloc(sizeof(SHCLLISTHANDLEINFO));
         if (pInfo)
         {
@@ -1263 +1263 @@
                 switch (pInfo->enmType)
                 {
-                    case SHCLURIOBJTYPE_DIRECTORY:
+                    case SHCLOBJTYPE_DIRECTORY:
                     {
                         rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
@@ -1269 +1269 @@
                     }
 
-                    case SHCLURIOBJTYPE_FILE:
+                    case SHCLOBJTYPE_FILE:
                     {
                         rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
@@ -1283 +1283 @@
                 if (RT_SUCCESS(rc))
                 {
-                    pInfo->hList = sharedClipboardURITransferListHandleNew(pTransfer);
+                    pInfo->hList = sharedClipboardTransferListHandleNew(pTransfer);
 
                     RTListAppend(&pTransfer->lstList, &pInfo->Node);
@@ -1331 +1331 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   pTransfer           Clipboard transfer to handle.
  * @param   hList               Handle of list to close.
  */
-int SharedClipboardURITransferListClose(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList)
+int SharedClipboardTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1345 +1345 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHCLURIOBJTYPE_DIRECTORY:
+                case SHCLOBJTYPE_DIRECTORY:
                 {
                     if (RTDirIsValid(pInfo->u.Local.hDir))
@@ -1393 +1393 @@
  * @param   pszPath             Path of file to add.
  */
-static int sharedClipboardURITransferListHdrAddFile(PSHCLLISTHDR pHdr, const char *pszPath)
+static int sharedClipboardTransferListHdrAddFile(PSHCLLISTHDR pHdr, const char *pszPath)
 {
     uint64_t cbSize = 0;
@@ -1417 +1417 @@
  * @param   cchDstBase          Number of charaters of destination base path.
  */
-static int sharedClipboardURITransferListHdrFromDir(PSHCLLISTHDR pHdr,
-                                                    const char *pcszSrcPath, const char *pcszDstPath,
-                                                    const char *pcszDstBase)
+static int sharedClipboardTransferListHdrFromDir(PSHCLLISTHDR pHdr,
+                                                 const char *pcszSrcPath, const char *pcszDstPath,
+                                                 const char *pcszDstBase)
 {
     AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
@@ -1468 +1468 @@
                                 if (pszDst)
                                 {
-                                    rc = sharedClipboardURITransferListHdrFromDir(pHdr, pszSrc, pszDst,
+                                    rc = sharedClipboardTransferListHdrFromDir(pHdr, pszSrc, pszDst,
                                                                                   pcszDstBase, cchDstBase);
                                     RTStrFree(pszDst);
@@ -1487 +1487 @@
                             if (pszSrc)
                             {
-                                rc = sharedClipboardURITransferListHdrAddFile(pHdr, pszSrc);
+                                rc = sharedClipboardTransferListHdrAddFile(pHdr, pszSrc);
                                 RTStrFree(pszSrc);
                             }
@@ -1511 +1511 @@
         else if (RTFS_IS_FILE(objInfo.Attr.fMode))
         {
-            rc = sharedClipboardURITransferListHdrAddFile(pHdr, pcszSrcPath);
+            rc = sharedClipboardTransferListHdrAddFile(pHdr, pcszSrcPath);
         }
         else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
@@ -1565 +1565 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   pTransfer           Clipboard transfer to handle.
  * @param   hList               Handle of list to get header for.
  * @param   pHdr                Where to store the returned list header information.
  */
-int SharedClipboardURITransferListGetHeader(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                            PSHCLLISTHDR pHdr)
+int SharedClipboardTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                         PSHCLLISTHDR pHdr)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1581 +1581 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
         if (pInfo)
         {
-            rc = SharedClipboardURIListHdrInit(pHdr);
+            rc = SharedClipboardTransferListHdrInit(pHdr);
             if (RT_SUCCESS(rc))
             {
                 switch (pInfo->enmType)
                 {
-                    case SHCLURIOBJTYPE_DIRECTORY:
+                    case SHCLOBJTYPE_DIRECTORY:
                     {
                         char *pszPathRel = sharedClipboardPathTranslate(pInfo->pszPathLocalAbs);
                         if (pszPathRel)
                         {
-                            rc = sharedClipboardURITransferListHdrFromDir(pHdr,
+                            rc = sharedClipboardTransferListHdrFromDir(pHdr,
                                                                           pszPathRel, pszPathRel, pszPathRel);
                             RTStrFree(pszPathRel);
@@ -1603 +1603 @@
                     }
 
-                    case SHCLURIOBJTYPE_FILE:
+                    case SHCLOBJTYPE_FILE:
                     {
                         pHdr->cTotalObjects = 1;
@@ -1644 +1644 @@
 
 /**
- * Returns the current URI object for a clipboard URI transfer list.
+ * Returns the current transfer object for a clipboard Shared Clipboard transfer list.
  *
  * Currently not implemented and wil return NULL.
  *
- * @returns Pointer to URI object, or NULL if not found / invalid.
- * @param   pTransfer           URI clipboard transfer to return URI object for.
- * @param   hList               Handle of URI transfer list to get object for.
+ * @returns Pointer to transfer object, or NULL if not found / invalid.
+ * @param   pTransfer           Clipboard transfer to return transfer object for.
+ * @param   hList               Handle of Shared Clipboard transfer list to get object for.
  * @param   uIdx                Index of object to get.
  */
-PSHCLURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHCLURITRANSFER pTransfer,
-                                                                    SHCLLISTHANDLE hList, uint64_t uIdx)
+PSHCLTRANSFEROBJ SharedClipboardTransferListGetObj(PSHCLTRANSFER pTransfer,
+                                                   SHCLLISTHANDLE hList, uint64_t uIdx)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -1669 +1669 @@
  *
  * @returns VBox status code or VERR_NO_MORE_FILES if the end of the list has been reached.
- * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   pTransfer           Clipboard transfer to handle.
  * @param   hList               List handle of list to read from.
  * @param   pEntry              Where to store the read information.
  */
-int SharedClipboardURITransferListRead(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                       PSHCLLISTENTRY pEntry)
+int SharedClipboardTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                    PSHCLLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1685 +1685 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLURILISTHANDLEINFO pInfo = sharedClipboardURITransferListGet(pTransfer, hList);
+        PSHCLLISTHANDLEINFO pInfo = sharedClipboardTransferListGet(pTransfer, hList);
         if (pInfo)
         {
             switch (pInfo->enmType)
             {
-                case SHCLURIOBJTYPE_DIRECTORY:
+                case SHCLOBJTYPE_DIRECTORY:
                 {
                     LogFlowFunc(("\tDirectory: %s\n", pInfo->pszPathLocalAbs));
@@ -1766 +1766 @@
                 }
 
-                case SHCLURIOBJTYPE_FILE:
+                case SHCLOBJTYPE_FILE:
                 {
                     LogFlowFunc(("\tSingle file: %s\n", pInfo->pszPathLocalAbs));
@@ -1813 +1813 @@
 }
 
-int SharedClipboardURITransferListWrite(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList,
-                                        PSHCLLISTENTRY pEntry)
+int SharedClipboardTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList,
+                                     PSHCLLISTENTRY pEntry)
 {
     RT_NOREF(pTransfer, hList, pEntry);
@@ -1833 +1833 @@
  *
  * @returns \c true if list handle is valid, \c false if not.
- * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   pTransfer           Clipboard transfer to handle.
  * @param   hList               List handle to check.
  */
-bool SharedClipboardURITransferListHandleIsValid(PSHCLURITRANSFER pTransfer, SHCLLISTHANDLE hList)
+bool SharedClipboardTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList)
 {
     bool fIsValid = false;
@@ -1842 +1842 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        fIsValid = sharedClipboardURITransferListGet(pTransfer, hList) != NULL;
+        fIsValid = sharedClipboardTransferListGet(pTransfer, hList) != NULL;
     }
     else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE)
@@ -1856 +1856 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to prepare.
- */
-int SharedClipboardURITransferPrepare(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to prepare.
+ */
+int SharedClipboardTransferPrepare(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -1866 +1866 @@
     int rc = VINF_SUCCESS;
 
-    AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_NONE,
+    AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_NONE,
                     ("Transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
 
@@ -1873 +1873 @@
     if (pTransfer->Callbacks.pfnTransferPrepare)
     {
-        SHCLURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+        SHCLTRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
         pTransfer->Callbacks.pfnTransferPrepare(&callbackData);
     }
@@ -1879 +1879 @@
     if (RT_SUCCESS(rc))
     {
-        pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_READY;
+        pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_READY;
 
         /** @todo Add checksum support. */
@@ -1889 +1889 @@
 
 /**
- * Sets the URI provider interface for a given transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           Transfer to create URI provider for.
+ * Sets the transfer provider interface for a given transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Transfer to create transfer provider for.
  * @param   pCreationCtx        Provider creation context to use for provider creation.
  */
-int SharedClipboardURITransferSetInterface(PSHCLURITRANSFER pTransfer,
-                                           PSHCLPROVIDERCREATIONCTX pCreationCtx)
+int SharedClipboardTransferSetInterface(PSHCLTRANSFER pTransfer,
+                                        PSHCLPROVIDERCREATIONCTX pCreationCtx)
 {
     AssertPtrReturn(pTransfer,    VERR_INVALID_POINTER);
@@ -1928 +1928 @@
 
 /**
- * Clears (resets) the root list of an URI transfer.
- *
- * @param   pTransfer           Transfer to clear URI root list for.
- */
-static void sharedClipboardURIListTransferRootsClear(PSHCLURITRANSFER pTransfer)
+ * Clears (resets) the root list of an Shared Clipboard transfer.
+ *
+ * @param   pTransfer           Transfer to clear transfer root list for.
+ */
+static void sharedClipboardTransferListTransferRootsClear(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -1942 +1942 @@
     }
 
-    PSHCLURILISTROOT pListRoot, pListRootNext;
-    RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHCLURILISTROOT, Node)
+    PSHCLLISTROOT pListRoot, pListRootNext;
+    RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHCLLISTROOT, Node)
     {
         RTStrFree(pListRoot->pszPathAbs);
@@ -1957 +1957 @@
 
 /**
- * Sets URI root list entries for a given transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           Transfer to set URI list entries for.
+ * Sets transfer root list entries for a given transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Transfer to set transfer list entries for.
  * @param   pszRoots            String list (separated by CRLF) of root entries to set.
  *                              All entries must have the same root path.
  * @param   cbRoots             Size (in bytes) of string list.
  */
-int SharedClipboardURILTransferSetRoots(PSHCLURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
+int SharedClipboardTransferLTransferSetRoots(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
 {
     AssertPtrReturn(pTransfer,      VERR_INVALID_POINTER);
@@ -1976 +1976 @@
     int rc = VINF_SUCCESS;
 
-    sharedClipboardURIListTransferRootsClear(pTransfer);
+    sharedClipboardTransferListTransferRootsClear(pTransfer);
 
     char  *pszPathRootAbs = NULL;
@@ -1983 +1983 @@
     for (size_t i = 0; i < lstRootEntries.size(); ++i)
     {
-        PSHCLURILISTROOT pListRoot = (PSHCLURILISTROOT)RTMemAlloc(sizeof(SHCLURILISTROOT));
+        PSHCLLISTROOT pListRoot = (PSHCLLISTROOT)RTMemAlloc(sizeof(SHCLLISTROOT));
         AssertPtrBreakStmt(pListRoot, rc = VERR_NO_MEMORY);
 
@@ -2029 +2029 @@
 
 /**
- * Resets an clipboard URI transfer.
- *
- * @param   pTransfer           URI clipboard transfer to reset.
- */
-void SharedClipboardURITransferReset(PSHCLURITRANSFER pTransfer)
+ * Resets an clipboard Shared Clipboard transfer.
+ *
+ * @param   pTransfer           Clipboard transfer to reset.
+ */
+void SharedClipboardTransferReset(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2039 +2039 @@
     LogFlowFuncEnter();
 
-    sharedClipboardURIListTransferRootsClear(pTransfer);
-}
-
-/**
- * Returns the clipboard area for a clipboard URI transfer.
+    sharedClipboardTransferListTransferRootsClear(pTransfer);
+}
+
+/**
+ * Returns the clipboard area for a clipboard Shared Clipboard transfer.
  *
  * @returns Current clipboard area, or NULL if none.
- * @param   pTransfer           URI clipboard transfer to return clipboard area for.
- */
-SharedClipboardArea *SharedClipboardURITransferGetArea(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to return clipboard area for.
+ */
+SharedClipboardArea *SharedClipboardTransferGetArea(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, NULL);
@@ -2056 +2056 @@
 
 /**
- * Returns the number of URI root list entries.
+ * Returns the number of transfer root list entries.
  *
  * @returns Root list entry count.
- * @param   pTransfer           URI clipboard transfer to return root entry count for.
- */
-uint32_t SharedClipboardURILTransferRootsCount(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to return root entry count for.
+ */
+uint32_t SharedClipboardTransferLTransferRootsCount(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2072 +2072 @@
  *
  * @returns Pointer to root list entry if found, or NULL if not found.
- * @param   pTransfer           URI clipboard transfer to get root list entry from.
+ * @param   pTransfer           Clipboard transfer to get root list entry from.
  * @param   uIdx                Index of root list entry to return.
  */
-inline PSHCLURILISTROOT sharedClipboardURILTransferRootsGet(PSHCLURITRANSFER pTransfer, uint32_t uIdx)
+inline PSHCLLISTROOT sharedClipboardTransferLTransferRootsGet(PSHCLTRANSFER pTransfer, uint32_t uIdx)
 {
     if (uIdx >= pTransfer->cRoots)
         return NULL;
 
-    PSHCLURILISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHCLURILISTROOT, Node);
+    PSHCLLISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHCLLISTROOT, Node);
     while (uIdx--)
-        pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHCLURILISTROOT, Node);
+        pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHCLLISTROOT, Node);
 
     return pIt;
@@ -2091 +2091 @@
  *
  * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to get root list entry of.
+ * @param   pTransfer           Clipboard transfer to get root list entry of.
  * @param   uIndex              Index (zero-based) of entry to get.
  * @param   pEntry              Where to store the returned entry on success.
  */
-int SharedClipboardURILTransferRootsEntry(PSHCLURITRANSFER pTransfer,
-                                          uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
+int SharedClipboardTransferLTransferRootsEntry(PSHCLTRANSFER pTransfer,
+                                               uint64_t uIndex, PSHCLROOTLISTENTRY pEntry)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2106 +2106 @@
     int rc;
 
-    PSHCLURILISTROOT pRoot = sharedClipboardURILTransferRootsGet(pTransfer, uIndex);
+    PSHCLLISTROOT pRoot = sharedClipboardTransferLTransferRootsGet(pTransfer, uIndex);
     AssertPtrReturn(pRoot, VERR_INVALID_PARAMETER);
 
@@ -2121 +2121 @@
         LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath));
 
-        rc = SharedClipboardURIListEntryInit(pEntry);
+        rc = SharedClipboardTransferListEntryInit(pEntry);
         if (RT_SUCCESS(rc))
         {
@@ -2153 +2153 @@
 
 /**
- * Returns the root entries of an URI transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to return root entries for.
+ * Returns the root entries of an Shared Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to return root entries for.
  * @param   ppRootList          Where to store the root list on success.
  */
-int SharedClipboardURILTransferRootsAsList(PSHCLURITRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
+int SharedClipboardTransferLTransferRootsAsList(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList)
 {
     AssertPtrReturn(pTransfer,  VERR_INVALID_POINTER);
@@ -2170 +2170 @@
     if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL)
     {
-        PSHCLROOTLIST pRootList = SharedClipboardURIRootListAlloc();
+        PSHCLROOTLIST pRootList = SharedClipboardTransferRootListAlloc();
         if (!pRootList)
             return VERR_NO_MEMORY;
@@ -2186 +2186 @@
                 for (uint64_t i = 0; i < cRoots; ++i)
                 {
-                    rc = SharedClipboardURILTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
+                    rc = SharedClipboardTransferLTransferRootsEntry(pTransfer, i, &paRootListEntries[i]);
                     if (RT_FAILURE(rc))
                         break;
@@ -2224 +2224 @@
  *
  * @returns The transfer's ID.
- * @param   pTransfer           URI clipboard transfer to return ID for.
- */
-SHCLURITRANSFERID SharedClipboardURITransferGetID(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to return ID for.
+ */
+SHCLTRANSFERID SharedClipboardTransferGetID(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, 0);
@@ -2237 +2237 @@
  *
  * @returns The transfer's source.
- * @param   pTransfer           URI clipboard transfer to return source for.
- */
-SHCLSOURCE SharedClipboardURITransferGetSource(PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Clipboard transfer to return source for.
+ */
+SHCLSOURCE SharedClipboardTransferGetSource(PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID);
@@ -2250 +2250 @@
  *
  * @returns Current transfer status.
- * @param   pTransfer           URI clipboard transfer to return status for.
- */
-SHCLURITRANSFERSTATUS SharedClipboardURITransferGetStatus(PSHCLURITRANSFER pTransfer)
-{
-    AssertPtrReturn(pTransfer, SHCLURITRANSFERSTATUS_NONE);
+ * @param   pTransfer           Clipboard transfer to return status for.
+ */
+SHCLTRANSFERSTATUS SharedClipboardTransferGetStatus(PSHCLTRANSFER pTransfer)
+{
+    AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE);
 
     return pTransfer->State.enmStatus;
@@ -2260 +2260 @@
 
 /**
- * Runs (starts) an URI transfer thread.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to run.
+ * Runs (starts) an Shared Clipboard transfer thread.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to run.
  * @param   pfnThreadFunc       Pointer to thread function to use.
  * @param   pvUser              Pointer to user-provided data.
  */
-int SharedClipboardURITransferRun(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
+int SharedClipboardTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
 
-    AssertMsgReturn(pTransfer->State.enmStatus == SHCLURITRANSFERSTATUS_READY,
+    AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_READY,
                     ("Wrong status (currently is %RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
 
-    int rc = sharedClipboardURITransferThreadCreate(pTransfer, pfnThreadFunc, pvUser);
+    int rc = sharedClipboardTransferThreadCreate(pTransfer, pfnThreadFunc, pvUser);
 
     LogFlowFuncLeaveRC(rc);
@@ -2281 +2281 @@
 
 /**
- * Sets or unsets the callback table to be used for a clipboard URI transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to set callbacks for.
+ * Sets or unsets the callback table to be used for a clipboard Shared Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to set callbacks for.
  * @param   pCallbacks          Pointer to callback table to set.
  */
-void SharedClipboardURITransferSetCallbacks(PSHCLURITRANSFER pTransfer,
-                                            PSHCLURITRANSFERCALLBACKS pCallbacks)
+void SharedClipboardTransferSetCallbacks(PSHCLTRANSFER pTransfer,
+                                         PSHCLTRANSFERCALLBACKS pCallbacks)
 {
     AssertPtrReturnVoid(pTransfer);
@@ -2313 +2313 @@
 
 /**
- * Creates a thread for a clipboard URI transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to create thread for.
+ * Creates a thread for a clipboard Shared Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to create thread for.
  * @param   pfnThreadFunc       Thread function to use for this transfer.
  * @param   pvUser              Pointer to user-provided data.
  */
-static int sharedClipboardURITransferThreadCreate(PSHCLURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
+static int sharedClipboardTransferThreadCreate(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser)
 
 {
@@ -2336 +2336 @@
         if (pTransfer->Thread.fStarted) /* Did the thread indicate that it started correctly? */
         {
-            pTransfer->State.enmStatus = SHCLURITRANSFERSTATUS_STARTED;
+            pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_STARTED;
         }
         else
@@ -2347 +2347 @@
 
 /**
- * Destroys a thread of a clipboard URI transfer.
- *
- * @returns VBox status code.
- * @param   pTransfer           URI clipboard transfer to destroy thread for.
+ * Destroys a thread of a clipboard Shared Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           Clipboard transfer to destroy thread for.
  * @param   uTimeoutMs          Timeout (in ms) to wait for thread creation.
  */
-static int sharedClipboardURITransferThreadDestroy(PSHCLURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs)
+static int sharedClipboardTransferThreadDestroy(PSHCLTRANSFER pTransfer, RTMSINTERVAL uTimeoutMs)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -2374 +2374 @@
 
 /**
- * Initializes a clipboard URI transfer.
- *
- * @returns VBox status code.
- * @param   pURI                URI clipboard context to initialize.
- */
-int SharedClipboardURICtxInit(PSHCLURICTX pURI)
-{
-    AssertPtrReturn(pURI, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("%p\n", pURI));
-
-    int rc = RTCritSectInit(&pURI->CritSect);
+ * Initializes a clipboard Shared Clipboard transfer.
+ *
+ * @returns VBox status code.
+ * @param   pTransferCtx                Transfer context to initialize.
+ */
+int SharedClipboardTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("%p\n", pTransferCtx));
+
+    int rc = RTCritSectInit(&pTransferCtx->CritSect);
     if (RT_SUCCESS(rc))
     {
-        RTListInit(&pURI->List);
-
-        pURI->cRunning    = 0;
-        pURI->cMaxRunning = UINT16_MAX;
-
-        RT_ZERO(pURI->bmTransferIds);
-
-        SharedClipboardURICtxReset(pURI);
+        RTListInit(&pTransferCtx->List);
+
+        pTransferCtx->cRunning    = 0;
+        pTransferCtx->cMaxRunning = UINT16_MAX;
+
+        RT_ZERO(pTransferCtx->bmTransferIds);
+
+        SharedClipboardTransferCtxReset(pTransferCtx);
     }
 
@@ -2402 +2402 @@
 
 /**
- * Destroys an URI clipboard information context struct.
- *
- * @param   pURI                URI clipboard context to destroy.
- */
-void SharedClipboardURICtxDestroy(PSHCLURICTX pURI)
-{
-    AssertPtrReturnVoid(pURI);
-
-    LogFlowFunc(("%p\n", pURI));
-
-    RTCritSectDelete(&pURI->CritSect);
-
-    PSHCLURITRANSFER pTransfer, pTransferNext;
-    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node)
-    {
-        SharedClipboardURITransferDestroy(pTransfer);
+ * Destroys an Shared Clipboard transfer context context struct.
+ *
+ * @param   pTransferCtx                Transfer context to destroy.
+ */
+void SharedClipboardTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturnVoid(pTransferCtx);
+
+    LogFlowFunc(("%p\n", pTransferCtx));
+
+    RTCritSectDelete(&pTransferCtx->CritSect);
+
+    PSHCLTRANSFER pTransfer, pTransferNext;
+    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
+    {
+        SharedClipboardTransferDestroy(pTransfer);
 
         RTListNodeRemove(&pTransfer->Node);
@@ -2425 +2425 @@
     }
 
-    pURI->cRunning   = 0;
-    pURI->cTransfers = 0;
-}
-
-/**
- * Resets an clipboard URI transfer.
- *
- * @param   pURI                URI clipboard context to reset.
- */
-void SharedClipboardURICtxReset(PSHCLURICTX pURI)
-{
-    AssertPtrReturnVoid(pURI);
+    pTransferCtx->cRunning   = 0;
+    pTransferCtx->cTransfers = 0;
+}
+
+/**
+ * Resets an clipboard Shared Clipboard transfer.
+ *
+ * @param   pTransferCtx                Transfer context to reset.
+ */
+void SharedClipboardTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturnVoid(pTransferCtx);
 
     LogFlowFuncEnter();
 
-    PSHCLURITRANSFER pTransfer;
-    RTListForEach(&pURI->List, pTransfer, SHCLURITRANSFER, Node)
-        SharedClipboardURITransferReset(pTransfer);
-}
-
-/**
- * Returns a specific URI transfer, internal version.
- *
- * @returns URI transfer, or NULL if not found.
- * @param   pURI                URI clipboard context to return transfer for.
+    PSHCLTRANSFER pTransfer;
+    RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node)
+        SharedClipboardTransferReset(pTransfer);
+}
+
+/**
+ * Returns a specific Shared Clipboard transfer, internal version.
+ *
+ * @returns Shared Clipboard transfer, or NULL if not found.
+ * @param   pTransferCtx                Transfer context to return transfer for.
  * @param   uID                 ID of the transfer to return.
  */
-static PSHCLURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHCLURICTX pURI, uint32_t uID)
-{
-    PSHCLURITRANSFER pTransfer;
-    RTListForEach(&pURI->List, pTransfer, SHCLURITRANSFER, Node) /** @todo Slow, but works for now. */
+static PSHCLTRANSFER sharedClipboardTransferCtxGetTransferInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
+{
+    PSHCLTRANSFER pTransfer;
+    RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node) /** @todo Slow, but works for now. */
     {
         if (pTransfer->State.uID == uID)
@@ -2465 +2465 @@
 
 /**
- * Returns a specific URI transfer.
- *
- * @returns URI transfer, or NULL if not found.
- * @param   pURI                URI clipboard context to return transfer for.
+ * Returns a specific Shared Clipboard transfer.
+ *
+ * @returns Shared Clipboard transfer, or NULL if not found.
+ * @param   pTransferCtx                Transfer context to return transfer for.
  * @param   uID                 ID of the transfer to return.
  */
-PSHCLURITRANSFER SharedClipboardURICtxGetTransfer(PSHCLURICTX pURI, uint32_t uID)
-{
-    return sharedClipboardURICtxGetTransferInternal(pURI, uID);
-}
-
-/**
- * Returns the number of running URI transfers.
+PSHCLTRANSFER SharedClipboardTransferCtxGetTransfer(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID)
+{
+    return sharedClipboardTransferCtxGetTransferInternal(pTransferCtx, uID);
+}
+
+/**
+ * Returns the number of running Shared Clipboard transfers.
  *
  * @returns Number of running transfers.
- * @param   pURI                URI clipboard context to return number for.
- */
-uint32_t SharedClipboardURICtxGetRunningTransfers(PSHCLURICTX pURI)
-{
-    AssertPtrReturn(pURI, 0);
-    return pURI->cRunning;
-}
-
-/**
- * Returns the number of total URI transfers.
+ * @param   pTransferCtx                Transfer context to return number for.
+ */
+uint32_t SharedClipboardTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturn(pTransferCtx, 0);
+    return pTransferCtx->cRunning;
+}
+
+/**
+ * Returns the number of total Shared Clipboard transfers.
  *
  * @returns Number of total transfers.
- * @param   pURI                URI clipboard context to return number for.
- */
-uint32_t SharedClipboardURICtxGetTotalTransfers(PSHCLURICTX pURI)
-{
-    AssertPtrReturn(pURI, 0);
-    return pURI->cTransfers;
-}
-
-/**
- * Registers an URI transfer with an URI context, i.e. allocates a transfer ID.
+ * @param   pTransferCtx                Transfer context to return number for.
+ */
+uint32_t SharedClipboardTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturn(pTransferCtx, 0);
+    return pTransferCtx->cTransfers;
+}
+
+/**
+ * Registers an Shared Clipboard transfer with a transfer context, i.e. allocates a transfer ID.
  *
  * @return  VBox status code.
  * @retval  VERR_SHCLPB_MAX_TRANSFERS_REACHED if the maximum of concurrent transfers
  *          is reached.
- * @param   pURI                URI clipboard context to register transfer to.
+ * @param   pTransferCtx        Transfer context to register transfer to.
  * @param   pTransfer           Transfer to register.
  * @param   pidTransfer         Where to return the transfer ID on success. Optional.
  */
-int SharedClipboardURICtxTransferRegister(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer, uint32_t *pidTransfer)
-{
-    AssertPtrReturn(pURI,      VERR_INVALID_POINTER);
+int SharedClipboardTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t *pidTransfer)
+{
+    AssertPtrReturn(pTransferCtx,      VERR_INVALID_POINTER);
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     /* pidTransfer is optional. */
@@ -2523 +2523 @@
     uint32_t idTransfer = RTRandU32Ex(1, VBOX_SHCL_MAX_TRANSFERS - 2);
 
-    if (!ASMBitTestAndSet(&pURI->bmTransferIds[0], idTransfer))
+    if (!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer))
     { /* likely */ }
-    else if (pURI->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
+    else if (pTransferCtx->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
     {
         /* Forward search. */
-        int iHit = ASMBitNextClear(&pURI->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS, idTransfer);
+        int iHit = ASMBitNextClear(&pTransferCtx->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS, idTransfer);
         if (iHit < 0)
-            iHit = ASMBitFirstClear(&pURI->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS);
-        AssertLogRelMsgReturn(iHit >= 0, ("Transfer count: %RU16\n", pURI->cTransfers), VERR_SHCLPB_MAX_TRANSFERS_REACHED);
+            iHit = ASMBitFirstClear(&pTransferCtx->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS);
+        AssertLogRelMsgReturn(iHit >= 0, ("Transfer count: %RU16\n", pTransferCtx->cTransfers), VERR_SHCLPB_MAX_TRANSFERS_REACHED);
         idTransfer = iHit;
-        AssertLogRelMsgReturn(!ASMBitTestAndSet(&pURI->bmTransferIds[0], idTransfer), ("idObject=%#x\n", idTransfer), VERR_INTERNAL_ERROR_2);
+        AssertLogRelMsgReturn(!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer), ("idObject=%#x\n", idTransfer), VERR_INTERNAL_ERROR_2);
     }
     else
     {
-        LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pURI->cTransfers));
+        LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers));
         return VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     }
 
-    Log2Func(("pTransfer=%p, idTransfer=%RU32 (%RU16 transfers)\n", pTransfer, idTransfer, pURI->cTransfers));
-
-    RTListAppend(&pURI->List, &pTransfer->Node);
-
-    pURI->cTransfers++;
+    Log2Func(("pTransfer=%p, idTransfer=%RU32 (%RU16 transfers)\n", pTransfer, idTransfer, pTransferCtx->cTransfers));
+
+    RTListAppend(&pTransferCtx->List, &pTransfer->Node);
+
+    pTransferCtx->cTransfers++;
 
     if (pidTransfer)
@@ -2554 +2554 @@
 
 /**
- * Registers an URI transfer with an URI context by specifying an ID for the transfer.
+ * Registers an Shared Clipboard transfer with a transfer contextby specifying an ID for the transfer.
  *
  * @return  VBox status code.
  * @retval  VERR_ALREADY_EXISTS if a transfer with the given ID already exists.
  * @retval  VERR_SHCLPB_MAX_TRANSFERS_REACHED if the maximum of concurrent transfers for this context has been reached.
- * @param   pURI                URI clipboard context to register transfer to.
+ * @param   pTransferCtx                Transfer context to register transfer to.
  * @param   pTransfer           Transfer to register.
  * @param   idTransfer          Transfer ID to use for registration.
  */
-int SharedClipboardURICtxTransferRegisterByIndex(PSHCLURICTX pURI, PSHCLURITRANSFER pTransfer, uint32_t idTransfer)
-{
-    LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pURI->cTransfers, idTransfer));
-
-    if (pURI->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
-    {
-        if (!ASMBitTestAndSet(&pURI->bmTransferIds[0], idTransfer))
-        {
-            RTListAppend(&pURI->List, &pTransfer->Node);
-
-            pURI->cTransfers++;
+int SharedClipboardTransferCtxTransferRegisterByIndex(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, uint32_t idTransfer)
+{
+    LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pTransferCtx->cTransfers, idTransfer));
+
+    if (pTransferCtx->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */)
+    {
+        if (!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer))
+        {
+            RTListAppend(&pTransferCtx->List, &pTransfer->Node);
+
+            pTransferCtx->cTransfers++;
             return VINF_SUCCESS;
         }
@@ -2580 +2580 @@
     }
 
-    LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pURI->cTransfers));
+    LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers));
     return VERR_SHCLPB_MAX_TRANSFERS_REACHED;
 }
 
 /**
- * Unregisters a transfer from an URI clipboard context.
+ * Unregisters a transfer from an Transfer context.
  *
  * @retval  VINF_SUCCESS on success.
  * @retval  VERR_NOT_FOUND if the transfer ID was not found.
- * @param   pURI                URI clipboard context to unregister transfer from.
+ * @param   pTransferCtx                Transfer context to unregister transfer from.
  * @param   idTransfer          Transfer ID to unregister.
  */
-int SharedClipboardURICtxTransferUnregister(PSHCLURICTX pURI, uint32_t idTransfer)
+int SharedClipboardTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, uint32_t idTransfer)
 {
     int rc = VINF_SUCCESS;
-    AssertMsgStmt(ASMBitTestAndClear(&pURI->bmTransferIds, idTransfer), ("idTransfer=%#x\n", idTransfer), rc = VERR_NOT_FOUND);
-
-    PSHCLURITRANSFER pTransfer = sharedClipboardURICtxGetTransferInternal(pURI, idTransfer);
+    AssertMsgStmt(ASMBitTestAndClear(&pTransferCtx->bmTransferIds, idTransfer), ("idTransfer=%#x\n", idTransfer), rc = VERR_NOT_FOUND);
+
+    PSHCLTRANSFER pTransfer = sharedClipboardTransferCtxGetTransferInternal(pTransferCtx, idTransfer);
     if (pTransfer)
     {
         RTListNodeRemove(&pTransfer->Node);
 
-        Assert(pURI->cTransfers);
-        pURI->cTransfers--;
+        Assert(pTransferCtx->cTransfers);
+        pTransferCtx->cTransfers--;
     }
     else
@@ -2616 +2616 @@
  * This can be due to transfers which only have been announced but not / never being run.
  *
- * @param   pURI                URI clipboard context to cleanup transfers for.
- */
-void SharedClipboardURICtxTransfersCleanup(PSHCLURICTX pURI)
-{
-    AssertPtrReturnVoid(pURI);
-
-    LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pURI->cTransfers, pURI->cRunning));
+ * @param   pTransferCtx                Transfer context to cleanup transfers for.
+ */
+void SharedClipboardTransferCtxTransfersCleanup(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturnVoid(pTransferCtx);
+
+    LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pTransferCtx->cTransfers, pTransferCtx->cRunning));
 
     /* Remove all transfers which are not in a running state (e.g. only announced). */
-    PSHCLURITRANSFER pTransfer, pTransferNext;
-    RTListForEachSafe(&pURI->List, pTransfer, pTransferNext, SHCLURITRANSFER, Node)
-    {
-        if (SharedClipboardURITransferGetStatus(pTransfer) != SHCLURITRANSFERSTATUS_STARTED)
-        {
-            SharedClipboardURITransferDestroy(pTransfer);
+    PSHCLTRANSFER pTransfer, pTransferNext;
+    RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
+    {
+        if (SharedClipboardTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
+        {
+            SharedClipboardTransferDestroy(pTransfer);
             RTListNodeRemove(&pTransfer->Node);
 
@@ -2636 +2636 @@
             pTransfer = NULL;
 
-            Assert(pURI->cTransfers);
-            pURI->cTransfers--;
-        }
-    }
-}
-
-/**
- * Returns whether the maximum of concurrent transfers of a specific URI context has been reached or not.
+            Assert(pTransferCtx->cTransfers);
+            pTransferCtx->cTransfers--;
+        }
+    }
+}
+
+/**
+ * Returns whether the maximum of concurrent transfers of a specific transfer contexthas been reached or not.
  *
  * @returns \c if maximum has been reached, \c false if not.
- * @param   pURI                URI clipboard context to determine value for.
- */
-bool SharedClipboardURICtxTransfersMaximumReached(PSHCLURICTX pURI)
-{
-    AssertPtrReturn(pURI, true);
-
-    LogFlowFunc(("cRunning=%RU32, cMaxRunning=%RU32\n", pURI->cRunning, pURI->cMaxRunning));
-
-    Assert(pURI->cRunning <= pURI->cMaxRunning);
-    return pURI->cRunning == pURI->cMaxRunning;
+ * @param   pTransferCtx                Transfer context to determine value for.
+ */
+bool SharedClipboardTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx)
+{
+    AssertPtrReturn(pTransferCtx, true);
+
+    LogFlowFunc(("cRunning=%RU32, cMaxRunning=%RU32\n", pTransferCtx->cRunning, pTransferCtx->cMaxRunning));
+
+    Assert(pTransferCtx->cRunning <= pTransferCtx->cMaxRunning);
+    return pTransferCtx->cRunning == pTransferCtx->cMaxRunning;
 }
 
@@ -2945 +2945 @@
 
 /**
- * Translates a Shared Clipboard transfer status (SHCLURITRANSFERSTATUS_XXX) into a string.
+ * Translates a Shared Clipboard transfer status (SHCLTRANSFERSTATUS_XXX) into a string.
  *
  * @returns Transfer status string name.
@@ -2954 +2954 @@
     switch (uStatus)
     {
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_NONE);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_READY);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_STARTED);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_STOPPED);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_CANCELED);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_KILLED);
-        RT_CASE_RET_STR(SHCLURITRANSFERSTATUS_ERROR);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_NONE);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_READY);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_STARTED);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_STOPPED);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_CANCELED);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_KILLED);
+        RT_CASE_RET_STR(SHCLTRANSFERSTATUS_ERROR);
     }
     return "Unknown";

trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

@@ -881 +881 @@
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
 /**
- * Creates an URI transfer by announcing URI data (via IDataObject) to Windows.
+ * Creates an Shared Clipboard transfer by announcing transfer data  (via IDataObject) to Windows.
  *
  * This creates the necessary IDataObject + IStream implementations and initiates the actual transfers required for getting
@@ -888 +888 @@
  * @returns VBox status code.
  * @param   pWinCtx             Windows context to use.
- * @param   pURICtx             URI context to use.
- * @param   pTransfer           URI transfer to use.
- */
-int SharedClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
+ * @param   pTransferCtxCtx             transfer contextto use.
+ * @param   pTransfer           Shared Clipboard transfer to use.
+ */
+int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
@@ -901 +901 @@
     AssertReturn(pTransfer->pvUser == NULL, VERR_WRONG_ORDER);
 
-    SharedClipboardWinURITransferCtx *pWinURITransferCtx = new SharedClipboardWinURITransferCtx();
+    SharedClipboardWinTransferCtx *pWinURITransferCtx = new SharedClipboardWinTransferCtx();
     if (pWinURITransferCtx)
     {
         pTransfer->pvUser = pWinURITransferCtx;
-        pTransfer->cbUser = sizeof(SharedClipboardWinURITransferCtx);
+        pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx);
 
         pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer);
@@ -971 +971 @@
 
 /**
- * Destroys implementation-specific data for an URI transfer.
+ * Destroys implementation-specific data for an Shared Clipboard transfer.
  *
  * @param   pWinCtx             Windows context to use.
- * @param   pTransfer           URI transfer to create implementation-specific data for.
- */
-void SharedClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
+ * @param   pTransfer           Shared Clipboard transfer to create implementation-specific data for.
+ */
+void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pWinCtx);
@@ -987 +987 @@
     if (pTransfer->pvUser)
     {
-        Assert(pTransfer->cbUser == sizeof(SharedClipboardWinURITransferCtx));
-        SharedClipboardWinURITransferCtx *pWinURITransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser;
+        Assert(pTransfer->cbUser == sizeof(SharedClipboardWinTransferCtx));
+        SharedClipboardWinTransferCtx *pWinURITransferCtx = (SharedClipboardWinTransferCtx *)pTransfer->pvUser;
         Assert(pWinURITransferCtx);