VirtualBox

Changeset 105635 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Aug 9, 2024 9:38:27 AM (9 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
164324
Message:

Shared Clipboard: Cleanup: Made a lot more functions static where possible and renamed the non-static ones to indicate its usage.

Location:
trunk/src/VBox/HostServices/SharedClipboard
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r103630 r105635  
    7373typedef SHCLCLIENTMSG *PSHCLCLIENTMSG;
    7474
     75#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    7576typedef struct SHCLCLIENTTRANSFERSTATE
    7677{
    … …  
    7879    SHCLTRANSFERDIR enmTransferDir;
    7980} SHCLCLIENTTRANSFERSTATE, *PSHCLCLIENTTRANSFERSTATE;
     81#endif
    8082
    8183/**
    … …  
    169171    /** POD (plain old data) state. */
    170172    SHCLCLIENTPODSTATE      POD;
     173#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    171174    /** The client's transfers state. */
    172175    SHCLCLIENTTRANSFERSTATE Transfers;
     176#endif
    173177} SHCLCLIENTSTATE, *PSHCLCLIENTSTATE;
    174178
    … …  
    288292extern SHCLEXTSTATE g_ExtState;
    289293
    290 void shClSvcMsgQueueReset(PSHCLCLIENT pClient);
    291 PSHCLCLIENTMSG shClSvcMsgAlloc(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t cParms);
    292 void shClSvcMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
    293 void shClSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
    294 int shClSvcMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
    295 
    296 int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID);
    297 void shClSvcClientDestroy(PSHCLCLIENT pClient);
    298 void shClSvcClientLock(PSHCLCLIENT pClient);
    299 void shClSvcClientUnlock(PSHCLCLIENT pClient);
    300 void shClSvcClientReset(PSHCLCLIENT pClient);
    301 
    302 int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
    303 int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
    304 void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
    305 
    306 int shClSvcClientWakeup(PSHCLCLIENT pClient);
     294/** @name Service client functions.
     295 * @{
     296 */
     297PSHCLCLIENTMSG ShClSvcClientMsgAlloc(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t cParms);
     298void ShClSvcClientMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
     299void ShClSvcClientMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
     300
     301int ShClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID); /* For testcases. */
     302
     303void ShClSvcClientLock(PSHCLCLIENT pClient);
     304void ShClSvcClientUnlock(PSHCLCLIENT pClient);
     305
     306int ShClSvcClientWakeup(PSHCLCLIENT pClient);
     307/** @} */
    307308
    308309/** @name Service functions, accessible by the backends.

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp

    r104472 r105635  
    104104    int rc;
    105105
    106     PSHCLCLIENTMSG pMsgHdr = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
    107                                              VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
     106    PSHCLCLIENTMSG pMsgHdr = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
     107                                                   VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
    108108    if (pMsgHdr)
    109109    {
    … …  
    116116            HGCMSvcSetU32(&pMsgHdr->aParms[1], 0 /* fRoots */);
    117117
    118             shClSvcClientLock(pClient);
    119 
    120             shClSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    121             rc = shClSvcClientWakeup(pClient);
    122 
    123             shClSvcClientUnlock(pClient);
     118            ShClSvcClientLock(pClient);
     119
     120            ShClSvcClientMsgAdd(pClient, pMsgHdr, true /* fAppend */);
     121            rc = ShClSvcClientWakeup(pClient);
     122
     123            ShClSvcClientUnlock(pClient);
    124124
    125125            /* Remove event from list if caller did not request event handle or in case
    … …  
    136136        else
    137137        {
    138             shClSvcMsgFree(pClient, pMsgHdr);
     138            ShClSvcClientMsgFree(pClient, pMsgHdr);
    139139            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    140140        }
    … …  
    200200    LogFlowFuncEnter();
    201201
    202     PSHCLCLIENTMSG pMsgEntry = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
    203                                                VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    204 
     202    PSHCLCLIENTMSG pMsgEntry = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
     203                                                     VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    205204    PSHCLEVENT pEvent;
    206205    int rc = ShClEventSourceGenerateAndRegisterEvent(&pTransfer->Events, &pEvent);
    … …  
    212211        HGCMSvcSetU64(&pMsgEntry->aParms[2], idxEntry /* uIndex */);
    213212
    214         shClSvcClientLock(pClient);
    215 
    216         shClSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
    217         rc = shClSvcClientWakeup(pClient);
    218 
    219         shClSvcClientUnlock(pClient);
     213        ShClSvcClientLock(pClient);
     214
     215        ShClSvcClientMsgAdd(pClient, pMsgEntry, true /* fAppend */);
     216        rc = ShClSvcClientWakeup(pClient);
     217
     218        ShClSvcClientUnlock(pClient);
    220219
    221220        /* Remove event from list if caller did not request event handle or in case
    … …  
    317316    int rc;
    318317
    319     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
    320                                           VBOX_SHCL_CPARMS_LIST_OPEN);
     318    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
     319                                                VBOX_SHCL_CPARMS_LIST_OPEN);
    321320    if (pMsg)
    322321    {
    … …  
    333332            if (RT_SUCCESS(rc))
    334333            {
    335                 shClSvcClientLock(pClient);
    336 
    337                 shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    338                 rc = shClSvcClientWakeup(pClient);
    339 
    340                 shClSvcClientUnlock(pClient);
     334                ShClSvcClientLock(pClient);
     335
     336                ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     337                rc = ShClSvcClientWakeup(pClient);
     338
     339                ShClSvcClientUnlock(pClient);
    341340
    342341                if (RT_SUCCESS(rc))
    … …  
    369368        else
    370369        {
    371             shClSvcMsgFree(pClient, pMsg);
     370            ShClSvcClientMsgFree(pClient, pMsg);
    372371            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    373372        }
    … …  
    390389    int rc;
    391390
    392     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
    393                                           VBOX_SHCL_CPARMS_LIST_CLOSE);
     391    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
     392                                                VBOX_SHCL_CPARMS_LIST_CLOSE);
    394393    if (pMsg)
    395394    {
    … …  
    404403            if (RT_SUCCESS(rc))
    405404            {
    406                 shClSvcClientLock(pClient);
    407 
    408                 shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    409                 rc = shClSvcClientWakeup(pClient);
    410 
    411                 shClSvcClientUnlock(pClient);
     405                ShClSvcClientLock(pClient);
     406
     407                ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     408                rc = ShClSvcClientWakeup(pClient);
     409
     410                ShClSvcClientUnlock(pClient);
    412411
    413412                if (RT_SUCCESS(rc))
    … …  
    429428        else
    430429        {
    431             shClSvcMsgFree(pClient, pMsg);
     430            ShClSvcClientMsgFree(pClient, pMsg);
    432431            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    433432        }
    … …  
    451450    int rc;
    452451
    453     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
    454                                           VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     452    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
     453                                                VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
    455454    if (pMsg)
    456455    {
    … …  
    464463            HGCMSvcSetU32(&pMsg->aParms[2], 0 /* fFlags */);
    465464
    466             shClSvcClientLock(pClient);
    467 
    468             shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    469             rc = shClSvcClientWakeup(pClient);
    470 
    471             shClSvcClientUnlock(pClient);
     465            ShClSvcClientLock(pClient);
     466
     467            ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     468            rc = ShClSvcClientWakeup(pClient);
     469
     470            ShClSvcClientUnlock(pClient);
    472471
    473472            if (RT_SUCCESS(rc))
    … …  
    492491        else
    493492        {
    494             shClSvcMsgFree(pClient, pMsg);
     493            ShClSvcClientMsgFree(pClient, pMsg);
    495494            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    496495        }
    … …  
    514513    int rc;
    515514
    516     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
    517                                           VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     515    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
     516                                                VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
    518517    if (pMsg)
    519518    {
    … …  
    527526            HGCMSvcSetU32(&pMsg->aParms[2], 0 /* fInfo */);
    528527
    529             shClSvcClientLock(pClient);
    530 
    531             shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    532             rc = shClSvcClientWakeup(pClient);
    533 
    534             shClSvcClientUnlock(pClient);
     528            ShClSvcClientLock(pClient);
     529
     530            ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     531            rc = ShClSvcClientWakeup(pClient);
     532
     533            ShClSvcClientUnlock(pClient);
    535534
    536535            if (RT_SUCCESS(rc))
    … …  
    555554        else
    556555        {
    557             shClSvcMsgFree(pClient, pMsg);
     556            ShClSvcClientMsgFree(pClient, pMsg);
    558557            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    559558        }
    … …  
    576575    int rc;
    577576
    578     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
    579                                           VBOX_SHCL_CPARMS_OBJ_OPEN);
     577    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
     578                                                VBOX_SHCL_CPARMS_OBJ_OPEN);
    580579    if (pMsg)
    581580    {
    … …  
    597596                HGCMSvcSetU32(&pMsg->aParms[3], pCreateParms->fCreate);
    598597
    599                 shClSvcClientLock(pClient);
    600 
    601                 shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    602                 rc = shClSvcClientWakeup(pClient);
    603 
    604                 shClSvcClientUnlock(pClient);
     598                ShClSvcClientLock(pClient);
     599
     600                ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     601                rc = ShClSvcClientWakeup(pClient);
     602
     603                ShClSvcClientUnlock(pClient);
    605604
    606605                if (RT_SUCCESS(rc))
    … …  
    633632        else
    634633        {
    635             shClSvcMsgFree(pClient, pMsg);
     634            ShClSvcClientMsgFree(pClient, pMsg);
    636635            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    637636        }
    … …  
    654653    int rc;
    655654
    656     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
    657                                           VBOX_SHCL_CPARMS_OBJ_CLOSE);
     655    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
     656                                                VBOX_SHCL_CPARMS_OBJ_CLOSE);
    658657    if (pMsg)
    659658    {
    … …  
    666665            HGCMSvcSetU64(&pMsg->aParms[1], hObj);
    667666
    668             shClSvcClientLock(pClient);
    669 
    670             shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    671             rc = shClSvcClientWakeup(pClient);
    672 
    673             shClSvcClientUnlock(pClient);
     667            ShClSvcClientLock(pClient);
     668
     669            ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     670            rc = ShClSvcClientWakeup(pClient);
     671
     672            ShClSvcClientUnlock(pClient);
    674673
    675674            if (RT_SUCCESS(rc))
    … …  
    699698        else
    700699        {
    701             shClSvcMsgFree(pClient, pMsg);
     700            ShClSvcClientMsgFree(pClient, pMsg);
    702701            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    703702        }
    … …  
    721720    int rc;
    722721
    723     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
    724                                           VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     722    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
     723                                                VBOX_SHCL_CPARMS_OBJ_READ_REQ);
    725724    if (pMsg)
    726725    {
    … …  
    735734            HGCMSvcSetU32(&pMsg->aParms[3], fFlags);
    736735
    737             shClSvcClientLock(pClient);
    738 
    739             shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    740             rc = shClSvcClientWakeup(pClient);
    741 
    742             shClSvcClientUnlock(pClient);
     736            ShClSvcClientLock(pClient);
     737
     738            ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
     739            rc = ShClSvcClientWakeup(pClient);
     740
     741            ShClSvcClientUnlock(pClient);
    743742
    744743            if (RT_SUCCESS(rc))
    … …  
    771770        else
    772771        {
    773             shClSvcMsgFree(pClient, pMsg);
     772            ShClSvcClientMsgFree(pClient, pMsg);
    774773            rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
    775774        }
    … …  
    13841383                                        if (RT_SUCCESS(rc))
    13851384                                        {
    1386                                             shClSvcClientLock(pClient);
     1385                                            ShClSvcClientLock(pClient);
    13871386
    13881387                                            rc = shClSvcTransferSendStatusAsync(pClient, pTransfer,
    13891388                                                                                SHCLTRANSFERSTATUS_REQUESTED, VINF_SUCCESS,
    13901389                                                                                NULL);
    1391                                             shClSvcClientUnlock(pClient);
     1390                                            ShClSvcClientUnlock(pClient);
    13921391                                        }
    13931392                                    }
    … …  
    20102009        && pTransfer)
    20112010    {
    2012         shClSvcClientLock(pClient);
     2011        ShClSvcClientLock(pClient);
    20132012
    20142013        /* Let the guest know. */
    … …  
    20172016        AssertRC(rc2);
    20182017
    2019         shClSvcClientUnlock(pClient);
     2018        ShClSvcClientUnlock(pClient);
    20202019
    20212020        ShClSvcTransferDestroy(pClient, pTransfer);
    … …  
    21002099    Assert(RTCritSectIsOwner(&pClient->CritSect));
    21012100
    2102     PSHCLCLIENTMSG pMsgReadData = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
    2103                                                   VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     2101    PSHCLCLIENTMSG pMsgReadData = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
     2102                                                        VBOX_SHCL_CPARMS_TRANSFER_STATUS);
    21042103    if (!pMsgReadData)
    21052104        return VERR_NO_MEMORY;
    … …  
    21152114        HGCMSvcSetU32(&pMsgReadData->aParms[4], 0 /* fFlags, unused */);
    21162115
    2117         shClSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
    2118 
    2119         rc = shClSvcClientWakeup(pClient);
     2116        ShClSvcClientMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     2117
     2118        rc = ShClSvcClientWakeup(pClient);
    21202119        if (RT_SUCCESS(rc))
    21212120        {
    … …  
    22352234    LogFlowFuncEnter();
    22362235
    2237     shClSvcClientLock(pClient);
     2236    ShClSvcClientLock(pClient);
    22382237
    22392238    /* When creating a new transfer, this is a good time to clean up old stuff we don't need anymore. */
    … …  
    22552254    }
    22562255
    2257     shClSvcClientUnlock(pClient);
     2256    ShClSvcClientUnlock(pClient);
    22582257
    22592258    if (RT_FAILURE(rc))
    … …  
    22812280    LogFlowFuncEnter();
    22822281
    2283     shClSvcClientLock(pClient);
     2282    ShClSvcClientLock(pClient);
    22842283
    22852284    PSHCLTRANSFERCTX pTxCtx = &pClient->Transfers.Ctx;
    … …  
    22952294    pTransfer = NULL;
    22962295
    2297     shClSvcClientUnlock(pClient);
     2296    ShClSvcClientUnlock(pClient);
    22982297
    22992298    LogFlowFuncLeave();
    … …  
    23132312    LogFlowFuncEnter();
    23142313
    2315     shClSvcClientLock(pClient);
     2314    ShClSvcClientLock(pClient);
    23162315
    23172316    Assert(ShClTransferGetStatus(pTransfer) == SHCLTRANSFERSTATUS_NONE);
    … …  
    23442343        LogRel(("Shared Clipboard: Initializing transfer failed with %Rrc\n", rc));
    23452344
    2346     shClSvcClientUnlock(pClient);
     2345    ShClSvcClientUnlock(pClient);
    23472346
    23482347    LogFlowFuncLeaveRC(rc);
    … …  
    23612360    LogRel2(("Shared Clipboard: Starting transfer %RU16 ...\n", pTransfer->State.uID));
    23622361
    2363     shClSvcClientLock(pClient);
     2362    ShClSvcClientLock(pClient);
    23642363
    23652364    int rc = ShClTransferStart(pTransfer);
    … …  
    23682367     * (so that it can tear down the transfer on error as well). */
    23692368    int rc2 = shClSvcTransferSendStatusAsync(pClient, pTransfer,
    2370                                               RT_SUCCESS(rc)
    2371                                             ? SHCLTRANSFERSTATUS_STARTED : SHCLTRANSFERSTATUS_ERROR, rc,
    2372                                             NULL /* ppEvent */);
     2369                                               RT_SUCCESS(rc)
     2370                                             ? SHCLTRANSFERSTATUS_STARTED : SHCLTRANSFERSTATUS_ERROR, rc,
     2371                                             NULL /* ppEvent */);
    23732372    if (RT_SUCCESS(rc))
    23742373        rc = rc2;
    23752374
    2376     shClSvcClientUnlock(pClient);
     2375    ShClSvcClientUnlock(pClient);
    23772376    return rc;
    23782377}
    … …  
    23902389    LogRel2(("Shared Clipboard: Stopping transfer %RU16 ...\n", pTransfer->State.uID));
    23912390
    2392     shClSvcClientLock(pClient);
     2391    ShClSvcClientLock(pClient);
    23932392
    23942393    PSHCLEVENT pEvent;
    … …  
    24002399        LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU16 on guest ...\n", pTransfer->State.uID));
    24012400
    2402         shClSvcClientUnlock(pClient);
     2401        ShClSvcClientUnlock(pClient);
    24032402
    24042403        rc = ShClEventWait(pEvent, pTransfer->uTimeoutMs, NULL /* ppPayload */);
    … …  
    24082407        ShClEventRelease(pEvent);
    24092408
    2410         shClSvcClientLock(pClient);
     2409        ShClSvcClientLock(pClient);
    24112410    }
    24122411
    … …  
    24152414                       pTransfer->State.uID, rc));
    24162415
    2417     shClSvcClientUnlock(pClient);
     2416    ShClSvcClientUnlock(pClient);
    24182417
    24192418    LogFlowFuncLeaveRC(rc);

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

    r105634 r105635  
    303303
    304304
     305/*********************************************************************************************************************************
     306*   Prototypes                                                                                                                   *
     307*********************************************************************************************************************************/
     308static void shClSvcClientReset(PSHCLCLIENT pClient);
     309static void shClSvcClientDestroy(PSHCLCLIENT pClient);
     310
     311static void shClSvcClientMsgQueueReset(PSHCLCLIENT pClient);
     312static int  shClSvcClientMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
     313
     314static int  shClSvcClientStateInit(PSHCLCLIENTSTATE pState, uint32_t uClientID);
     315static int  shClSvcClientStateDestroy(PSHCLCLIENTSTATE pState);
     316static void shclSvcClientStateReset(PSHCLCLIENTSTATE pState);
     317
     318
    305319/**
    306320 * Returns the current Shared Clipboard service mode.
    … …  
    389403 * @note    Caller enters pClient->CritSect.
    390404 */
    391 void shClSvcMsgQueueReset(PSHCLCLIENT pClient)
     405static void shClSvcClientMsgQueueReset(PSHCLCLIENT pClient)
    392406{
    393407    Assert(RTCritSectIsOwner(&pClient->CritSect));
    … …  
    397411    {
    398412        PSHCLCLIENTMSG pMsg = RTListRemoveFirst(&pClient->MsgQueue, SHCLCLIENTMSG, ListEntry);
    399         shClSvcMsgFree(pClient, pMsg);
     413        ShClSvcClientMsgFree(pClient, pMsg);
    400414    }
    401415    pClient->cMsgAllocated = 0;
    … …  
    417431 * @param   cParms      The number of parameters the message takes.
    418432 */
    419 PSHCLCLIENTMSG shClSvcMsgAlloc(PSHCLCLIENT pClient, uint32_t idMsg, uint32_t cParms)
     433PSHCLCLIENTMSG ShClSvcClientMsgAlloc(PSHCLCLIENT pClient, uint32_t idMsg, uint32_t cParms)
    420434{
    421435    RT_NOREF(pClient);
    … …  
    439453
    440454/**
    441  * Frees a formerly allocated clipboard message.
     455 * Frees a formerly allocated client clipboard message.
    442456 *
    443457 * @param   pClient     The client which was the target of this message.
    444458 * @param   pMsg        Clipboard message to free.
    445459 */
    446 void shClSvcMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg)
     460void ShClSvcClientMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg)
    447461{
    448462    RT_NOREF(pClient);
    … …  
    534548 * @note    Caller must enter critical section.
    535549 */
    536 void shClSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
     550void ShClSvcClientMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
    537551{
    538552    Assert(RTCritSectIsOwner(&pClient->CritSect));
    … …  
    560574 * @note    Caller must enter critical section.
    561575 */
    562 int shClSvcMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg)
     576int shClSvcClientMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg)
    563577{
    564578    Assert(RTCritSectIsOwner(&pClient->CritSect));
    … …  
    568582
    569583    RTListAppend(&pClient->MsgQueue, &pMsg->ListEntry);
    570     return shClSvcClientWakeup(pClient); /** @todo r=andy Remove message if waking up failed? */
     584    return ShClSvcClientWakeup(pClient); /** @todo r=andy Remove message if waking up failed? */
    571585}
    572586
    … …  
    577591 * @param   uClientID           HGCM client ID to assign client to.
    578592 */
    579 int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID)
     593int ShClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID)
    580594{
    581595    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    623637 * @param   pClient             Client to destroy.
    624638 */
    625 void shClSvcClientDestroy(PSHCLCLIENT pClient)
     639static void shClSvcClientDestroy(PSHCLCLIENT pClient)
    626640{
    627641    AssertPtrReturnVoid(pClient);
    … …  
    630644
    631645    /* Make sure to send a quit message to the guest so that it can terminate gracefully. */
    632     shClSvcClientLock(pClient);
     646    ShClSvcClientLock(pClient);
    633647
    634648    if (pClient->Pending.uType)
    … …  
    651665
    652666    ShClEventSourceDestroy(&pClient->EventSrc);
    653 
    654     shClSvcClientUnlock(pClient);
    655 
    656667    shClSvcClientStateDestroy(&pClient->State);
     668
     669    ShClSvcClientUnlock(pClient);
    657670
    658671    PSHCLCLIENTLEGACYCID pCidIter, pCidIterNext;
    … …  
    672685}
    673686
    674 void shClSvcClientLock(PSHCLCLIENT pClient)
     687void ShClSvcClientLock(PSHCLCLIENT pClient)
    675688{
    676689    int rc2 = RTCritSectEnter(&pClient->CritSect);
    … …  
    678691}
    679692
    680 void shClSvcClientUnlock(PSHCLCLIENT pClient)
     693void ShClSvcClientUnlock(PSHCLCLIENT pClient)
    681694{
    682695    int rc2 = RTCritSectLeave(&pClient->CritSect);
    … …  
    689702 * @param   pClient             Client to reset.
    690703 */
    691 void shClSvcClientReset(PSHCLCLIENT pClient)
     704static void shClSvcClientReset(PSHCLCLIENT pClient)
    692705{
    693706    if (!pClient)
    … …  
    698711
    699712    /* Reset message queue. */
    700     shClSvcMsgQueueReset(pClient);
     713    shClSvcClientMsgQueueReset(pClient);
    701714
    702715    /* Reset event source. */
    … …  
    970983        {
    971984            RTListNodeRemove(&pFirstMsg->ListEntry);
    972             shClSvcMsgFree(pClient, pFirstMsg);
     985            ShClSvcClientMsgFree(pClient, pFirstMsg);
    973986
    974987            rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
    … …  
    11041117            {
    11051118                RTListNodeRemove(&pFirstMsg->ListEntry);
    1106                 shClSvcMsgFree(pClient, pFirstMsg);
     1119                ShClSvcClientMsgFree(pClient, pFirstMsg);
    11071120            }
    11081121
    … …  
    11981211 * @note    Caller must enter critical section.
    11991212 */
    1200 int shClSvcClientWakeup(PSHCLCLIENT pClient)
     1213int ShClSvcClientWakeup(PSHCLCLIENT pClient)
    12011214{
    12021215    Assert(RTCritSectIsOwner(&pClient->CritSect));
    … …  
    12261239        {
    12271240            RTListNodeRemove(&pFirstMsg->ListEntry);
    1228             shClSvcMsgFree(pClient, pFirstMsg);
     1241            ShClSvcClientMsgFree(pClient, pFirstMsg);
    12291242        }
    12301243
    … …  
    12931306         * Allocate messages, one for each format.
    12941307         */
    1295         PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient,
    1296                                               pClient->State.fGuestFeatures0 & VBOX_SHCL_GF_0_CONTEXT_ID
    1297                                               ? VBOX_SHCL_HOST_MSG_READ_DATA_CID : VBOX_SHCL_HOST_MSG_READ_DATA,
    1298                                               2);
     1308        PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient,
     1309                                                      pClient->State.fGuestFeatures0 & VBOX_SHCL_GF_0_CONTEXT_ID
     1310                                                    ? VBOX_SHCL_HOST_MSG_READ_DATA_CID : VBOX_SHCL_HOST_MSG_READ_DATA,
     1311                                                    2);
    12991312        if (pMsg)
    13001313        {
    1301             shClSvcClientLock(pClient);
     1314            ShClSvcClientLock(pClient);
    13021315
    13031316            PSHCLEVENT pEvent;
    … …  
    13421355                    HGCMSvcSetU32(&pMsg->aParms[1], fFormat);
    13431356
    1344                     shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     1357                    ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
    13451358                    /* Wake up the client to let it know that there are new messages. */
    1346                     shClSvcClientWakeup(pClient);
     1359                    ShClSvcClientWakeup(pClient);
    13471360
    13481361                    /* Return event to caller. */
    … …  
    13641377
    13651378            if (RT_FAILURE(rc))
    1366                 shClSvcMsgFree(pClient, pMsg);
    1367 
    1368             shClSvcClientUnlock(pClient);
     1379                ShClSvcClientMsgFree(pClient, pMsg);
     1380
     1381            ShClSvcClientUnlock(pClient);
    13691382        }
    13701383        else
    … …  
    16141627     * Allocate a message, populate parameters and post it to the client.
    16151628     */
    1616     PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 2);
     1629    PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 2);
    16171630    if (pMsg)
    16181631    {
    … …  
    16201633        HGCMSvcSetU32(&pMsg->aParms[1], fFormats);
    16211634
    1622         shClSvcClientLock(pClient);
    1623 
    1624         rc = shClSvcMsgAddAndWakeupClient(pClient, pMsg);
    1625 
    1626         shClSvcClientUnlock(pClient);
     1635        ShClSvcClientLock(pClient);
     1636
     1637        rc = shClSvcClientMsgAddAndWakeupClient(pClient, pMsg);
     1638
     1639        ShClSvcClientUnlock(pClient);
    16271640    }
    16281641    else
    … …  
    21632176    AssertPtr(pvClient);
    21642177
    2165     int rc = shClSvcClientInit(pClient, u32ClientID);
     2178    int rc = ShClSvcClientInit(pClient, u32ClientID);
    21662179    if (RT_SUCCESS(rc))
    21672180    {
    … …  
    23192332                LogRel(("Shared Clipboard: Error reported from guest side: %Rrc\n", rcGuest));
    23202333
    2321                 shClSvcClientLock(pClient);
    2322 
    2323                 /* Reset message queue. */
    2324                 shClSvcMsgQueueReset(pClient);
    2325 
    2326 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    2327                 /* Reset transfer state. */
    2328                 shClSvcTransferDestroyAll(pClient);
    2329 #endif
    2330                 shClSvcClientUnlock(pClient);
     2334                /* Start over. */
     2335                shClSvcClientReset(pClient);
    23312336            }
    23322337            break;
    … …  
    23702375 * @param   uClientID           Client ID (HGCM) to use for this client state.
    23712376 */
    2372 int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
     2377static int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
    23732378{
    23742379    LogFlowFuncEnter();
    … …  
    23862391 *
    23872392 * @returns VBox status code.
    2388  * @param   pClientState        Client state to destroy.
    2389  */
    2390 int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
    2391 {
    2392     RT_NOREF(pClientState);
    2393 
     2393 * @param   pState              Client state to destroy.
     2394 */
     2395static int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pState)
     2396{
    23942397    LogFlowFuncEnter();
    23952398
     2399    shclSvcClientStateReset(pState);
     2400
    23962401    return VINF_SUCCESS;
    23972402}
    … …  
    24002405 * Resets a Shared Clipboard service's client state.
    24012406 *
    2402  * @param   pClientState    Client state to reset.
    2403  */
    2404 void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
     2407 * @param   pState              Client state to reset.
     2408 */
     2409static void shclSvcClientStateReset(PSHCLCLIENTSTATE pState)
    24052410{
    24062411    LogFlowFuncEnter();
    24072412
    2408     pClientState->fGuestFeatures0 = VBOX_SHCL_GF_NONE;
    2409     pClientState->fGuestFeatures1 = VBOX_SHCL_GF_NONE;
    2410 
    2411     pClientState->cbChunkSize     = VBOX_SHCL_DEFAULT_CHUNK_SIZE; /** @todo Make this configurable. */
    2412     pClientState->enmSource       = SHCLSOURCE_INVALID;
    2413     pClientState->fFlags          = SHCLCLIENTSTATE_FLAGS_NONE;
    2414 
    2415     pClientState->POD.enmDir             = SHCLTRANSFERDIR_UNKNOWN;
    2416     pClientState->POD.uFormat            = VBOX_SHCL_FMT_NONE;
    2417     pClientState->POD.cbToReadWriteTotal = 0;
    2418     pClientState->POD.cbReadWritten      = 0;
     2413    pState->fGuestFeatures0 = VBOX_SHCL_GF_NONE;
     2414    pState->fGuestFeatures1 = VBOX_SHCL_GF_NONE;
     2415
     2416    pState->cbChunkSize     = VBOX_SHCL_DEFAULT_CHUNK_SIZE; /** @todo Make this configurable. */
     2417    pState->enmSource       = SHCLSOURCE_INVALID;
     2418    pState->fFlags          = SHCLCLIENTSTATE_FLAGS_NONE;
     2419
     2420    pState->POD.enmDir             = SHCLTRANSFERDIR_UNKNOWN;
     2421    pState->POD.uFormat            = VBOX_SHCL_FMT_NONE;
     2422    pState->POD.cbToReadWriteTotal = 0;
     2423    pState->POD.cbReadWritten      = 0;
    24192424
    24202425#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    2421     pClientState->Transfers.enmTransferDir = SHCLTRANSFERDIR_UNKNOWN;
     2426    pState->Transfers.enmTransferDir = SHCLTRANSFERDIR_UNKNOWN;
    24222427#endif
    24232428}
    … …  
    27502755                                  VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    27512756
    2752             PSHCLCLIENTMSG pMsg = shClSvcMsgAlloc(pClient, u.Msg.idMsg, u.Msg.cParms);
     2757            PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, u.Msg.idMsg, u.Msg.cParms);
    27532758            AssertReturn(pMsg, VERR_NO_MEMORY);
    27542759            pMsg->idCtx = u.Msg.idCtx;
    … …  
    27572762            {
    27582763                rc = HGCMSvcSSMR3Get(&pMsg->aParms[p], pSSM, pVMM);
    2759                 AssertRCReturnStmt(rc, shClSvcMsgFree(pClient, pMsg), rc);
     2764                AssertRCReturnStmt(rc, ShClSvcClientMsgFree(pClient, pMsg), rc);
    27602765            }
    27612766
    27622767            RTCritSectEnter(&pClient->CritSect);
    2763             shClSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     2768            ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
    27642769            RTCritSectLeave(&pClient->CritSect);
    27652770        }

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceImpl.cpp

    r103631 r105635  
    8989    rc = table.pfnHostCall(NULL, VBOX_SHCL_HOST_FN_SET_MODE, 1, parms);
    9090    RTTESTI_CHECK_RC_OK(rc);
    91     rc = shClSvcClientInit(&g_Client, 1 /* clientId */);
     91    rc = ShClSvcClientInit(&g_Client, 1 /* clientId */);
    9292    RTTESTI_CHECK_RC_OK(rc);
    9393
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette