VirtualBox

Changeset 86908 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Nov 18, 2020 10:56:12 AM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
141388
Message:

Shared Clipboard/Transfers: Removed clipboard area handling code. bugref:9437

Location:
trunk/src/VBox/Main
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/Makefile.kmk

    r86753 r86908  
    726726endif
    727727
    728 ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    729  VBoxSVC_SOURCES += $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardArea.cpp
    730 endif
    731 
    732728$(call KB_FN_DO_PASS0_ON_TARGET,VBoxSVC) # Sets VBoxSVC_0_OUTDIR
    733729

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r86752 r86908  
    49284928  <interface
    49294929    name="IInternalMachineControl" extends="$unknown"
    4930     uuid="0075FD6C-00C2-4484-0077-C057003D9C90"
     4930    uuid="EA05E40C-CB31-423B-B3B7-A5B19300F40C"
    49314931    internal="yes"
    49324932    wsmap="suppress"
    … …  
    51275127          The flags of the properties returned. The array entries match the
    51285128          corresponding entries in the @a name array.
    5129         </desc>
    5130       </param>
    5131     </method>
    5132     <method name="clipboardAreaRegister">
    5133       <desc>
    5134         Registers a new clipboard area.
    5135       </desc>
    5136       <param name="parms" type="wstring" dir="in" safearray="yes">
    5137         <desc>
    5138           Registration parameters. Currently not used and therefore ignored.
    5139         </desc>
    5140       </param>
    5141       <param name="id" type="unsigned long" dir="out">
    5142         <desc>
    5143           Returns the new clipboard area which got registered.
    5144         </desc>
    5145       </param>
    5146     </method>
    5147     <method name="clipboardAreaUnregister">
    5148       <desc>
    5149         Unregisters a formerly registered clipboard area.
    5150       </desc>
    5151       <param name="id" type="unsigned long" dir="in">
    5152         <desc>
    5153           Clipboard area to unregister.
    5154         </desc>
    5155       </param>
    5156     </method>
    5157     <method name="clipboardAreaAttach">
    5158       <desc>
    5159         Attaches to a registered clipboard area.
    5160       </desc>
    5161       <param name="id" type="unsigned long" dir="in">
    5162         <desc>
    5163           Clipboard area to attach to.
    5164         </desc>
    5165       </param>
    5166     </method>
    5167     <method name="clipboardAreaDetach">
    5168       <desc>
    5169         Detaches from a registered clipboard area.
    5170       </desc>
    5171       <param name="id" type="unsigned long" dir="in">
    5172         <desc>
    5173           Clipboard area to detach from.
    5174         </desc>
    5175       </param>
    5176     </method>
    5177     <method name="clipboardAreaGetMostRecent">
    5178       <desc>
    5179         Returns the most recent (last registered) clipboard area.
    5180       </desc>
    5181       <param name="id" type="unsigned long" dir="out">
    5182         <desc>
    5183           Returns the most recent clipboard area.
    5184         </desc>
    5185       </param>
    5186     </method>
    5187     <method name="clipboardAreaGetRefCount">
    5188       <desc>
    5189         Returns the current reference count of a clipboard area.
    5190       </desc>
    5191       <param name="id" type="unsigned long" dir="in">
    5192         <desc>
    5193           Clipboard area to return reference count for.
    5194         </desc>
    5195       </param>
    5196       <param name="refcount" type="unsigned long" dir="out">
    5197         <desc>
    5198           Returns the current reference count.
    51995129        </desc>
    52005130      </param>

  • trunk/src/VBox/Main/include/MachineImpl.h

    r85769 r86908  
    12151215                         ComPtr<IProgress> &aProgress);
    12161216    HRESULT finishOnlineMergeMedium();
    1217     HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    1218     HRESULT clipboardAreaUnregister(ULONG aID);
    1219     HRESULT clipboardAreaAttach(ULONG aID);
    1220     HRESULT clipboardAreaDetach(ULONG aID);
    1221     HRESULT clipboardAreaGetMostRecent(ULONG *aID);
    1222     HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
    12231217    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    12241218                                std::vector<com::Utf8Str> &aValues,
    … …  
    13771371                         ComPtr<IProgress> &aProgress);
    13781372    HRESULT finishOnlineMergeMedium();
    1379     HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    1380     HRESULT clipboardAreaUnregister(ULONG aID);
    1381     HRESULT clipboardAreaAttach(ULONG aID);
    1382     HRESULT clipboardAreaDetach(ULONG aID);
    1383     HRESULT clipboardAreaGetMostRecent(ULONG *aID);
    1384     HRESULT clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount);
    13851373    HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    13861374                                std::vector<com::Utf8Str> &aValues,

  • trunk/src/VBox/Main/include/VirtualBoxImpl.h

    r86501 r86908  
    7575#endif
    7676
    77 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    78 struct SharedClipboardAreaData;
    79 #endif
    80 
    8177class ATL_NO_VTABLE VirtualBox :
    8278    public VirtualBoxWrap
    … …  
    178174    void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
    179175    void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
    180 
    181 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    182     int i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData);
    183     int i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData);
    184 
    185     HRESULT i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
    186     HRESULT i_onClipboardAreaUnregister(ULONG aID);
    187     HRESULT i_onClipboardAreaAttach(ULONG aID);
    188     HRESULT i_onClipboardAreaDetach(ULONG aID);
    189     ULONG i_onClipboardAreaGetMostRecent(void);
    190     ULONG i_onClipboardAreaGetRefCount(ULONG aID);
    191 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    192176
    193177    void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);

  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r86498 r86908  
    1337613376}
    1337713377
    13378 HRESULT SessionMachine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    13379 {
    13380 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13381     ULONG uID;
    13382     int rc = mParent->i_onClipboardAreaRegister(aParms, &uID);
    13383     if (RT_SUCCESS(rc))
    13384     {
    13385         if (aID)
    13386             *aID = uID;
    13387         return S_OK;
    13388     }
    13389     return E_FAIL;
    13390 #else
    13391     RT_NOREF(aParms, aID);
    13392     ReturnComNotImplemented();
    13393 #endif
    13394 }
    13395 
    13396 HRESULT SessionMachine::clipboardAreaUnregister(ULONG aID)
    13397 {
    13398 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13399     return mParent->i_onClipboardAreaUnregister(aID);
    13400 #else
    13401     RT_NOREF(aID);
    13402     ReturnComNotImplemented();
    13403 #endif
    13404 }
    13405 
    13406 HRESULT SessionMachine::clipboardAreaAttach(ULONG aID)
    13407 {
    13408 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13409     return mParent->i_onClipboardAreaAttach(aID);
    13410 #else
    13411     RT_NOREF(aID);
    13412     ReturnComNotImplemented();
    13413 #endif
    13414 }
    13415 HRESULT SessionMachine::clipboardAreaDetach(ULONG aID)
    13416 {
    13417 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13418     return mParent->i_onClipboardAreaDetach(aID);
    13419 #else
    13420     RT_NOREF(aID);
    13421     ReturnComNotImplemented();
    13422 #endif
    13423 }
    13424 
    13425 HRESULT SessionMachine::clipboardAreaGetMostRecent(ULONG *aID)
    13426 {
    13427 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13428     ULONG uID = mParent->i_onClipboardAreaGetMostRecent();
    13429     if (aID)
    13430         *aID = uID;
    13431     return S_OK;
    13432 #else
    13433     RT_NOREF(aID);
    13434     ReturnComNotImplemented();
    13435 #endif
    13436 }
    13437 
    13438 HRESULT SessionMachine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
    13439 {
    13440 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    13441     ULONG uRefCount = mParent->i_onClipboardAreaGetRefCount(aID);
    13442     if (aRefCount)
    13443         *aRefCount = uRefCount;
    13444     return S_OK;
    13445 #else
    13446     RT_NOREF(aID, aRefCount);
    13447     ReturnComNotImplemented();
    13448 #endif
    13449 }
    13450 
    1345113378HRESULT SessionMachine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    1345213379                                            std::vector<com::Utf8Str> &aValues,
    … …  
    1495614883}
    1495714884
    14958 HRESULT Machine::clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    14959 {
    14960     RT_NOREF(aParms, aID);
    14961     ReturnComNotImplemented();
    14962 }
    14963 
    14964 HRESULT Machine::clipboardAreaUnregister(ULONG aID)
    14965 {
    14966     RT_NOREF(aID);
    14967     ReturnComNotImplemented();
    14968 }
    14969 
    14970 HRESULT Machine::clipboardAreaAttach(ULONG aID)
    14971 {
    14972     RT_NOREF(aID);
    14973     ReturnComNotImplemented();
    14974 }
    14975 HRESULT Machine::clipboardAreaDetach(ULONG aID)
    14976 {
    14977     RT_NOREF(aID);
    14978     ReturnComNotImplemented();
    14979 }
    14980 
    14981 HRESULT Machine::clipboardAreaGetMostRecent(ULONG *aID)
    14982 {
    14983     RT_NOREF(aID);
    14984     ReturnComNotImplemented();
    14985 }
    14986 
    14987 HRESULT Machine::clipboardAreaGetRefCount(ULONG aID, ULONG *aRefCount)
    14988 {
    14989     RT_NOREF(aID, aRefCount);
    14990     ReturnComNotImplemented();
    14991 }
    14992 
    1499314885HRESULT Machine::pullGuestProperties(std::vector<com::Utf8Str> &aNames,
    1499414886                                     std::vector<com::Utf8Str> &aValues,

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r86521 r86908  
    262262typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
    263263
    264 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    265 /**
    266  * Structure for keeping Shared Clipboard area data within the VirtualBox object.
    267  */
    268 struct SharedClipboardAreaData
    269 {
    270     SharedClipboardAreaData()
    271         : uID(NIL_SHCLAREAID) { }
    272 
    273     /** The area's (unique) ID.
    274      *  Set to NIL_SHCLAREAID if not initialized yet. */
    275     ULONG               uID;
    276     /** The actual Shared Clipboard area assigned to this ID. */
    277     SharedClipboardArea Area;
    278 };
    279 
    280 /** Map of Shared Clipboard areas. The key defines the area ID. */
    281 typedef std::map<ULONG, SharedClipboardAreaData *> SharedClipboardAreaMap;
    282 
    283 /**
    284  * Structure for keeping global Shared Clipboard data within the VirtualBox object.
    285  */
    286 struct SharedClipboardData
    287 {
    288     SharedClipboardData()
    289         : uMostRecentClipboardAreaID(NIL_SHCLAREAID)
    290         , uMaxClipboardAreas(32) /** @todo Make this configurable. */
    291     {
    292 #ifdef DEBUG_andy
    293         uMaxClipboardAreas = 9999;
    294 #endif
    295         int rc2 = RTCritSectInit(&CritSect);
    296         AssertRC(rc2);
    297     }
    298 
    299     virtual ~SharedClipboardData()
    300     {
    301         RTCritSectDelete(&CritSect);
    302     }
    303 
    304     /**
    305      * Generates a new clipboard area ID.
    306      * Currently does *not* check for collisions and stuff.
    307      *
    308      * @returns New clipboard area ID.
    309      */
    310     ULONG GenerateAreaID(void)
    311     {
    312         ULONG uID = NIL_SHCLAREAID;
    313 
    314         int rc = RTCritSectEnter(&CritSect);
    315         if (RT_SUCCESS(rc))
    316         {
    317             uID = RTRandU32Ex(1, UINT32_MAX - 1); /** @todo Make this a bit more sophisticated. Later. */
    318 
    319             int rc2 = RTCritSectLeave(&CritSect);
    320             AssertRC(rc2);
    321         }
    322 
    323         LogFlowFunc(("uID=%RU32\n", uID));
    324         return uID;
    325     }
    326 
    327     /** Critical section to serialize access. */
    328     RTCRITSECT                          CritSect;
    329     /** The most recent (last created) clipboard area ID.
    330      *  NIL_SHCLAREAID if not initialized yet. */
    331     ULONG                               uMostRecentClipboardAreaID;
    332     /** Maximum of concurrent clipboard areas.
    333      *  @todo Make this configurable. */
    334     ULONG                               uMaxClipboardAreas;
    335     /** Map of clipboard areas. The key is the area ID. */
    336     SharedClipboardAreaMap              mapClipboardAreas;
    337 };
    338 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    339 
    340264/**
    341265 *  Main VirtualBox data structure.
    … …  
    492416    bool                                fWatcherIsReliable;
    493417#endif
    494 
    495 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    496     /** Data related to Shared Clipboard handling. */
    497     SharedClipboardData                 SharedClipboard;
    498 #endif
    499418};
    500419
    … …  
    11291048        unconst(m->ptrExtPackManager).setNull();
    11301049    }
    1131 #endif
    1132 
    1133 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1134     LogFlowThisFunc(("Destroying Shared Clipboard areas...\n"));
    1135     SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.begin();
    1136     while (itArea != m->SharedClipboard.mapClipboardAreas.end())
    1137     {
    1138         i_clipboardAreaDestroy(itArea->second);
    1139         ++itArea;
    1140     }
    1141     m->SharedClipboard.mapClipboardAreas.clear();
    11421050#endif
    11431051
    … …  
    34453353}
    34463354
    3447 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS /** @todo r=bird: Why is this still here?  */
    3448 
    3449 /**
    3450  * Generates a new clipboard area on the host by opening (and locking) a new, temporary directory.
    3451  *
    3452  * @returns VBox status code.
    3453  * @param   uAreaID             Clipboard area ID to use for creation.
    3454  * @param   fFlags              Additional creation flags; currently unused and ignored.
    3455  * @param   ppAreaData          Where to return the created clipboard area on success.
    3456  */
    3457 int VirtualBox::i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData)
    3458 {
    3459     RT_NOREF(fFlags);
    3460 
    3461     int vrc;
    3462 
    3463     SharedClipboardAreaData *pAreaData = new SharedClipboardAreaData();
    3464     if (pAreaData)
    3465     {
    3466         vrc = pAreaData->Area.OpenTemp(uAreaID, SHCLAREA_OPEN_FLAGS_MUST_NOT_EXIST);
    3467         if (RT_SUCCESS(vrc))
    3468         {
    3469             pAreaData->uID = uAreaID;
    3470 
    3471             *ppAreaData = pAreaData;
    3472         }
    3473     }
    3474     else
    3475         vrc = VERR_NO_MEMORY;
    3476 
    3477     LogFlowFunc(("uID=%RU32, rc=%Rrc\n", uAreaID, vrc));
    3478     return vrc;
    3479 }
    3480 
    3481 /**
    3482  * Destroys a formerly created clipboard area.
    3483  *
    3484  * @returns VBox status code.
    3485  * @param   pAreaData           Area data to destroy. The pointer will be invalid on successful return.
    3486  */
    3487 int VirtualBox::i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData)
    3488 {
    3489     if (!pAreaData)
    3490         return VINF_SUCCESS;
    3491 
    3492     /** @todo Do we need a worker for this to not block here for too long?
    3493      *        This could take a while to clean up huge areas ... */
    3494     int vrc = pAreaData->Area.Close();
    3495     if (RT_SUCCESS(vrc))
    3496     {
    3497         delete pAreaData;
    3498         pAreaData = NULL;
    3499     }
    3500 
    3501     LogFlowFunc(("uID=%RU32, rc=%Rrc\n", pAreaData->uID, vrc));
    3502     return vrc;
    3503 }
    3504 
    3505 /**
    3506  * Registers and creates a new clipboard area on the host (for all VMs), returned the clipboard area ID for it.
    3507  *
    3508  * @returns HRESULT
    3509  * @param   aParms              Creation parameters. Currently unused.
    3510  * @param   aID                 Where to return the clipboard area ID on success.
    3511  */
    3512 HRESULT VirtualBox::i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID)
    3513 {
    3514     RT_NOREF(aParms);
    3515 
    3516     HRESULT rc = S_OK;
    3517 
    3518     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3519     if (RT_SUCCESS(vrc))
    3520     {
    3521         try
    3522         {
    3523             if (m->SharedClipboard.mapClipboardAreas.size() < m->SharedClipboard.uMaxClipboardAreas)
    3524             {
    3525                 for (unsigned uTries = 0; uTries < 32; uTries++) /* Don't try too hard. */
    3526                 {
    3527                     const ULONG uAreaID = m->SharedClipboard.GenerateAreaID();
    3528 
    3529                     /* Area ID already taken? */
    3530                     if (m->SharedClipboard.mapClipboardAreas.find(uAreaID) != m->SharedClipboard.mapClipboardAreas.end())
    3531                         continue;
    3532 
    3533                     SharedClipboardAreaData *pAreaData;
    3534                     vrc = i_clipboardAreaCreate(uAreaID, 0 /* fFlags */, &pAreaData);
    3535                     if (RT_SUCCESS(vrc))
    3536                     {
    3537                         m->SharedClipboard.mapClipboardAreas[uAreaID] = pAreaData;
    3538                         m->SharedClipboard.uMostRecentClipboardAreaID = uAreaID;
    3539 
    3540                         /** @todo Implement collision detection / wrap-around. */
    3541 
    3542                         if (aID)
    3543                             *aID = uAreaID;
    3544 
    3545                         LogThisFunc(("Registered new clipboard area %RU32: '%s'\n",
    3546                                      uAreaID, pAreaData->Area.GetDirAbs()));
    3547                         break;
    3548                     }
    3549                 }
    3550 
    3551                 if (RT_FAILURE(vrc))
    3552                     rc = setError(E_FAIL, /** @todo Find a better rc. */
    3553                                   tr("Failed to create new clipboard area (%Rrc)"), vrc);
    3554             }
    3555             else
    3556             {
    3557                 rc = setError(E_FAIL, /** @todo Find a better rc. */
    3558                               tr("Maximum number of concurrent clipboard areas reached (%RU32)"),
    3559                               m->SharedClipboard.uMaxClipboardAreas);
    3560             }
    3561         }
    3562         catch (std::bad_alloc &ba)
    3563         {
    3564             vrc = VERR_NO_MEMORY;
    3565             RT_NOREF(ba);
    3566         }
    3567 
    3568         RTCritSectLeave(&m->SharedClipboard.CritSect);
    3569     }
    3570     LogFlowThisFunc(("rc=%Rhrc\n", rc));
    3571     return rc;
    3572 }
    3573 
    3574 /**
    3575  * Unregisters (destroys) a formerly created clipboard area.
    3576  *
    3577  * @returns HRESULT
    3578  * @param   aID                 ID of clipboard area to destroy.
    3579  */
    3580 HRESULT VirtualBox::i_onClipboardAreaUnregister(ULONG aID)
    3581 {
    3582     HRESULT rc = S_OK;
    3583 
    3584     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3585     if (RT_SUCCESS(vrc))
    3586     {
    3587         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3588         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3589         {
    3590             if (itArea->second->Area.GetRefCount() == 0)
    3591             {
    3592                 vrc = i_clipboardAreaDestroy(itArea->second);
    3593                 if (RT_SUCCESS(vrc))
    3594                 {
    3595                     m->SharedClipboard.mapClipboardAreas.erase(itArea);
    3596                 }
    3597             }
    3598             else
    3599                 rc = setError(E_ACCESSDENIED, /** @todo Find a better rc. */
    3600                               tr("Area with ID %RU32 still in used, cannot unregister"), aID);
    3601         }
    3602         else
    3603             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3604                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3605 
    3606         int vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3607         AssertRC(vrc2);
    3608     }
    3609     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3610     return rc;
    3611 }
    3612 
    3613 /**
    3614  * Attaches to an existing clipboard area.
    3615  *
    3616  * @returns HRESULT
    3617  * @param   aID                 ID of clipboard area to attach.
    3618  */
    3619 HRESULT VirtualBox::i_onClipboardAreaAttach(ULONG aID)
    3620 {
    3621     HRESULT rc = S_OK;
    3622 
    3623     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3624     if (RT_SUCCESS(vrc))
    3625     {
    3626         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3627         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3628         {
    3629             const uint32_t cRefs = itArea->second->Area.AddRef();
    3630             RT_NOREF(cRefs);
    3631             LogFlowThisFunc(("aID=%RU32 -> cRefs=%RU32\n", aID, cRefs));
    3632             vrc = VINF_SUCCESS;
    3633         }
    3634         else
    3635             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3636                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3637 
    3638         int vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3639         AssertRC(vrc2);
    3640     }
    3641     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3642     return rc;
    3643 }
    3644 
    3645 /**
    3646  * Detaches from an existing clipboard area.
    3647  *
    3648  * @returns HRESULT
    3649  * @param   aID                 ID of clipboard area to detach from.
    3650  */
    3651 HRESULT VirtualBox::i_onClipboardAreaDetach(ULONG aID)
    3652 {
    3653     HRESULT rc = S_OK;
    3654 
    3655     int vrc = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3656     if (RT_SUCCESS(vrc))
    3657     {
    3658         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3659         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3660         {
    3661             const uint32_t cRefs = itArea->second->Area.Release();
    3662             RT_NOREF(cRefs);
    3663             LogFlowThisFunc(("aID=%RU32 -> cRefs=%RU32\n", aID, cRefs));
    3664             vrc = VINF_SUCCESS;
    3665         }
    3666         else
    3667             rc = setError(VBOX_E_OBJECT_NOT_FOUND, /** @todo Find a better rc. */
    3668                           tr("Could not find a registered clipboard area with ID %RU32"), aID);
    3669 
    3670         int rc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3671         AssertRC(rc2);
    3672     }
    3673     LogFlowThisFunc(("aID=%RU32, rc=%Rhrc\n", aID, rc));
    3674     return rc;
    3675 }
    3676 
    3677 /**
    3678  * Returns the ID of the most recent (last created) clipboard area,
    3679  * or NIL_SHCLAREAID if no clipboard area has been created yet.
    3680  *
    3681  * @returns Most recent clipboard area ID.
    3682  */
    3683 ULONG VirtualBox::i_onClipboardAreaGetMostRecent(void)
    3684 {
    3685     ULONG aID = 0;
    3686     int vrc2 = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3687     if (RT_SUCCESS(vrc2))
    3688     {
    3689         aID = m->SharedClipboard.uMostRecentClipboardAreaID;
    3690 
    3691         vrc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3692         AssertRC(vrc2);
    3693     }
    3694     LogFlowThisFunc(("aID=%RU32\n", aID));
    3695     return aID;
    3696 }
    3697 
    3698 /**
    3699  * Returns the current reference count of a clipboard area.
    3700  *
    3701  * @returns Reference count of given clipboard area ID.
    3702  */
    3703 ULONG VirtualBox::i_onClipboardAreaGetRefCount(ULONG aID)
    3704 {
    3705     ULONG cRefCount = 0;
    3706     int rc2 = RTCritSectEnter(&m->SharedClipboard.CritSect);
    3707     if (RT_SUCCESS(rc2))
    3708     {
    3709         SharedClipboardAreaMap::iterator itArea = m->SharedClipboard.mapClipboardAreas.find(aID);
    3710         if (itArea != m->SharedClipboard.mapClipboardAreas.end())
    3711         {
    3712             cRefCount = itArea->second->Area.GetRefCount();
    3713         }
    3714 
    3715         rc2 = RTCritSectLeave(&m->SharedClipboard.CritSect);
    3716         AssertRC(rc2);
    3717     }
    3718     LogFlowThisFunc(("aID=%RU32, cRefCount=%RU32\n", aID, cRefCount));
    3719     return cRefCount;
    3720 }
    3721 
    3722 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    3723 
    37243355/**
    37253356 *  @note Doesn't lock any object.
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