VirtualBox

Changeset 25194 in vbox


Ignore:
Timestamp:
Dec 4, 2009 3:59:34 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
55674
Message:

Main: stop USBController from being a VirtualBoxBaseWithChildren; make its instance data private

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

Legend:

Unmodified
Added
Removed

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

    r25184 r25194  
    82488248 *       unsaved.
    82498249 */
    8250 void Machine::copyFrom (Machine *aThat)
     8250void Machine::copyFrom(Machine *aThat)
    82518251{
    82528252    AssertReturnVoid (mType == IsMachine || mType == IsSessionMachine);
    … …  
    82708270    }
    82718271
    8272     mBIOSSettings->copyFrom (aThat->mBIOSSettings);
     8272    mBIOSSettings->copyFrom(aThat->mBIOSSettings);
    82738273#ifdef VBOX_WITH_VRDP
    8274     mVRDPServer->copyFrom (aThat->mVRDPServer);
     8274    mVRDPServer->copyFrom(aThat->mVRDPServer);
    82758275#endif
    8276     mAudioAdapter->copyFrom (aThat->mAudioAdapter);
    8277     mUSBController->copyFrom (aThat->mUSBController);
     8276    mAudioAdapter->copyFrom(aThat->mAudioAdapter);
     8277    mUSBController->copyFrom(aThat->mUSBController);
    82788278
    82798279    /* create private copies of all controllers */
    … …  
    85358535    /* create another USB controller object that will be mutable */
    85368536    unconst(mUSBController).createObject();
    8537     mUSBController->init (this, aMachine->mUSBController);
     8537    mUSBController->init(this, aMachine->mUSBController);
    85388538
    85398539    /* create a list of network adapters that will be mutable */
    8540     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
     8540    for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
    85418541    {
    85428542        unconst(mNetworkAdapters [slot]).createObject();
    8543         mNetworkAdapters [slot]->init (this, aMachine->mNetworkAdapters [slot]);
     8543        mNetworkAdapters[slot]->init (this, aMachine->mNetworkAdapters [slot]);
    85448544    }
    85458545

  • trunk/src/VBox/Main/SnapshotImpl.cpp

    r25152 r25194  
    884884
    885885    unconst(mUSBController).createObject();
    886     mUSBController->initCopy (this, mPeer->mUSBController);
    887 
    888     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
    889     {
    890         unconst(mNetworkAdapters [slot]).createObject();
    891         mNetworkAdapters [slot]->initCopy (this, mPeer->mNetworkAdapters [slot]);
    892     }
    893 
    894     for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
     886    mUSBController->init(this, mPeer->mUSBController);
     887
     888    for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot++)
     889    {
     890        unconst(mNetworkAdapters[slot]).createObject();
     891        mNetworkAdapters[slot]->initCopy (this, mPeer->mNetworkAdapters [slot]);
     892    }
     893
     894    for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot++)
    895895    {
    896896        unconst(mSerialPorts [slot]).createObject();
    897         mSerialPorts [slot]->initCopy (this, mPeer->mSerialPorts [slot]);
    898     }
    899 
    900     for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
    901     {
    902         unconst(mParallelPorts [slot]).createObject();
    903         mParallelPorts [slot]->initCopy (this, mPeer->mParallelPorts [slot]);
     897        mSerialPorts[slot]->initCopy (this, mPeer->mSerialPorts[slot]);
     898    }
     899
     900    for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot++)
     901    {
     902        unconst(mParallelPorts[slot]).createObject();
     903        mParallelPorts[slot]->initCopy (this, mPeer->mParallelPorts[slot]);
    904904    }
    905905

  • trunk/src/VBox/Main/USBControllerImpl.cpp

    r25149 r25194  
    4040
    4141#include <algorithm>
     42#include "objectslist.h"
    4243
    4344// defines
    4445/////////////////////////////////////////////////////////////////////////////
    4546
     47typedef std::list< ComObjPtr<USBDeviceFilter> > DeviceFilterList;
     48
     49struct USBController::Data
     50{
     51    struct BackupableData
     52    {
     53        /* Constructor. */
     54        BackupableData()
     55            : fEnabled(false),
     56              fEnabledEHCI(false)
     57        { }
     58
     59        bool operator==(const BackupableData &that) const
     60        {
     61            return this == &that || (fEnabled == that.fEnabled && fEnabledEHCI == that.fEnabledEHCI);
     62        }
     63
     64        bool fEnabled;
     65        bool fEnabledEHCI;
     66    };
     67
     68    /** Parent object. */
     69    const ComObjPtr<Machine, ComWeakRef> pParent;
     70    /** Peer object. */
     71    const ComObjPtr<USBController> pPeer;
     72
     73    Backupable<BackupableData>      bd;
     74#ifdef VBOX_WITH_USB
     75    // the following fields need special backup/rollback/commit handling,
     76    // so they cannot be a part of BackupableData
     77    Backupable<DeviceFilterList>    llDeviceFilters;
     78#endif
     79};
     80
     81
     82
    4683// constructor / destructor
    4784/////////////////////////////////////////////////////////////////////////////
    … …  
    68105 * @param aParent       Pointer to our parent object.
    69106 */
    70 HRESULT USBController::init (Machine *aParent)
     107HRESULT USBController::init(Machine *aParent)
    71108{
    72109    LogFlowThisFunc(("aParent=%p\n", aParent));
    … …  
    78115    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    79116
    80     unconst(mParent) = aParent;
     117    m = new Data();
     118
     119    unconst(m->pParent) = aParent;
    81120    /* mPeer is left null */
    82121
    83     mData.allocate();
    84 #ifdef VBOX_WITH_USB
    85     mDeviceFilters.allocate();
     122    m->bd.allocate();
     123#ifdef VBOX_WITH_USB
     124    m->llDeviceFilters.allocate();
    86125#endif
    87126
    … …  
    104143 * it shares data with is destroyed.
    105144 */
    106 HRESULT USBController::init (Machine *aParent, USBController *aPeer)
     145HRESULT USBController::init(Machine *aParent, USBController *aPeer)
    107146{
    108147    LogFlowThisFunc(("aParent=%p, aPeer=%p\n", aParent, aPeer));
    … …  
    114153    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    115154
    116     unconst(mParent) = aParent;
    117     unconst(mPeer) = aPeer;
    118 
    119     AutoWriteLock thatlock (aPeer);
    120     mData.share (aPeer->mData);
     155    m = new Data();
     156
     157    unconst(m->pParent) = aParent;
     158    unconst(m->pPeer) = aPeer;
     159
     160    AutoWriteLock thatlock(aPeer);
     161    m->bd.share(aPeer->m->bd);
    121162
    122163#ifdef VBOX_WITH_USB
    123164    /* create copies of all filters */
    124     mDeviceFilters.allocate();
    125     DeviceFilterList::const_iterator it = aPeer->mDeviceFilters->begin();
    126     while (it != aPeer->mDeviceFilters->end())
     165    m->llDeviceFilters.allocate();
     166    DeviceFilterList::const_iterator it = aPeer->m->llDeviceFilters->begin();
     167    while (it != aPeer->m->llDeviceFilters->end())
    127168    {
    128169        ComObjPtr<USBDeviceFilter> filter;
    129170        filter.createObject();
    130171        filter->init (this, *it);
    131         mDeviceFilters->push_back (filter);
     172        m->llDeviceFilters->push_back(filter);
    132173        ++ it;
    133174    }
    … …  
    146187 *  of the original object passed as an argument.
    147188 */
    148 HRESULT USBController::initCopy (Machine *aParent, USBController *aPeer)
     189HRESULT USBController::initCopy(Machine *aParent, USBController *aPeer)
    149190{
    150191    LogFlowThisFunc(("aParent=%p, aPeer=%p\n", aParent, aPeer));
    … …  
    156197    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    157198
    158     unconst(mParent) = aParent;
     199    m = new Data();
     200
     201    unconst(m->pParent) = aParent;
    159202    /* mPeer is left null */
    160203
    161204    AutoWriteLock thatlock (aPeer);
    162     mData.attachCopy (aPeer->mData);
     205    m->bd.attachCopy(aPeer->m->bd);
    163206
    164207#ifdef VBOX_WITH_USB
    165208    /* create private copies of all filters */
    166     mDeviceFilters.allocate();
    167     DeviceFilterList::const_iterator it = aPeer->mDeviceFilters->begin();
    168     while (it != aPeer->mDeviceFilters->end())
     209    m->llDeviceFilters.allocate();
     210    DeviceFilterList::const_iterator it = aPeer->m->llDeviceFilters->begin();
     211    while (it != aPeer->m->llDeviceFilters->end())
    169212    {
    170213        ComObjPtr<USBDeviceFilter> filter;
    171214        filter.createObject();
    172         filter->initCopy (this, *it);
    173         mDeviceFilters->push_back (filter);
     215        filter->initCopy(this, *it);
     216        m->llDeviceFilters->push_back(filter);
    174217        ++ it;
    175218    }
    … …  
    196239        return;
    197240
    198     /* uninit all filters (including those still referenced by clients) */
    199     uninitDependentChildren();
    200 
    201 #ifdef VBOX_WITH_USB
    202     mDeviceFilters.free();
     241#ifdef VBOX_WITH_USB
     242    // uninit all device filters on the list (it's a standard std::list not an ObjectsList
     243    // so we must uninit() manually)
     244    for (DeviceFilterList::iterator it = m->llDeviceFilters->begin();
     245         it != m->llDeviceFilters->end();
     246         ++it)
     247        (*it)->uninit();
     248
     249    m->llDeviceFilters.free();
    203250#endif
    204     mData.free();
    205 
    206     unconst(mPeer).setNull();
    207     unconst(mParent).setNull();
     251    m->bd.free();
     252
     253    unconst(m->pPeer).setNull();
     254    unconst(m->pParent).setNull();
     255
     256    delete m;
     257    m = NULL;
    208258}
    209259
    … …  
    221271    AutoReadLock alock(this);
    222272
    223     *aEnabled = mData->mEnabled;
     273    *aEnabled = m->bd->fEnabled;
    224274
    225275    return S_OK;
    … …  
    235285
    236286    /* the machine needs to be mutable */
    237     Machine::AutoMutableStateDependency adep(mParent);
     287    Machine::AutoMutableStateDependency adep(m->pParent);
    238288    if (FAILED(adep.rc())) return adep.rc();
    239289
    240290    AutoWriteLock alock(this);
    241291
    242     if (mData->mEnabled != aEnabled)
    243     {
    244         mData.backup();
    245         mData->mEnabled = aEnabled;
     292    if (m->bd->fEnabled != aEnabled)
     293    {
     294        m->bd.backup();
     295        m->bd->fEnabled = aEnabled;
    246296
    247297        /* leave the lock for safety */
    248298        alock.leave();
    249299
    250         mParent->onUSBControllerChange();
     300        m->pParent->onUSBControllerChange();
    251301    }
    252302
    … …  
    263313    AutoReadLock alock(this);
    264314
    265     *aEnabled = mData->mEnabledEhci;
     315    *aEnabled = m->bd->fEnabledEHCI;
    266316
    267317    return S_OK;
    … …  
    276326
    277327    /* the machine needs to be mutable */
    278     Machine::AutoMutableStateDependency adep(mParent);
     328    Machine::AutoMutableStateDependency adep(m->pParent);
    279329    if (FAILED(adep.rc())) return adep.rc();
    280330
    281331    AutoWriteLock alock(this);
    282332
    283     if (mData->mEnabledEhci != aEnabled)
    284     {
    285         mData.backup();
    286         mData->mEnabledEhci = aEnabled;
     333    if (m->bd->fEnabledEHCI != aEnabled)
     334    {
     335        m->bd.backup();
     336        m->bd->fEnabledEHCI = aEnabled;
    287337
    288338        /* leave the lock for safety */
    289339        alock.leave();
    290340
    291         mParent->onUSBControllerChange();
     341        m->pParent->onUSBControllerChange();
    292342    }
    293343
    … …  
    368418    AutoReadLock alock(this);
    369419
    370     SafeIfaceArray<IUSBDeviceFilter> collection (*mDeviceFilters.data());
     420    SafeIfaceArray<IUSBDeviceFilter> collection (*m->llDeviceFilters.data());
    371421    collection.detachTo(ComSafeArrayOutArg(aDevicesFilters));
    372422
    … …  
    396446
    397447    /* the machine needs to be mutable */
    398     Machine::AutoMutableStateDependency adep(mParent);
     448    Machine::AutoMutableStateDependency adep(m->pParent);
    399449    if (FAILED(adep.rc())) return adep.rc();
    400450
    … …  
    427477
    428478    /* the machine needs to be mutable */
    429     Machine::AutoMutableStateDependency adep(mParent);
     479    Machine::AutoMutableStateDependency adep(m->pParent);
    430480    if (FAILED(adep.rc())) return adep.rc();
    431481
    432482    AutoWriteLock alock(this);
    433483
    434     ComObjPtr<USBDeviceFilter> filter = getDependentChild (aFilter);
    435     if (!filter)
    436         return setError (E_INVALIDARG,
    437             tr ("The given USB device filter is not created within "
    438                 "this VirtualBox instance"));
     484    ComObjPtr<USBDeviceFilter> filter = static_cast<USBDeviceFilter*>(aFilter);
     485    // @todo r=dj make sure the input object is actually from us
     486//     ComObjPtr<USBDeviceFilter> filter = getDependentChild(aFilter);
     487//     if (!filter)
     488//         return setError (E_INVALIDARG,
     489//             tr ("The given USB device filter is not created within "
     490//                 "this VirtualBox instance"));
    439491
    440492    if (filter->mInList)
    … …  
    443495
    444496    /* backup the list before modification */
    445     mDeviceFilters.backup();
     497    m->llDeviceFilters.backup();
    446498
    447499    /* iterate to the position... */
    448500    DeviceFilterList::iterator it;
    449     if (aPosition < mDeviceFilters->size())
    450     {
    451         it = mDeviceFilters->begin();
     501    if (aPosition < m->llDeviceFilters->size())
     502    {
     503        it = m->llDeviceFilters->begin();
    452504        std::advance (it, aPosition);
    453505    }
    454506    else
    455         it = mDeviceFilters->end();
     507        it = m->llDeviceFilters->end();
    456508    /* ...and insert */
    457     mDeviceFilters->insert (it, filter);
     509    m->llDeviceFilters->insert (it, filter);
    458510    filter->mInList = true;
    459511
    … …  
    461513    if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
    462514    {
    463         USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     515        USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
    464516        ComAssertRet (service, E_FAIL);
    465517
    … …  
    479531}
    480532
    481 STDMETHODIMP USBController::RemoveDeviceFilter (ULONG aPosition,
    482                                                 IUSBDeviceFilter **aFilter)
     533STDMETHODIMP USBController::RemoveDeviceFilter(ULONG aPosition,
     534                                               IUSBDeviceFilter **aFilter)
    483535{
    484536#ifdef VBOX_WITH_USB
    … …  
    490542
    491543    /* the machine needs to be mutable */
    492     Machine::AutoMutableStateDependency adep(mParent);
     544    Machine::AutoMutableStateDependency adep(m->pParent);
    493545    if (FAILED(adep.rc())) return adep.rc();
    494546
    495547    AutoWriteLock alock(this);
    496548
    497     if (!mDeviceFilters->size())
     549    if (!m->llDeviceFilters->size())
    498550        return setError (E_INVALIDARG,
    499551            tr ("The USB device filter list is empty"));
    500552
    501     if (aPosition >= mDeviceFilters->size())
     553    if (aPosition >= m->llDeviceFilters->size())
    502554        return setError (E_INVALIDARG,
    503555            tr ("Invalid position: %lu (must be in range [0, %lu])"),
    504             aPosition, mDeviceFilters->size() - 1);
     556            aPosition, m->llDeviceFilters->size() - 1);
    505557
    506558    /* backup the list before modification */
    507     mDeviceFilters.backup();
     559    m->llDeviceFilters.backup();
    508560
    509561    ComObjPtr<USBDeviceFilter> filter;
    510562    {
    511563        /* iterate to the position... */
    512         DeviceFilterList::iterator it = mDeviceFilters->begin();
     564        DeviceFilterList::iterator it = m->llDeviceFilters->begin();
    513565        std::advance (it, aPosition);
    514566        /* ...get an element from there... */
    … …  
    516568        /* ...and remove */
    517569        filter->mInList = false;
    518         mDeviceFilters->erase (it);
     570        m->llDeviceFilters->erase (it);
    519571    }
    520572
    … …  
    527579    if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
    528580    {
    529         USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     581        USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
    530582        ComAssertRet (service, E_FAIL);
    531583
    … …  
    575627     * default to B. */
    576628
    577     mData->mEnabled = data.fEnabled;
    578     mData->mEnabledEhci = data.fEnabledEHCI;
     629    m->bd->fEnabled = data.fEnabled;
     630    m->bd->fEnabledEHCI = data.fEnabledEHCI;
    579631
    580632#ifdef VBOX_WITH_USB
    … …  
    590642        if (FAILED(rc)) return rc;
    591643
    592         mDeviceFilters->push_back(pFilter);
     644        m->llDeviceFilters->push_back(pFilter);
    593645        pFilter->mInList = true;
    594646    }
    … …  
    612664    AutoReadLock alock(this);
    613665
    614     data.fEnabled = !!mData->mEnabled;
    615     data.fEnabledEHCI = !!mData->mEnabledEhci;
     666    data.fEnabled = !!m->bd->fEnabled;
     667    data.fEnabledEHCI = !!m->bd->fEnabledEHCI;
    616668
    617669#ifdef VBOX_WITH_USB
    618670    data.llDeviceFilters.clear();
    619671
    620     for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    621          it != mDeviceFilters->end();
     672    for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     673         it != m->llDeviceFilters->end();
    622674         ++it)
    623675    {
    … …  
    662714    AutoReadLock alock(this);
    663715
    664     if (mData.isBackedUp()
    665 #ifdef VBOX_WITH_USB
    666         || mDeviceFilters.isBackedUp()
     716    if (m->bd.isBackedUp()
     717#ifdef VBOX_WITH_USB
     718        || m->llDeviceFilters.isBackedUp()
    667719#endif
    668720        )
    … …  
    672724    /* see whether any of filters has changed its data */
    673725    for (DeviceFilterList::const_iterator
    674          it = mDeviceFilters->begin();
    675          it != mDeviceFilters->end();
     726         it = m->llDeviceFilters->begin();
     727         it != m->llDeviceFilters->end();
    676728         ++ it)
    677729    {
    … …  
    692744    AutoReadLock alock(this);
    693745
    694     if (mData.hasActualChanges())
     746    if (m->bd.hasActualChanges())
    695747        return true;
    696748
    697749#ifdef VBOX_WITH_USB
    698     if (!mDeviceFilters.isBackedUp())
     750    if (!m->llDeviceFilters.isBackedUp())
    699751    {
    700752        /* see whether any of filters has changed its data */
    701753        for (DeviceFilterList::const_iterator
    702              it = mDeviceFilters->begin();
    703              it != mDeviceFilters->end();
     754             it = m->llDeviceFilters->begin();
     755             it != m->llDeviceFilters->end();
    704756             ++ it)
    705757        {
    … …  
    711763    }
    712764
    713     if (mDeviceFilters->size() != mDeviceFilters.backedUpData()->size())
     765    if (m->llDeviceFilters->size() != m->llDeviceFilters.backedUpData()->size())
    714766        return true;
    715767
    716     if (mDeviceFilters->size() == 0)
     768    if (m->llDeviceFilters->size() == 0)
    717769        return false;
    718770
    719771    /* Make copies to speed up comparison */
    720     DeviceFilterList devices = *mDeviceFilters.data();
    721     DeviceFilterList backDevices = *mDeviceFilters.backedUpData();
     772    DeviceFilterList devices = *m->llDeviceFilters.data();
     773    DeviceFilterList backDevices = *m->llDeviceFilters.backedUpData();
    722774
    723775    DeviceFilterList::iterator it = devices.begin();
    … …  
    756808
    757809    /* we need the machine state */
    758     Machine::AutoAnyStateDependency adep (mParent);
     810    Machine::AutoAnyStateDependency adep(m->pParent);
    759811    AssertComRCReturn (adep.rc(), false);
    760812
    … …  
    763815    bool dataChanged = false;
    764816
    765     if (mData.isBackedUp())
     817    if (m->bd.isBackedUp())
    766818    {
    767819        /* we need to check all data to see whether anything will be changed
    768820         * after rollback */
    769         dataChanged = mData.hasActualChanges();
    770         mData.rollback();
    771     }
    772 
    773 #ifdef VBOX_WITH_USB
    774 
    775     if (mDeviceFilters.isBackedUp())
    776     {
    777         USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     821        dataChanged = m->bd.hasActualChanges();
     822        m->bd.rollback();
     823    }
     824
     825#ifdef VBOX_WITH_USB
     826
     827    if (m->llDeviceFilters.isBackedUp())
     828    {
     829        USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
    778830        ComAssertRet (service, false);
    779831
    780832        /* uninitialize all new filters (absent in the backed up list) */
    781         DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    782         DeviceFilterList *backedList = mDeviceFilters.backedUpData();
    783         while (it != mDeviceFilters->end())
     833        DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     834        DeviceFilterList *backedList = m->llDeviceFilters.backedUpData();
     835        while (it != m->llDeviceFilters->end())
    784836        {
    785837            if (std::find (backedList->begin(), backedList->end(), *it) ==
    … …  
    808860            while (it != backedList->end())
    809861            {
    810                 if (std::find (mDeviceFilters->begin(), mDeviceFilters->end(), *it) ==
    811                     mDeviceFilters->end())
     862                if (std::find (m->llDeviceFilters->begin(), m->llDeviceFilters->end(), *it) ==
     863                    m->llDeviceFilters->end())
    812864                {
    813865                    /* notify the proxy (only when necessary) */
    … …  
    824876
    825877        /* restore the list */
    826         mDeviceFilters.rollback();
     878        m->llDeviceFilters.rollback();
    827879    }
    828880
    … …  
    831883
    832884    /* rollback any changes to filters after restoring the list */
    833     DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    834     while (it != mDeviceFilters->end())
     885    DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     886    while (it != m->llDeviceFilters->end())
    835887    {
    836888        if ((*it)->isModified())
    … …  
    859911
    860912    /* sanity too */
    861     AutoCaller peerCaller (mPeer);
     913    AutoCaller peerCaller(m->pPeer);
    862914    AssertComRCReturnVoid (peerCaller.rc());
    863915
    864916    /* lock both for writing since we modify both (mPeer is "master" so locked
    865917     * first) */
    866     AutoMultiWriteLock2 alock (mPeer, this);
    867 
    868     if (mData.isBackedUp())
    869     {
    870         mData.commit();
    871         if (mPeer)
     918    AutoMultiWriteLock2 alock (m->pPeer, this);
     919
     920    if (m->bd.isBackedUp())
     921    {
     922        m->bd.commit();
     923        if (m->pPeer)
    872924        {
    873925            /* attach new data to the peer and reshare it */
    874             AutoWriteLock peerlock (mPeer);
    875             mPeer->mData.attach (mData);
     926            AutoWriteLock peerlock(m->pPeer);
     927            m->pPeer->m->bd.attach(m->bd);
    876928        }
    877929    }
    … …  
    880932    bool commitFilters = false;
    881933
    882     if (mDeviceFilters.isBackedUp())
    883     {
    884         mDeviceFilters.commit();
     934    if (m->llDeviceFilters.isBackedUp())
     935    {
     936        m->llDeviceFilters.commit();
    885937
    886938        /* apply changes to peer */
    887         if (mPeer)
     939        if (m->pPeer)
    888940        {
    889             AutoWriteLock peerlock (mPeer);
     941            AutoWriteLock peerlock(m->pPeer);
    890942
    891943            /* commit all changes to new filters (this will reshare data with
    892944             * peers for those who have peers) */
    893945            DeviceFilterList *newList = new DeviceFilterList();
    894             DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    895             while (it != mDeviceFilters->end())
     946            DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     947            while (it != m->llDeviceFilters->end())
    896948            {
    897949                (*it)->commit();
    … …  
    904956                     * create a peer owning data this filter share it with */
    905957                    peer.createObject();
    906                     peer->init (mPeer, *it, true /* aReshare */);
     958                    peer->init(m->pPeer, *it, true /* aReshare */);
    907959                }
    908960                else
    909961                {
    910962                    /* remove peer from the old list */
    911                     mPeer->mDeviceFilters->remove (peer);
     963                    m->pPeer->m->llDeviceFilters->remove(peer);
    912964                }
    913965                /* and add it to the new list */
    … …  
    918970
    919971            /* uninit old peer's filters that are left */
    920             it = mPeer->mDeviceFilters->begin();
    921             while (it != mPeer->mDeviceFilters->end())
     972            it = m->pPeer->m->llDeviceFilters->begin();
     973            while (it != m->pPeer->m->llDeviceFilters->end())
    922974            {
    923975                (*it)->uninit();
    … …  
    926978
    927979            /* attach new list of filters to our peer */
    928             mPeer->mDeviceFilters.attach (newList);
     980            m->pPeer->m->llDeviceFilters.attach(newList);
    929981        }
    930982        else
    … …  
    944996    if (commitFilters)
    945997    {
    946         DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    947         while (it != mDeviceFilters->end())
     998        DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     999        while (it != m->llDeviceFilters->end())
    9481000        {
    9491001            (*it)->commit();
    … …  
    9711023
    9721024    /* even more sanity */
    973     Machine::AutoAnyStateDependency adep (mParent);
     1025    Machine::AutoAnyStateDependency adep(m->pParent);
    9741026    AssertComRCReturnVoid (adep.rc());
    9751027    /* Machine::copyFrom() may not be called when the VM is running */
    … …  
    9811033
    9821034    /* this will back up current data */
    983     mData.assignCopy (aThat->mData);
     1035    m->bd.assignCopy(aThat->m->bd);
    9841036
    9851037#ifdef VBOX_WITH_USB
    … …  
    9891041
    9901042    /* create private copies of all filters */
    991     mDeviceFilters.backup();
    992     mDeviceFilters->clear();
    993     for (DeviceFilterList::const_iterator it = aThat->mDeviceFilters->begin();
    994         it != aThat->mDeviceFilters->end();
     1043    m->llDeviceFilters.backup();
     1044    m->llDeviceFilters->clear();
     1045    for (DeviceFilterList::const_iterator it = aThat->m->llDeviceFilters->begin();
     1046        it != aThat->m->llDeviceFilters->end();
    9951047        ++ it)
    9961048    {
    … …  
    9981050        filter.createObject();
    9991051        filter->initCopy (this, *it);
    1000         mDeviceFilters->push_back (filter);
     1052        m->llDeviceFilters->push_back (filter);
    10011053    }
    10021054
    … …  
    10181070
    10191071    /* we need the machine state */
    1020     Machine::AutoAnyStateDependency adep (mParent);
     1072    Machine::AutoAnyStateDependency adep(m->pParent);
    10211073    AssertComRCReturnRC(adep.rc());
    10221074
    … …  
    10271079    /* we don't modify our data fields -- no need to lock */
    10281080
    1029     if (aFilter->mInList && mParent->isRegistered())
    1030     {
    1031         USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     1081    if (aFilter->mInList && m->pParent->isRegistered())
     1082    {
     1083        USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
    10321084        ComAssertRet (service, E_FAIL);
    10331085
    … …  
    10781130
    10791131    /* Disabled USB controllers cannot actually work with USB devices */
    1080     if (!mData->mEnabled)
     1132    if (!m->bd->fEnabled)
    10811133        return false;
    10821134
    10831135    /* apply self filters */
    1084     for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    1085          it != mDeviceFilters->end();
     1136    for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     1137         it != m->llDeviceFilters->end();
    10861138         ++ it)
    10871139    {
    … …  
    11191171
    11201172    /* Disabled USB controllers cannot actually work with USB devices */
    1121     if (!mData->mEnabled)
     1173    if (!m->bd->fEnabled)
    11221174        return false;
    11231175
    … …  
    11791231
    11801232    /* apply self filters */
    1181     for (DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    1182          it != mDeviceFilters->end();
     1233    for (DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     1234         it != m->llDeviceFilters->end();
    11831235         ++ it)
    11841236    {
    … …  
    12211273    AutoReadLock alock(this);
    12221274
    1223     USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     1275    USBProxyService *service = m->pParent->getVirtualBox()->host()->usbProxyService();
    12241276    AssertReturn(service, E_FAIL);
    12251277
    1226     DeviceFilterList::const_iterator it = mDeviceFilters->begin();
    1227     while (it != mDeviceFilters->end())
     1278    DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
     1279    while (it != m->llDeviceFilters->end())
    12281280    {
    12291281        USBDeviceFilter *flt = *it; /* resolve ambiguity (for ComPtr below) */
    … …  
    12551307}
    12561308
     1309Machine* USBController::getMachine()
     1310{
     1311    return m->pParent;
     1312}
     1313
    12571314#endif /* VBOX_WITH_USB */
    12581315

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

    r25184 r25194  
    139139////////////////////////////////////////////////////////////////////////////////
    140140//
    141 // VirtualBox data definition
     141// VirtualBox private member data definition
    142142//
    143143////////////////////////////////////////////////////////////////////////////////

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

    r24989 r25194  
    4848
    4949class ATL_NO_VTABLE USBController :
    50     public VirtualBoxBaseWithChildrenNEXT,
     50    public VirtualBoxBase,
    5151    public VirtualBoxSupportErrorInfoImpl<USBController, IUSBController>,
    5252    public VirtualBoxSupportTranslation<USBController>,
    5353    VBOX_SCRIPTABLE_IMPL(IUSBController)
    5454{
    55 private:
    56 
    57     struct Data
    58     {
    59         /* Constructor. */
    60         Data() : mEnabled (FALSE), mEnabledEhci (FALSE) { }
    61 
    62         bool operator== (const Data &that) const
    63         {
    64             return this == &that || (mEnabled == that.mEnabled && mEnabledEhci == that.mEnabledEhci);
    65         }
    66 
    67         /** Enabled indicator. */
    68         BOOL mEnabled;
    69 
    70         /** Enabled indicator for EHCI. */
    71         BOOL mEnabledEhci;
    72     };
    73 
    7455public:
    75 
    7656    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (USBController)
    7757
    … …  
    133113    // public methods for internal purposes only
    134114    // (ensure there is a caller and a read lock before calling them!)
    135 
    136     /** @note this doesn't require a read lock since mParent is constant. */
    137     const ComObjPtr<Machine, ComWeakRef> &parent() { return mParent; };
    138 
    139     const Backupable<Data>& getData() { return mData; }
     115    Machine* getMachine();
    140116
    141117    // for VirtualBoxSupportErrorInfoImpl
    … …  
    144120private:
    145121
    146 #ifdef VBOX_WITH_USB
    147     /** specialization for IUSBDeviceFilter */
    148     ComObjPtr<USBDeviceFilter> getDependentChild (IUSBDeviceFilter *aFilter)
    149     {
    150         VirtualBoxBase *child = VirtualBoxBaseWithChildrenNEXT::
    151                                 getDependentChild (ComPtr<IUnknown> (aFilter));
    152         return child ? static_cast <USBDeviceFilter *> (child)
    153                      : NULL;
    154     }
    155 #endif /* VBOX_WITH_USB */
    156 
    157122    void printList();
    158123
    159     /** Parent object. */
    160     const ComObjPtr<Machine, ComWeakRef> mParent;
    161     /** Peer object. */
    162     const ComObjPtr<USBController> mPeer;
    163     /** Data. */
    164     Backupable<Data> mData;
    165 
    166 #ifdef VBOX_WITH_USB
    167     // the following fields need special backup/rollback/commit handling,
    168     // so they cannot be a part of Data
    169 
    170     typedef std::list <ComObjPtr<USBDeviceFilter> > DeviceFilterList;
    171     Backupable <DeviceFilterList> mDeviceFilters;
    172 #endif /* VBOX_WITH_USB */
     124    struct Data;
     125    Data *m;
    173126};
    174127

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

    r25184 r25194  
    6767    }
    6868
     69private:
     70    // prohibit copying and assignment
     71    ObjectsList(const ObjectsList &d);
     72    ObjectsList& operator=(const ObjectsList &d);
     73
     74public:
     75
    6976    /**
    7077     * Returns the lock handle which protects this list, for use with
    … …  
    113120            m_ll.push_back(*it);
    114121        }
    115     }
    116 
    117     /**
    118      * Returns the no. of objects on the list (std::list compatibility)
    119      * with locking.
    120      */
    121     size_t size()
    122     {
    123         AutoReadLock al(m_lock);
    124         return m_ll.size();
    125     }
    126 
    127     /**
    128      * Returns the first object on the list (std::list compatibility)
    129      * with locking.
    130      */
    131     MyType front()
    132     {
    133         AutoReadLock al(m_lock);
    134         return m_ll.front();
    135     }
    136 
    137     /**
    138      * Returns a raw pointer to the member list of objects.
    139      * Does not lock!
    140      * @return
    141      */
    142     MyList& getList()
    143     {
    144         return m_ll;
    145     }
    146 
    147     /**
    148      * Returns the begin iterator from the list (std::list compatibility).
    149      * Does not lock!
    150      * @return
    151      */
    152     iterator begin()
    153     {
    154         return m_ll.begin();
    155     }
    156 
    157     /**
    158      * Returns the end iterator from the list (std::list compatibility).
    159      * Does not lock!
    160      */
    161     iterator end()
    162     {
    163         return m_ll.end();
    164122    }
    165123
    … …  
    181139    }
    182140
     141    /**
     142     * Returns the no. of objects on the list (std::list compatibility)
     143     * with locking.
     144     */
     145    size_t size()
     146    {
     147        AutoReadLock al(m_lock);
     148        return m_ll.size();
     149    }
     150
     151    /**
     152     * Returns a raw pointer to the member list of objects.
     153     * Does not lock!
     154     * @return
     155     */
     156    MyList& getList()
     157    {
     158        return m_ll;
     159    }
     160
     161    /**
     162     * Returns the first object on the list (std::list compatibility)
     163     * with locking.
     164     */
     165    MyType front()
     166    {
     167        AutoReadLock al(m_lock);
     168        return m_ll.front();
     169    }
     170
     171    /**
     172     * Returns the begin iterator from the list (std::list compatibility).
     173     * Does not lock!
     174     * @return
     175     */
     176    iterator begin()
     177    {
     178        return m_ll.begin();
     179    }
     180
     181    /**
     182     * Returns the end iterator from the list (std::list compatibility).
     183     * Does not lock!
     184     */
     185    iterator end()
     186    {
     187        return m_ll.end();
     188    }
     189
     190    void insert(iterator it, MyType &p)
     191    {
     192        m_ll.insert(it, p);
     193    }
     194
     195    void erase(iterator it)
     196    {
     197        m_ll.erase(it);
     198    }
     199
    183200private:
    184201    MyList          m_ll;
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