VirtualBox

Changeset 3412 in vbox for trunk


Ignore:
Timestamp:
Jul 4, 2007 11:25:35 AM (17 years ago)
Author:
vboxsync
Message:

Main: Converted USBDeviceFilter and HostUSBDeviceFilter to the new locking scheme.

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

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/USBDeviceFilterImpl.cpp

    r2981 r3412  
    2727#include "Logging.h"
    2828
     29#include <iprt/cpputils.h>
     30
    2931////////////////////////////////////////////////////////////////////////////////
    3032// USBDeviceFilter
     
    3436////////////////////////////////////////////////////////////////////////////////
    3537
     38DEFINE_EMPTY_CTOR_DTOR (USBDeviceFilter)
     39
    3640HRESULT USBDeviceFilter::FinalConstruct()
    3741{
     
    4852
    4953/**
    50  * Initializes the USB device filter object.
     54 *  Initializes the USB device filter object.
     55 *
     56 *  @param aParent  Handle of the parent object.
    5157 */
    5258HRESULT USBDeviceFilter::init (USBController *aParent,
     
    5864                               INPTR BSTR aPort, INPTR BSTR aRemote)
    5965{
    60     LogFlowMember (("USBDeviceFilter::init (%p)\n", aParent));
     66    LogFlowThisFunc (("aParent=%p\n", aParent));
    6167
    6268    ComAssertRet (aParent && aName && *aName, E_INVALIDARG);
    6369
    64     AutoLock alock (this);
    65     ComAssertRet (!isReady(), E_UNEXPECTED);
    66 
    67     mParent = aParent;
     70    /* Enclose the state transition NotReady->InInit->Ready */
     71    AutoInitSpan autoInitSpan (this);
     72    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     73
     74    unconst (mParent) = aParent;
     75    /* mPeer is left null */
     76
     77    /* register with parent early, since uninit() will unconditionally
     78     * unregister on failure */
     79    mParent->addDependentChild (this);
    6880
    6981    mData.allocate();
     
    7183    mData->mActive = aActive;
    7284
    73     // initialize all filters to any match using null string
     85    /* initialize all filters to any match using null string */
    7486    mData->mVendorId = NULL;
    7587    mData->mProductId = NULL;
     
    8395    mInList = false;
    8496
    85     // use setters for the attributes below to reuse parsing errors handling
    86     setReady (true);
     97    /* use setters for the attributes below to reuse parsing errors
     98     * handling */
     99
    87100    HRESULT rc = S_OK;
    88101    do
    89102    {
    90103        rc = COMSETTER(VendorId) (aVendorId);
    91         if (FAILED (rc))
    92             break;
     104        CheckComRCBreakRC (rc);
    93105        rc = COMSETTER(ProductId) (aProductId);
    94         if (FAILED (rc))
    95             break;
     106        CheckComRCBreakRC (rc);
    96107        rc = COMSETTER(Revision) (aRevision);
    97         if (FAILED (rc))
    98             break;
     108        CheckComRCBreakRC (rc);
    99109        rc = COMSETTER(Manufacturer) (aManufacturer);
    100         if (FAILED (rc))
    101             break;
     110        CheckComRCBreakRC (rc);
    102111        rc = COMSETTER(Product) (aProduct);
    103         if (FAILED (rc))
    104             break;
     112        CheckComRCBreakRC (rc);
    105113        rc = COMSETTER(SerialNumber) (aSerialNumber);
    106         if (FAILED (rc))
    107             break;
     114        CheckComRCBreakRC (rc);
    108115        rc = COMSETTER(Port) (aPort);
    109         if (FAILED (rc))
    110             break;
     116        CheckComRCBreakRC (rc);
    111117        rc = COMSETTER(Remote) (aRemote);
    112         if (FAILED (rc))
    113             break;
     118        CheckComRCBreakRC (rc);
    114119    }
    115120    while (0);
    116121
     122    /* Confirm successful initialization when it's the case */
    117123    if (SUCCEEDED (rc))
    118         mParent->addDependentChild (this);
    119     else
    120         setReady (false);
     124        autoInitSpan.setSucceeded();
    121125
    122126    return rc;
     
    124128
    125129/**
    126  * Initializes the USB device filter object (short version).
     130 *  Initializes the USB device filter object (short version).
     131 *
     132 *  @param aParent  Handle of the parent object.
    127133 */
    128134HRESULT USBDeviceFilter::init (USBController *aParent, INPTR BSTR aName)
    129135{
    130     LogFlowMember (("USBDeviceFilter::init (%p) [short]\n", aParent));
     136    LogFlowThisFunc (("aParent=%p\n", aParent));
    131137
    132138    ComAssertRet (aParent && aName && *aName, E_INVALIDARG);
    133139
    134     AutoLock alock (this);
    135     ComAssertRet (!isReady(), E_UNEXPECTED);
    136 
    137     mParent = aParent;
    138     // mPeer is left null
     140    /* Enclose the state transition NotReady->InInit->Ready */
     141    AutoInitSpan autoInitSpan (this);
     142    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     143
     144    unconst (mParent) = aParent;
     145    /* mPeer is left null */
     146
     147    /* register with parent early, since uninit() will unconditionally
     148     * unregister on failure */
     149    mParent->addDependentChild (this);
    139150
    140151    mData.allocate();
     
    143154    mData->mActive = FALSE;
    144155
    145     // initialize all filters to any match using null string
     156    /* initialize all filters to any match using null string */
    146157    mData->mVendorId = NULL;
    147158    mData->mProductId = NULL;
     
    155166    mInList = false;
    156167
    157     mParent->addDependentChild (this);
    158 
    159     setReady (true);
     168    /* Confirm successful initialization */
     169    autoInitSpan.setSucceeded();
     170
    160171    return S_OK;
    161172}
     
    173184 *  @note This object must be destroyed before the original object
    174185 *  it shares data with is destroyed.
     186 *
     187 *  @note Locks @a aThat object for writing if @a aReshare is @c true, or for
     188 *  reading if @a aReshare is false.
    175189 */
    176190HRESULT USBDeviceFilter::init (USBController *aParent, USBDeviceFilter *aThat,
    177191                               bool aReshare /* = false */)
    178192{
    179     LogFlowMember (("USBDeviceFilter::init (%p, %p): aReshare=%d\n",
    180                     aParent, aThat, aReshare));
     193    LogFlowThisFunc (("aParent=%p, aThat=%p, aReshare=%RTbool\n",
     194                      aParent, aThat, aReshare));
    181195
    182196    ComAssertRet (aParent && aThat, E_INVALIDARG);
    183197
    184     AutoLock alock (this);
    185     ComAssertRet (!isReady(), E_UNEXPECTED);
    186 
    187     mParent = aParent;
    188 
    189     AutoLock thatlock (aThat);
     198    /* Enclose the state transition NotReady->InInit->Ready */
     199    AutoInitSpan autoInitSpan (this);
     200    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     201
     202    unconst (mParent) = aParent;
     203
     204    /* register with parent early, since uninit() will unconditionally
     205     * unregister on failure */
     206    mParent->addDependentChild (this);
     207
     208    /* sanity */
     209    AutoCaller thatCaller (aThat);
     210    AssertComRCReturnRC (thatCaller.rc());
     211
    190212    if (aReshare)
    191213    {
    192         aThat->mPeer = this;
     214        AutoLock thatLock (aThat);
     215
     216        unconst (aThat->mPeer) = this;
    193217        mData.attach (aThat->mData);
    194218    }
    195219    else
    196220    {
    197         mPeer = aThat;
     221        unconst (mPeer) = aThat;
     222
     223        AutoReaderLock thatLock (aThat);
    198224        mData.share (aThat->mData);
    199225    }
    200226
    201     // the arbitrary ID field is not reset because
    202     // the copy is a shadow of the original
     227    /* the arbitrary ID field is not reset because
     228     * the copy is a shadow of the original */
    203229
    204230    mInList = aThat->mInList;
    205231
    206     mParent->addDependentChild (this);
    207 
    208     setReady (true);
     232    /* Confirm successful initialization */
     233    autoInitSpan.setSucceeded();
     234
    209235    return S_OK;
    210236}
     
    214240 *  (a kind of copy constructor). This object makes a private copy of data
    215241 *  of the original object passed as an argument.
     242 *
     243 *  @note Locks @a aThat object for reading.
    216244 */
    217245HRESULT USBDeviceFilter::initCopy (USBController *aParent, USBDeviceFilter *aThat)
    218246{
    219     LogFlowMember (("USBDeviceFilter::initCopy (%p, %p)\n", aParent, aThat));
     247    LogFlowThisFunc (("aParent=%p, aThat=%p\n", aParent, aThat));
    220248
    221249    ComAssertRet (aParent && aThat, E_INVALIDARG);
    222250
    223     AutoLock alock (this);
    224     ComAssertRet (!isReady(), E_UNEXPECTED);
    225 
    226     mParent = aParent;
    227     // mPeer is left null
    228 
    229     AutoLock thatlock (aThat);
     251    /* Enclose the state transition NotReady->InInit->Ready */
     252    AutoInitSpan autoInitSpan (this);
     253    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     254
     255    unconst (mParent) = aParent;
     256    /* mPeer is left null */
     257
     258    /* register with parent early, since uninit() will unconditionally
     259     * unregister on failure */
     260    mParent->addDependentChild (this);
     261
     262    /* sanity */
     263    AutoCaller thatCaller (aThat);
     264    AssertComRCReturnRC (thatCaller.rc());
     265
     266    AutoReaderLock thatLock (aThat);
    230267    mData.attachCopy (aThat->mData);
    231268
    232     // reset the arbitrary ID field
    233     // (this field is something unique that two distinct objects, even if they
    234     // are deep copies of each other, should not share)
     269    /* reset the arbitrary ID field
     270     * (this field is something unique that two distinct objects, even if they
     271     * are deep copies of each other, should not share) */
    235272    mData->mId = NULL;
    236273
    237274    mInList = aThat->mInList;
    238275
    239     mParent->addDependentChild (this);
    240 
    241     setReady (true);
     276    /* Confirm successful initialization */
     277    autoInitSpan.setSucceeded();
     278
    242279    return S_OK;
    243280}
     
    249286void USBDeviceFilter::uninit()
    250287{
    251     LogFlowMember (("USBDeviceFilter::uninit()\n"));
    252 
    253     AutoLock alock (this);
    254 
    255     LogFlowMember (("USBDeviceFilter::uninit(): isReady=%d\n", isReady()));
    256 
    257     if (!isReady())
     288    LogFlowThisFunc (("\n"));
     289
     290    /* Enclose the state transition Ready->InUninit->NotReady */
     291    AutoUninitSpan autoUninitSpan (this);
     292    if (autoUninitSpan.uninitDone())
    258293        return;
    259294
     
    262297    mData.free();
    263298
    264     setReady (false);
    265 
    266     alock.leave();
    267299    mParent->removeDependentChild (this);
    268     alock.enter();
    269 
    270     mPeer.setNull();
    271     mParent.setNull();
     300
     301    unconst (mPeer).setNull();
     302    unconst (mParent).setNull();
    272303}
    273304
     
    280311        return E_POINTER;
    281312
    282     AutoLock alock (this);
    283     CHECK_READY();
     313    AutoCaller autoCaller (this);
     314    CheckComRCReturnRC (autoCaller.rc());
     315
     316    AutoReaderLock alock (this);
    284317
    285318    mData->mName.cloneTo (aName);
     319
    286320    return S_OK;
    287321}
     
    292326        return E_INVALIDARG;
    293327
    294     AutoLock alock (this);
    295     CHECK_READY();
    296     CHECK_MACHINE_MUTABILITY (mParent->parent());
     328    AutoCaller autoCaller (this);
     329    CheckComRCReturnRC (autoCaller.rc());
     330
     331    /* the machine needs to be mutable */
     332    Machine::AutoMutableStateDependency adep (mParent->parent());
     333    CheckComRCReturnRC (adep.rc());
     334
     335    AutoLock alock (this);
    297336
    298337    if (mData->mName != aName)
     
    301340        mData->mName = aName;
    302341
    303         // notify parent
    304         alock.unlock();
     342        /* leave the lock before informing callbacks */
     343        alock.unlock();
     344
    305345        return mParent->onDeviceFilterChange (this);
    306346    }
     
    314354        return E_POINTER;
    315355
    316     AutoLock alock (this);
    317     CHECK_READY();
     356    AutoCaller autoCaller (this);
     357    CheckComRCReturnRC (autoCaller.rc());
     358
     359    AutoReaderLock alock (this);
    318360
    319361    *aActive = mData->mActive;
     362
    320363    return S_OK;
    321364}
     
    323366STDMETHODIMP USBDeviceFilter::COMSETTER(Active) (BOOL aActive)
    324367{
    325     AutoLock alock (this);
    326     CHECK_READY();
    327     CHECK_MACHINE_MUTABILITY (mParent->parent());
     368    AutoCaller autoCaller (this);
     369    CheckComRCReturnRC (autoCaller.rc());
     370
     371    /* the machine needs to be mutable */
     372    Machine::AutoMutableStateDependency adep (mParent->parent());
     373    CheckComRCReturnRC (adep.rc());
     374
     375    AutoLock alock (this);
    328376
    329377    if (mData->mActive != aActive)
     
    332380        mData->mActive = aActive;
    333381
    334         // notify parent
    335         alock.unlock();
     382        /* leave the lock before informing callbacks */
     383        alock.unlock();
     384
    336385        return mParent->onDeviceFilterChange (this, TRUE /* aActiveChanged */);
    337386    }
     
    345394        return E_POINTER;
    346395
    347     AutoLock alock (this);
    348     CHECK_READY();
     396    AutoCaller autoCaller (this);
     397    CheckComRCReturnRC (autoCaller.rc());
     398
     399    AutoReaderLock alock (this);
    349400
    350401    mData->mVendorId.string().cloneTo (aVendorId);
     402
    351403    return S_OK;
    352404}
     
    354406STDMETHODIMP USBDeviceFilter::COMSETTER(VendorId) (INPTR BSTR aVendorId)
    355407{
    356     AutoLock alock (this);
    357     CHECK_READY();
    358     CHECK_MACHINE_MUTABILITY (mParent->parent());
     408    AutoCaller autoCaller (this);
     409    CheckComRCReturnRC (autoCaller.rc());
     410
     411    /* the machine needs to be mutable */
     412    Machine::AutoMutableStateDependency adep (mParent->parent());
     413    CheckComRCReturnRC (adep.rc());
     414
     415    AutoLock alock (this);
    359416
    360417    if (mData->mVendorId.string() != aVendorId)
     
    377434        mData->mVendorId = flt;
    378435
    379         // notify parent
    380         alock.unlock();
     436        /* leave the lock before informing callbacks */
     437        alock.unlock();
     438
    381439        return mParent->onDeviceFilterChange (this);
    382440    }
     
    390448        return E_POINTER;
    391449
    392     AutoLock alock (this);
    393     CHECK_READY();
     450    AutoCaller autoCaller (this);
     451    CheckComRCReturnRC (autoCaller.rc());
     452
     453    AutoReaderLock alock (this);
    394454
    395455    mData->mProductId.string().cloneTo (aProductId);
     456
    396457    return S_OK;
    397458}
     
    399460STDMETHODIMP USBDeviceFilter::COMSETTER(ProductId) (INPTR BSTR aProductId)
    400461{
    401     AutoLock alock (this);
    402     CHECK_READY();
    403     CHECK_MACHINE_MUTABILITY (mParent->parent());
     462    AutoCaller autoCaller (this);
     463    CheckComRCReturnRC (autoCaller.rc());
     464
     465    /* the machine needs to be mutable */
     466    Machine::AutoMutableStateDependency adep (mParent->parent());
     467    CheckComRCReturnRC (adep.rc());
     468
     469    AutoLock alock (this);
    404470
    405471    if (mData->mProductId.string() != aProductId)
     
    422488        mData->mProductId = flt;
    423489
    424         // notify parent
    425         alock.unlock();
     490        /* leave the lock before informing callbacks */
     491        alock.unlock();
     492
    426493        return mParent->onDeviceFilterChange (this);
    427494    }
     
    435502        return E_POINTER;
    436503
    437     AutoLock alock (this);
    438     CHECK_READY();
     504    AutoCaller autoCaller (this);
     505    CheckComRCReturnRC (autoCaller.rc());
     506
     507    AutoReaderLock alock (this);
    439508
    440509    mData->mRevision.string().cloneTo (aRevision);
     510
    441511    return S_OK;
    442512}
     
    444514STDMETHODIMP USBDeviceFilter::COMSETTER(Revision) (INPTR BSTR aRevision)
    445515{
    446     AutoLock alock (this);
    447     CHECK_READY();
    448     CHECK_MACHINE_MUTABILITY (mParent->parent());
     516    AutoCaller autoCaller (this);
     517    CheckComRCReturnRC (autoCaller.rc());
     518
     519    /* the machine needs to be mutable */
     520    Machine::AutoMutableStateDependency adep (mParent->parent());
     521    CheckComRCReturnRC (adep.rc());
     522
     523    AutoLock alock (this);
    449524
    450525    if (mData->mRevision.string() != aRevision)
     
    467542        mData->mRevision = flt;
    468543
    469         // notify parent
    470         alock.unlock();
     544        /* leave the lock before informing callbacks */
     545        alock.unlock();
     546
    471547        return mParent->onDeviceFilterChange (this);
    472548    }
     
    480556        return E_POINTER;
    481557
    482     AutoLock alock (this);
    483     CHECK_READY();
     558    AutoCaller autoCaller (this);
     559    CheckComRCReturnRC (autoCaller.rc());
     560
     561    AutoReaderLock alock (this);
    484562
    485563    mData->mManufacturer.string().cloneTo (aManufacturer);
     
    489567STDMETHODIMP USBDeviceFilter::COMSETTER(Manufacturer) (INPTR BSTR aManufacturer)
    490568{
    491     AutoLock alock (this);
    492     CHECK_READY();
    493     CHECK_MACHINE_MUTABILITY (mParent->parent());
     569    AutoCaller autoCaller (this);
     570    CheckComRCReturnRC (autoCaller.rc());
     571
     572    /* the machine needs to be mutable */
     573    Machine::AutoMutableStateDependency adep (mParent->parent());
     574    CheckComRCReturnRC (adep.rc());
     575
     576    AutoLock alock (this);
    494577
    495578    if (mData->mManufacturer.string() != aManufacturer)
     
    505588        mData->mManufacturer = flt;
    506589
    507         // notify parent
    508         alock.unlock();
     590        /* leave the lock before informing callbacks */
     591        alock.unlock();
     592
    509593        return mParent->onDeviceFilterChange (this);
    510594    }
     
    518602        return E_POINTER;
    519603
    520     AutoLock alock (this);
    521     CHECK_READY();
     604    AutoCaller autoCaller (this);
     605    CheckComRCReturnRC (autoCaller.rc());
     606
     607    AutoReaderLock alock (this);
    522608
    523609    mData->mProduct.string().cloneTo (aProduct);
     610
    524611    return S_OK;
    525612}
     
    527614STDMETHODIMP USBDeviceFilter::COMSETTER(Product) (INPTR BSTR aProduct)
    528615{
    529     AutoLock alock (this);
    530     CHECK_READY();
    531     CHECK_MACHINE_MUTABILITY (mParent->parent());
     616    AutoCaller autoCaller (this);
     617    CheckComRCReturnRC (autoCaller.rc());
     618
     619    /* the machine needs to be mutable */
     620    Machine::AutoMutableStateDependency adep (mParent->parent());
     621    CheckComRCReturnRC (adep.rc());
     622
     623    AutoLock alock (this);
    532624
    533625    if (mData->mProduct.string() != aProduct)
     
    543635        mData->mProduct = flt;
    544636
    545         // notify parent
    546         alock.unlock();
     637        /* leave the lock before informing callbacks */
     638        alock.unlock();
     639
    547640        return mParent->onDeviceFilterChange (this);
    548641    }
     
    556649        return E_POINTER;
    557650
    558     AutoLock alock (this);
    559     CHECK_READY();
     651    AutoCaller autoCaller (this);
     652    CheckComRCReturnRC (autoCaller.rc());
     653
     654    AutoReaderLock alock (this);
    560655
    561656    mData->mSerialNumber.string().cloneTo (aSerialNumber);
     657
    562658    return S_OK;
    563659}
     
    565661STDMETHODIMP USBDeviceFilter::COMSETTER(SerialNumber) (INPTR BSTR aSerialNumber)
    566662{
    567     AutoLock alock (this);
    568     CHECK_READY();
    569     CHECK_MACHINE_MUTABILITY (mParent->parent());
     663    AutoCaller autoCaller (this);
     664    CheckComRCReturnRC (autoCaller.rc());
     665
     666    /* the machine needs to be mutable */
     667    Machine::AutoMutableStateDependency adep (mParent->parent());
     668    CheckComRCReturnRC (adep.rc());
     669
     670    AutoLock alock (this);
    570671
    571672    if (mData->mSerialNumber.string() != aSerialNumber)
     
    581682        mData->mSerialNumber = flt;
    582683
    583         // notify parent
    584         alock.unlock();
     684        /* leave the lock before informing callbacks */
     685        alock.unlock();
     686
    585687        return mParent->onDeviceFilterChange (this);
    586688    }
     
    594696        return E_POINTER;
    595697
    596     AutoLock alock (this);
    597     CHECK_READY();
     698    AutoCaller autoCaller (this);
     699    CheckComRCReturnRC (autoCaller.rc());
     700
     701    AutoReaderLock alock (this);
    598702
    599703    mData->mPort.string().cloneTo (aPort);
     704
    600705    return S_OK;
    601706}
     
    603708STDMETHODIMP USBDeviceFilter::COMSETTER(Port) (INPTR BSTR aPort)
    604709{
    605     AutoLock alock (this);
    606     CHECK_READY();
    607     CHECK_MACHINE_MUTABILITY (mParent->parent());
     710    AutoCaller autoCaller (this);
     711    CheckComRCReturnRC (autoCaller.rc());
     712
     713    /* the machine needs to be mutable */
     714    Machine::AutoMutableStateDependency adep (mParent->parent());
     715    CheckComRCReturnRC (adep.rc());
     716
     717    AutoLock alock (this);
    608718
    609719    if (mData->mPort.string() != aPort)
     
    626736        mData->mPort = flt;
    627737
    628         // notify parent
    629         alock.unlock();
     738        /* leave the lock before informing callbacks */
     739        alock.unlock();
     740
    630741        return mParent->onDeviceFilterChange (this);
    631742    }
     
    639750        return E_POINTER;
    640751
    641     AutoLock alock (this);
    642     CHECK_READY();
     752    AutoCaller autoCaller (this);
     753    CheckComRCReturnRC (autoCaller.rc());
     754
     755    AutoReaderLock alock (this);
    643756
    644757    mData->mRemote.string().cloneTo (aRemote);
     758
    645759    return S_OK;
    646760}
     
    648762STDMETHODIMP USBDeviceFilter::COMSETTER(Remote) (INPTR BSTR aRemote)
    649763{
    650     AutoLock alock (this);
    651     CHECK_READY();
    652     CHECK_MACHINE_MUTABILITY (mParent->parent());
     764    AutoCaller autoCaller (this);
     765    CheckComRCReturnRC (autoCaller.rc());
     766
     767    /* the machine needs to be mutable */
     768    Machine::AutoMutableStateDependency adep (mParent->parent());
     769    CheckComRCReturnRC (adep.rc());
     770
     771    AutoLock alock (this);
    653772
    654773    if (mData->mRemote.string() != aRemote)
     
    664783        mData->mRemote = flt;
    665784
    666         // notify parent
    667         alock.unlock();
     785        /* leave the lock before informing callbacks */
     786        alock.unlock();
     787
    668788        return mParent->onDeviceFilterChange (this);
    669789    }
     
    675795////////////////////////////////////////////////////////////////////////////////
    676796
     797/**
     798 *  @note Locks this object for writing.
     799 */
     800bool USBDeviceFilter::rollback()
     801{
     802    /* sanity */
     803    AutoCaller autoCaller (this);
     804    AssertComRCReturn (autoCaller.rc(), false);
     805
     806    AutoLock alock (this);
     807
     808    bool changed = false;
     809
     810    if (mData.isBackedUp())
     811    {
     812        /* we need to check all data to see whether anything will be changed
     813         * after rollback */
     814        changed = mData.hasActualChanges();
     815        mData.rollback();
     816    }
     817
     818    return changed;
     819}
     820
     821/**
     822 *  @note Locks this object for writing, together with the peer object (also
     823 *  for writing) if there is one.
     824 */
    677825void USBDeviceFilter::commit()
    678826{
    679     AutoLock alock (this);
     827    /* sanity */
     828    AutoCaller autoCaller (this);
     829    AssertComRCReturnVoid (autoCaller.rc());
     830
     831    /* sanity too */
     832    AutoCaller thatCaller (mPeer);
     833    AssertComRCReturnVoid (thatCaller.rc());
     834
     835    /* lock both for writing since we modify both */
     836    AutoMultiLock <2> alock (this->wlock(), AutoLock::maybeWlock (mPeer));
     837
    680838    if (mData.isBackedUp())
    681839    {
     
    683841        if (mPeer)
    684842        {
    685             // attach new data to the peer and reshare it
    686             AutoLock peerlock (mPeer);
     843            /* attach new data to the peer and reshare it */
    687844            mPeer->mData.attach (mData);
    688845        }
     
    693850 *  Cancels sharing (if any) by making an independent copy of data.
    694851 *  This operation also resets this object's peer to NULL.
     852 *
     853 *  @note Locks this object for writing, together with the peer object
     854 *  represented by @a aThat (locked for reading).
    695855 */
    696856void USBDeviceFilter::unshare()
    697857{
    698     AutoLock alock (this);
     858    /* sanity */
     859    AutoCaller autoCaller (this);
     860    AssertComRCReturnVoid (autoCaller.rc());
     861
     862    /* sanity too */
     863    AutoCaller thatCaller (mPeer);
     864    AssertComRCReturnVoid (thatCaller.rc());
     865     
     866    /* peer is not modified, lock it for reading */
     867    AutoMultiLock <2> alock (this->wlock(), AutoLock::maybeRlock (mPeer));
     868   
    699869    if (mData.isShared())
    700870    {
     871
    701872        if (!mData.isBackedUp())
    702873            mData.backup();
     874
    703875        mData.commit();
    704876    }
    705     mPeer.setNull();
     877
     878    unconst (mPeer).setNull();
    706879}
    707880
     
    713886////////////////////////////////////////////////////////////////////////////////
    714887
     888DEFINE_EMPTY_CTOR_DTOR (HostUSBDeviceFilter)
     889
    715890HRESULT HostUSBDeviceFilter::FinalConstruct()
    716891{
     
    727902
    728903/**
    729  * Initializes the USB device filter object.
     904 *  Initializes the USB device filter object.
     905 *
     906 *  @param aParent  Handle of the parent object.
    730907 */
    731908HRESULT HostUSBDeviceFilter::init (Host *aParent,
     
    738915                                   USBDeviceFilterAction_T aAction)
    739916{
    740     LogFlowMember (("HostUSBDeviceFilter::init(): isReady=%d\n", isReady()));
     917    LogFlowThisFunc (("aParent=%p\n", aParent));
    741918
    742919    ComAssertRet (aParent && aName && *aName, E_INVALIDARG);
    743920
    744     AutoLock alock (this);
    745     ComAssertRet (!isReady(), E_UNEXPECTED);
    746 
    747     mParent = aParent;
     921    /* Enclose the state transition NotReady->InInit->Ready */
     922    AutoInitSpan autoInitSpan (this);
     923    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     924
     925    unconst (mParent) = aParent;
     926
     927    /* register with parent early, since uninit() will unconditionally
     928     * unregister on failure */
     929    mParent->addDependentChild (this);
    748930
    749931    mData.allocate();
     
    752934    mData->mAction = aAction;
    753935
    754     // initialize all filters to any match using null string
     936    /* initialize all filters to any match using null string */
    755937    mData->mVendorId = NULL;
    756938    mData->mProductId = NULL;
     
    764946    mInList = false;
    765947
    766     // use setters for the attributes below to reuse parsing errors handling
    767     setReady (true);
    768     HRESULT rc;
     948    /* use setters for the attributes below to reuse parsing errors
     949     * handling */
     950
     951    HRESULT rc = S_OK;
    769952    do
    770953    {
    771954        rc = COMSETTER(VendorId) (aVendorId);
    772         if (FAILED (rc))
    773             break;
     955        CheckComRCBreakRC (rc);
    774956        rc = COMSETTER(ProductId) (aProductId);
    775         if (FAILED (rc))
    776             break;
     957        CheckComRCBreakRC (rc);
    777958        rc = COMSETTER(Revision) (aRevision);
    778         if (FAILED (rc))
    779             break;
     959        CheckComRCBreakRC (rc);
    780960        rc = COMSETTER(Manufacturer) (aManufacturer);
    781         if (FAILED (rc))
    782             break;
     961        CheckComRCBreakRC (rc);
    783962        rc = COMSETTER(Product) (aProduct);
    784         if (FAILED (rc))
    785             break;
     963        CheckComRCBreakRC (rc);
    786964        rc = COMSETTER(SerialNumber) (aSerialNumber);
    787         if (FAILED (rc))
    788             break;
     965        CheckComRCBreakRC (rc);
    789966        rc = COMSETTER(Port) (aPort);
    790         if (FAILED (rc))
    791             break;
     967        CheckComRCBreakRC (rc);
    792968    }
    793969    while (0);
    794970
     971    /* Confirm successful initialization when it's the case */
    795972    if (SUCCEEDED (rc))
    796         mParent->addDependentChild (this);
    797     else
    798         setReady (false);
     973        autoInitSpan.setSucceeded();
    799974
    800975    return rc;
     
    802977
    803978/**
    804  * Initializes the USB device filter object (short version).
     979 *  Initializes the USB device filter object (short version).
     980 *
     981 *  @param aParent  Handle of the parent object.
    805982 */
    806983HRESULT HostUSBDeviceFilter::init (Host *aParent, INPTR BSTR aName)
    807984{
    808     LogFlowMember (("HostUSBDeviceFilter::init(): isReady=%d\n", isReady()));
     985    LogFlowThisFunc (("aParent=%p\n", aParent));
    809986
    810987    ComAssertRet (aParent && aName && *aName, E_INVALIDARG);
    811988
    812     AutoLock alock (this);
    813     ComAssertRet (!isReady(), E_UNEXPECTED);
    814 
    815     mParent = aParent;
     989    /* Enclose the state transition NotReady->InInit->Ready */
     990    AutoInitSpan autoInitSpan (this);
     991    AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
     992
     993    unconst (mParent) = aParent;
     994
     995    /* register with parent early, since uninit() will unconditionally
     996     * unregister on failure */
     997    mParent->addDependentChild (this);
    816998
    817999    mData.allocate();
     1000
    8181001    mData->mName = aName;
    8191002    mData->mActive = FALSE;
     
    8221005    mInList = false;
    8231006
    824     // initialize all filters using null string (any match)
     1007    /* initialize all filters to any match using null string */
    8251008    mData->mVendorId = NULL;
    8261009    mData->mProductId = NULL;
     
    8321015    mData->mRemote = NULL;
    8331016
    834     mParent->addDependentChild (this);
    835 
    836     setReady (true);
     1017    /* Confirm successful initialization */
     1018    autoInitSpan.setSucceeded();
     1019
    8371020    return S_OK;
    8381021}
     
    8441027void HostUSBDeviceFilter::uninit()
    8451028{
    846     LogFlowMember (("HostUSBDeviceFilter::uninit()\n"));
    847 
    848     AutoLock alock (this);
    849 
    850     LogFlowMember (("HostUSBDeviceFilter::uninit(): isReady=%d\n", isReady()));
    851 
    852     if (!isReady())
     1029    LogFlowThisFunc (("\n"));
     1030
     1031    /* Enclose the state transition Ready->InUninit->NotReady */
     1032    AutoUninitSpan autoUninitSpan (this);
     1033    if (autoUninitSpan.uninitDone())
    8531034        return;
    8541035
     
    8571038    mData.free();
    8581039
    859     setReady (false);
    860 
    861     alock.leave();
    8621040    mParent->removeDependentChild (this);
    863     alock.enter();
    864 
    865     mParent.setNull();
     1041
     1042    unconst (mParent).setNull();
    8661043}
    8671044
     
    8741051        return E_POINTER;
    8751052
    876     AutoLock alock (this);
    877     CHECK_READY();
     1053    AutoCaller autoCaller (this);
     1054    CheckComRCReturnRC (autoCaller.rc());
     1055
     1056    AutoReaderLock alock (this);
    8781057
    8791058    mData->mName.cloneTo (aName);
     1059
    8801060    return S_OK;
    8811061}
     
    8861066        return E_INVALIDARG;
    8871067
    888     AutoLock alock (this);
    889     CHECK_READY();
     1068    AutoCaller autoCaller (this);
     1069    CheckComRCReturnRC (autoCaller.rc());
     1070
     1071    AutoLock alock (this);
    8901072
    8911073    if (mData->mName != aName)
     
    8931075        mData->mName = aName;
    8941076
    895         // notify parent
    896         alock.unlock();
     1077        /* leave the lock before informing callbacks */
     1078        alock.unlock();
     1079
    8971080        return mParent->onUSBDeviceFilterChange (this);
    8981081    }
     
    9061089        return E_POINTER;
    9071090
    908     AutoLock alock (this);
    909     CHECK_READY();
     1091    AutoCaller autoCaller (this);
     1092    CheckComRCReturnRC (autoCaller.rc());
     1093
     1094    AutoReaderLock alock (this);
    9101095
    9111096    *aActive = mData->mActive;
     1097
    9121098    return S_OK;
    9131099}
     
    9151101STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Active) (BOOL aActive)
    9161102{
    917     AutoLock alock (this);
    918     CHECK_READY();
     1103    AutoCaller autoCaller (this);
     1104    CheckComRCReturnRC (autoCaller.rc());
     1105
     1106    AutoLock alock (this);
    9191107
    9201108    if (mData->mActive != aActive)
     
    9221110        mData->mActive = aActive;
    9231111
    924         // notify parent
    925         alock.unlock();
     1112        /* leave the lock before informing callbacks */
     1113        alock.unlock();
     1114
    9261115        return mParent->onUSBDeviceFilterChange (this, TRUE /* aActiveChanged  */);
    9271116    }
     
    9351124        return E_POINTER;
    9361125
    937     AutoLock alock (this);
    938     CHECK_READY();
     1126    AutoCaller autoCaller (this);
     1127    CheckComRCReturnRC (autoCaller.rc());
     1128
     1129    AutoReaderLock alock (this);
    9391130
    9401131    mData->mVendorId.string().cloneTo (aVendorId);
     1132
    9411133    return S_OK;
    9421134}
     
    9441136STDMETHODIMP HostUSBDeviceFilter::COMSETTER(VendorId) (INPTR BSTR aVendorId)
    9451137{
    946     AutoLock alock (this);
    947     CHECK_READY();
     1138    AutoCaller autoCaller (this);
     1139    CheckComRCReturnRC (autoCaller.rc());
     1140
     1141    AutoLock alock (this);
    9481142
    9491143    if (mData->mVendorId.string() != aVendorId)
     
    9651159        mData->mVendorId = flt;
    9661160
    967         // notify parent
    968         alock.unlock();
     1161        /* leave the lock before informing callbacks */
     1162        alock.unlock();
     1163
    9691164        return mParent->onUSBDeviceFilterChange (this);
    9701165    }
     
    9781173        return E_POINTER;
    9791174
    980     AutoLock alock (this);
    981     CHECK_READY();
     1175    AutoCaller autoCaller (this);
     1176    CheckComRCReturnRC (autoCaller.rc());
     1177
     1178    AutoReaderLock alock (this);
    9821179
    9831180    mData->mProductId.string().cloneTo (aProductId);
     1181
    9841182    return S_OK;
    9851183}
     
    9871185STDMETHODIMP HostUSBDeviceFilter::COMSETTER(ProductId) (INPTR BSTR aProductId)
    9881186{
    989     AutoLock alock (this);
    990     CHECK_READY();
     1187    AutoCaller autoCaller (this);
     1188    CheckComRCReturnRC (autoCaller.rc());
     1189
     1190    AutoLock alock (this);
    9911191
    9921192    if (mData->mProductId.string() != aProductId)
     
    10081208        mData->mProductId = flt;
    10091209
    1010         // notify parent
    1011         alock.unlock();
     1210        /* leave the lock before informing callbacks */
     1211        alock.unlock();
     1212
    10121213        return mParent->onUSBDeviceFilterChange (this);
    10131214    }
     
    10211222        return E_POINTER;
    10221223
    1023     AutoLock alock (this);
    1024     CHECK_READY();
     1224    AutoCaller autoCaller (this);
     1225    CheckComRCReturnRC (autoCaller.rc());
     1226
     1227    AutoReaderLock alock (this);
    10251228
    10261229    mData->mRevision.string().cloneTo (aRevision);
     1230
    10271231    return S_OK;
    10281232}
     
    10301234STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Revision) (INPTR BSTR aRevision)
    10311235{
    1032     AutoLock alock (this);
    1033     CHECK_READY();
     1236    AutoCaller autoCaller (this);
     1237    CheckComRCReturnRC (autoCaller.rc());
     1238
     1239    AutoLock alock (this);
    10341240
    10351241    if (mData->mRevision.string() != aRevision)
     
    10511257        mData->mRevision = flt;
    10521258
    1053         // notify parent
    1054         alock.unlock();
     1259        /* leave the lock before informing callbacks */
     1260        alock.unlock();
     1261
    10551262        return mParent->onUSBDeviceFilterChange (this);
    10561263    }
     
    10641271        return E_POINTER;
    10651272
    1066     AutoLock alock (this);
    1067     CHECK_READY();
     1273    AutoCaller autoCaller (this);
     1274    CheckComRCReturnRC (autoCaller.rc());
     1275
     1276    AutoReaderLock alock (this);
    10681277
    10691278    mData->mManufacturer.string().cloneTo (aManufacturer);
     1279
    10701280    return S_OK;
    10711281}
     
    10731283STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Manufacturer) (INPTR BSTR aManufacturer)
    10741284{
    1075     AutoLock alock (this);
    1076     CHECK_READY();
     1285    AutoCaller autoCaller (this);
     1286    CheckComRCReturnRC (autoCaller.rc());
     1287
     1288    AutoLock alock (this);
    10771289
    10781290    if (mData->mManufacturer.string() != aManufacturer)
     
    10871299        mData->mManufacturer = flt;
    10881300
    1089         // notify parent
    1090         alock.unlock();
     1301        /* leave the lock before informing callbacks */
     1302        alock.unlock();
     1303
    10911304        return mParent->onUSBDeviceFilterChange (this);
    10921305    }
     
    11001313        return E_POINTER;
    11011314
    1102     AutoLock alock (this);
    1103     CHECK_READY();
     1315    AutoCaller autoCaller (this);
     1316    CheckComRCReturnRC (autoCaller.rc());
     1317
     1318    AutoReaderLock alock (this);
    11041319
    11051320    mData->mProduct.string().cloneTo (aProduct);
     1321
    11061322    return S_OK;
    11071323}
     
    11091325STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Product) (INPTR BSTR aProduct)
    11101326{
    1111     AutoLock alock (this);
    1112     CHECK_READY();
     1327    AutoCaller autoCaller (this);
     1328    CheckComRCReturnRC (autoCaller.rc());
     1329
     1330    AutoLock alock (this);
    11131331
    11141332    if (mData->mProduct.string() != aProduct)
     
    11231341        mData->mProduct = flt;
    11241342
    1125         // notify parent
    1126         alock.unlock();
     1343        /* leave the lock before informing callbacks */
     1344        alock.unlock();
     1345
    11271346        return mParent->onUSBDeviceFilterChange (this);
    11281347    }
     
    11361355        return E_POINTER;
    11371356
    1138     AutoLock alock (this);
    1139     CHECK_READY();
     1357    AutoCaller autoCaller (this);
     1358    CheckComRCReturnRC (autoCaller.rc());
     1359
     1360    AutoReaderLock alock (this);
    11401361
    11411362    mData->mSerialNumber.string().cloneTo (aSerialNumber);
     1363
    11421364    return S_OK;
    11431365}
     
    11451367STDMETHODIMP HostUSBDeviceFilter::COMSETTER(SerialNumber) (INPTR BSTR aSerialNumber)
    11461368{
    1147     AutoLock alock (this);
    1148     CHECK_READY();
     1369    AutoCaller autoCaller (this);
     1370    CheckComRCReturnRC (autoCaller.rc());
     1371
     1372    AutoLock alock (this);
    11491373
    11501374    if (mData->mSerialNumber.string() != aSerialNumber)
     
    11591383        mData->mSerialNumber = flt;
    11601384
    1161         // notify parent
    1162         alock.unlock();
     1385        /* leave the lock before informing callbacks */
     1386        alock.unlock();
     1387
    11631388        return mParent->onUSBDeviceFilterChange (this);
    11641389    }
     
    11721397        return E_POINTER;
    11731398
    1174     AutoLock alock (this);
    1175     CHECK_READY();
     1399    AutoCaller autoCaller (this);
     1400    CheckComRCReturnRC (autoCaller.rc());
     1401
     1402    AutoReaderLock alock (this);
    11761403
    11771404    mData->mPort.string().cloneTo (aPort);
     1405
    11781406    return S_OK;
    11791407}
     
    11811409STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Port) (INPTR BSTR aPort)
    11821410{
    1183     AutoLock alock (this);
    1184     CHECK_READY();
     1411    AutoCaller autoCaller (this);
     1412    CheckComRCReturnRC (autoCaller.rc());
     1413
     1414    AutoLock alock (this);
    11851415
    11861416    if (mData->mPort.string() != aPort)
     
    12021432        mData->mPort = flt;
    12031433
    1204         // notify parent
    1205         alock.unlock();
     1434        /* leave the lock before informing callbacks */
     1435        alock.unlock();
     1436
    12061437        return mParent->onUSBDeviceFilterChange (this);
    12071438    }
     
    12151446        return E_POINTER;
    12161447
    1217     AutoLock alock (this);
    1218     CHECK_READY();
     1448    AutoCaller autoCaller (this);
     1449    CheckComRCReturnRC (autoCaller.rc());
     1450
     1451    AutoReaderLock alock (this);
    12191452
    12201453    mData->mRemote.string().cloneTo (aRemote);
     1454
    12211455    return S_OK;
    12221456}
     
    12371471        return E_POINTER;
    12381472
    1239     AutoLock alock (this);
    1240     CHECK_READY();
     1473    AutoCaller autoCaller (this);
     1474    CheckComRCReturnRC (autoCaller.rc());
     1475
     1476    AutoReaderLock alock (this);
    12411477
    12421478    *aAction = mData->mAction;
     1479
    12431480    return S_OK;
    12441481}
     
    12461483STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Action) (USBDeviceFilterAction_T aAction)
    12471484{
    1248     AutoLock alock (this);
    1249     CHECK_READY();
     1485    AutoCaller autoCaller (this);
     1486    CheckComRCReturnRC (autoCaller.rc());
     1487
     1488    AutoLock alock (this);
    12501489
    12511490    if (mData->mAction != aAction)
     
    12531492        mData->mAction = aAction;
    12541493
    1255         // notify parent
    1256         alock.unlock();
     1494        /* leave the lock before informing callbacks */
     1495        alock.unlock();
     1496
    12571497        return mParent->onUSBDeviceFilterChange (this);
    12581498    }
  • trunk/src/VBox/Main/include/USBControllerImpl.h

    r2981 r3412  
    101101    // public methods only for internal purposes
    102102
    103     const ComObjPtr <Machine, ComWeakRef> &parent() { return mParent; };
    104 
    105103    HRESULT loadSettings (CFGNODE aMachine);
    106104    HRESULT saveSettings (CFGNODE aMachine);
     
    111109    void commit();
    112110    void copyFrom (USBController *aThat);
    113 
    114     const Backupable<Data> &data() { return mData; }
    115111
    116112    HRESULT onMachineRegistered (BOOL aRegistered);
     
    123119
    124120    HRESULT notifyProxy (bool aInsertFilters);
     121
     122    // public methods for internal purposes only
     123    // (ensure there is a caller and a read lock before calling them!)
     124
     125    /** @note this doesn't require a read lock since mParent is constant. */
     126    const ComObjPtr <Machine, ComWeakRef> &parent() { return mParent; };
     127
     128    const Backupable<Data> &data() { return mData; }
    125129
    126130    // for VirtualBoxSupportErrorInfoImpl
  • trunk/src/VBox/Main/include/USBDeviceFilterImpl.h

    r2981 r3412  
    3636
    3737class ATL_NO_VTABLE USBDeviceFilter :
     38    public VirtualBoxBaseNEXT,
    3839    public VirtualBoxSupportErrorInfoImpl <USBDeviceFilter, IUSBDeviceFilter>,
    3940    public VirtualBoxSupportTranslation <USBDeviceFilter>,
    40     public VirtualBoxBase,
    4141    public IUSBDeviceFilter
    4242{
     
    101101    };
    102102
     103    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (USBDeviceFilter)
     104
    103105    DECLARE_NOT_AGGREGATABLE(USBDeviceFilter)
    104106
     
    111113
    112114    NS_DECL_ISUPPORTS
     115
     116    DECLARE_EMPTY_CTOR_DTOR (USBDeviceFilter)
    113117
    114118    HRESULT FinalConstruct();
     
    153157    // public methods only for internal purposes
    154158
     159    bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
     160    bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }
     161    bool rollback();
     162    void commit();
     163
     164    void unshare();
     165
     166    // public methods for internal purposes only
     167    // (ensure there is a caller and a read lock before calling them!)
     168
    155169    void *& id() { return mData.data()->mId; }
    156170
     
    158172    ComObjPtr <USBDeviceFilter> peer() { return mPeer; }
    159173
    160     bool isModified() { AutoLock alock (this); return mData.isBackedUp(); }
    161     bool isReallyModified() { AutoLock alock (this); return mData.hasActualChanges(); }
    162     void rollback() { AutoLock alock (this); mData.rollback(); }
    163     void commit();
    164 
    165     void unshare();
    166 
    167174    // for VirtualBoxSupportErrorInfoImpl
    168175    static const wchar_t *getComponentName() { return L"USBDeviceFilter"; }
     
    170177private:
    171178
    172     ComObjPtr <USBController, ComWeakRef> mParent;
    173     ComObjPtr <USBDeviceFilter> mPeer;
     179    const ComObjPtr <USBController, ComWeakRef> mParent;
     180    const ComObjPtr <USBDeviceFilter> mPeer;
     181
    174182    Backupable <Data> mData;
    175183
     
    185193
    186194class ATL_NO_VTABLE HostUSBDeviceFilter :
     195    public VirtualBoxBaseNEXT,
    187196    public VirtualBoxSupportErrorInfoImpl <HostUSBDeviceFilter, IHostUSBDeviceFilter>,
    188197    public VirtualBoxSupportTranslation <HostUSBDeviceFilter>,
    189     public VirtualBoxBase,
    190198    public IHostUSBDeviceFilter
    191199{
     
    198206        USBDeviceFilterAction_T mAction;
    199207    };
     208
     209    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (HostUSBDeviceFilter)
    200210
    201211    DECLARE_NOT_AGGREGATABLE(HostUSBDeviceFilter)
     
    210220
    211221    NS_DECL_ISUPPORTS
     222
     223    DECLARE_EMPTY_CTOR_DTOR (HostUSBDeviceFilter)
    212224
    213225    HRESULT FinalConstruct();
     
    254266    // public methods only for internal purposes
    255267
     268    // public methods for internal purposes only
     269    // (ensure there is a caller and a read lock before calling them!)
     270
    256271    void *& id() { return mData.data()->mId; }
    257272
     
    263278private:
    264279
    265     ComObjPtr <Host, ComWeakRef> mParent;
     280    const ComObjPtr <Host, ComWeakRef> mParent;
     281
    266282    Backupable <Data> mData;
    267283
     
    285301    STDMETHOD(FindById) (INPTR GUIDPARAM aId, IUSBDevice **aDevice)
    286302    {
    287         // internal collection, no need to implement
     303        /* internal collection, no need to implement */
    288304        return E_NOTIMPL;
    289305    }
     
    291307    STDMETHOD(FindByAddress) (INPTR BSTR aAddress, IUSBDevice **aDevice)
    292308    {
    293         // internal collection, no need to implement
     309        /* internal collection, no need to implement */
    294310        return E_NOTIMPL;
    295311    }
Note: See TracChangeset for help on using the changeset viewer.

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