VirtualBox

Changeset 49874 in vbox for trunk


Ignore:
Timestamp:
Dec 11, 2013 12:28:07 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
91238
Message:

Main: fix Windows host warnings, hide internal data.

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

Legend:

Unmodified
Added
Removed

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

    r49871 r49874  
    6565    const ComObjPtr<AudioAdapter> mPeer;
    6666    struct Data;
    67     Backupable<Data>    mData;
     67    Data *mData;
    6868};
    6969

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

    r49871 r49874  
    101101    HRESULT removeRedirect(const com::Utf8Str &aName);
    102102
    103     struct  Data;
    104     Backupable<Data> mData;
     103    struct Data;
     104    Data *mData;
    105105    bool m_fModified;
    106106    const ComObjPtr<NATEngine> mPeer;

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

    r49871 r49874  
    2727#include "Logging.h"
    2828
     29struct AudioAdapterData
     30{
     31    AudioAdapterData() :
     32        mEnabled(false),
     33        mAudioController(AudioControllerType_AC97),
     34        mAudioDriver(AudioDriverType_Null)
     35    {}
     36
     37    BOOL mEnabled;
     38    AudioDriverType_T mAudioDriver;
     39    AudioControllerType_T mAudioController;
     40};
     41
    2942struct AudioAdapter::Data
    3043{
    31     Data();
    32         BOOL mEnabled;
    33         AudioDriverType_T mAudioDriver;
    34         AudioControllerType_T mAudioController;
     44    Backupable<AudioAdapterData> m;
    3545};
    3646
    … …  
    3949
    4050AudioAdapter::AudioAdapter()
    41     : mParent(NULL)
     51    : mParent(NULL),
     52      mData(NULL)
    4253{
    4354}
    … …  
    90101    /* mPeer is left null */
    91102
    92     mData.allocate();
    93     mData->mAudioDriver = defaultAudioDriver;
     103    mData = new Data();
     104    mData->m.allocate();
     105    mData->m->mAudioDriver = defaultAudioDriver;
    94106
    95107    /* Confirm a successful initialization */
    … …  
    126138
    127139    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
    128     mData.share (aThat->mData);
     140    mData = new Data();
     141    mData->m.share (aThat->mData->m);
    129142
    130143    /* Confirm a successful initialization */
    … …  
    158171
    159172    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
    160     mData.attachCopy (aThat->mData);
     173    mData = new Data();
     174    mData->m.attachCopy (aThat->mData->m);
    161175
    162176    /* Confirm a successful initialization */
    … …  
    179193        return;
    180194
    181     mData.free();
     195    mData->m.free();
     196    delete mData;
     197    mData = NULL;
    182198
    183199    unconst(mPeer) = NULL;
    … …  
    192208    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    193209
    194     *aEnabled = mData->mEnabled;
     210    *aEnabled = mData->m->mEnabled;
    195211
    196212    return S_OK;
    … …  
    205221    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    206222
    207     if (mData->mEnabled != aEnabled)
     223    if (mData->m->mEnabled != aEnabled)
    208224    {
    209         mData.backup();
    210         mData->mEnabled = aEnabled;
     225        mData->m.backup();
     226        mData->m->mEnabled = aEnabled;
    211227
    212228        alock.release();
    … …  
    222238    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    223239
    224     *aAudioDriver = mData->mAudioDriver;
     240    *aAudioDriver = mData->m->mAudioDriver;
    225241
    226242    return S_OK;
    … …  
    238254    HRESULT rc = S_OK;
    239255
    240     if (mData->mAudioDriver != aAudioDriver)
     256    if (mData->m->mAudioDriver != aAudioDriver)
    241257    {
    242258        if (settings::MachineConfigFile::isAudioDriverAllowedOnThisHost(aAudioDriver))
    243259        {
    244             mData.backup();
    245             mData->mAudioDriver = aAudioDriver;
     260            mData->m.backup();
     261            mData->m->mAudioDriver = aAudioDriver;
    246262            alock.release();
    247263            AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
    … …  
    262278    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    263279
    264     *aAudioController = mData->mAudioController;
     280    *aAudioController = mData->m->mAudioController;
    265281
    266282    return S_OK;
    … …  
    277293    HRESULT rc = S_OK;
    278294
    279     if (mData->mAudioController != aAudioController)
     295    if (mData->m->mAudioController != aAudioController)
    280296    {
    281297        /*
    … …  
    288304            case AudioControllerType_HDA:
    289305            {
    290                 mData.backup();
    291                 mData->mAudioController = aAudioController;
     306                mData->m.backup();
     307                mData->m->mAudioController = aAudioController;
    292308                alock.release();
    293309                AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
    … …  
    311327// public methods only for internal purposes
    312328/////////////////////////////////////////////////////////////////////////////
    313 
    314 AudioAdapter::Data::Data()
    315 {
    316     /* Generic defaults */
    317     mEnabled = false;
    318     mAudioController = AudioControllerType_AC97;
    319     /* Driver defaults to the null audio driver */
    320     mAudioDriver = AudioDriverType_Null;
    321 }
    322329
    323330/**
    … …  
    347354     * default to B. */
    348355
    349     mData->mEnabled = data.fEnabled;
    350     mData->mAudioController = data.controllerType;
    351     mData->mAudioDriver = data.driverType;
     356    mData->m->mEnabled = data.fEnabled;
     357    mData->m->mAudioController = data.controllerType;
     358    mData->m->mAudioDriver = data.driverType;
    352359
    353360    return S_OK;
    … …  
    368375    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    369376
    370     data.fEnabled = !!mData->mEnabled;
    371     data.controllerType = mData->mAudioController;
    372     data.driverType = mData->mAudioDriver;
     377    data.fEnabled = !!mData->m->mEnabled;
     378    data.controllerType = mData->m->mAudioController;
     379    data.driverType = mData->m->mAudioDriver;
    373380    return S_OK;
    374381}
    … …  
    385392    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    386393
    387     mData.rollback();
     394    mData->m.rollback();
    388395}
    389396
    … …  
    406413    AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
    407414
    408     if (mData.isBackedUp())
     415    if (mData->m.isBackedUp())
    409416    {
    410         mData.commit();
     417        mData->m.commit();
    411418        if (mPeer)
    412419        {
    413420            /* attach new data to the peer and reshare it */
    414             mPeer->mData.attach (mData);
     421            mPeer->mData->m.attach (mData->m);
    415422        }
    416423    }
    … …  
    439446
    440447    /* this will back up current data */
    441     mData.assignCopy(aThat->mData);
     448    mData->m.assignCopy(aThat->mData->m);
    442449}
    443450/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

    r49871 r49874  
    2929#include <VBox/com/array.h>
    3030
    31 struct NATEngine::Data
    32 {
    33     Data() : mMtu(0),
     31struct NATEngineData
     32{
     33    NATEngineData() : mMtu(0),
    3434             mSockRcv(0),
    3535             mSockSnd(0),
    … …  
    6161};
    6262
     63struct NATEngine::Data
     64{
     65    Backupable<NATEngineData> m;
     66};
    6367
    6468
    … …  
    6670////////////////////////////////////////////////////////////////////////////////
    6771
    68 NATEngine::NATEngine():mParent(NULL), mAdapter(NULL){}
     72NATEngine::NATEngine():mParent(NULL), mAdapter(NULL), mData(NULL) {}
    6973NATEngine::~NATEngine(){}
    7074
    … …  
    8791    autoInitSpan.setSucceeded();
    8892    m_fModified = false;
    89     mData.allocate();
    90     mData->mNetwork.setNull();
    91     mData->mBindIP.setNull();
     93    mData = new Data();
     94    mData->m.allocate();
     95    mData->m->mNetwork.setNull();
     96    mData->m->mBindIP.setNull();
    9297    unconst(mParent) = aParent;
    9398    unconst(mAdapter) = aAdapter;
    … …  
    106111    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
    107112
    108     mData.share(aThat->mData);
     113    mData = new Data();
     114    mData->m.share(aThat->mData->m);
    109115    NATRuleMap::iterator it;
    110116    mNATRules.clear();
    … …  
    132138    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
    133139
    134     mData.attachCopy(aThat->mData);
     140    mData = new Data();
     141    mData->m.attachCopy(aThat->mData->m);
    135142    NATRuleMap::iterator it;
    136143    mNATRules.clear();
    … …  
    153160
    154161    mNATRules.clear();
    155     mData.free();
     162    mData->m.free();
     163    delete mData;
     164    mData = NULL;
    156165    unconst(mPeer) = NULL;
    157166    unconst(mParent) = NULL;
    … …  
    177186        /* we need to check all data to see whether anything will be changed
    178187         * after rollback */
    179         mData.rollback();
     188        mData->m.rollback();
    180189    }
    181190    m_fModified = false;
    … …  
    197206    if (m_fModified)
    198207    {
    199         mData.commit();
     208        mData->m.commit();
    200209        if (mPeer)
    201210        {
    202             mPeer->mData.attach(mData);
     211            mPeer->mData->m.attach(mData->m);
    203212            mPeer->mNATRules.clear();
    204213            NATRuleMap::iterator it;
    … …  
    216225    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    217226    if (aMtu)
    218         *aMtu = mData->mMtu;
     227        *aMtu = mData->m->mMtu;
    219228    if (aSockSnd)
    220         *aSockSnd = mData->mSockSnd;
     229        *aSockSnd = mData->m->mSockSnd;
    221230    if (aSockRcv)
    222         *aSockRcv = mData->mSockRcv;
     231        *aSockRcv = mData->m->mSockRcv;
    223232    if (aTcpWndSnd)
    224         *aTcpWndSnd = mData->mTcpSnd;
     233        *aTcpWndSnd = mData->m->mTcpSnd;
    225234    if (aTcpWndRcv)
    226         *aTcpWndRcv = mData->mTcpRcv;
     235        *aTcpWndRcv = mData->m->mTcpRcv;
    227236
    228237    return S_OK;
    … …  
    235244        || aTcpWndSnd || aTcpWndRcv)
    236245    {
    237         mData.backup();
     246        mData->m.backup();
    238247        m_fModified = true;
    239248    }
    240249    if (aMtu)
    241         mData->mMtu = aMtu;
     250        mData->m->mMtu = aMtu;
    242251    if (aSockSnd)
    243         mData->mSockSnd = aSockSnd;
     252        mData->m->mSockSnd = aSockSnd;
    244253    if (aSockRcv)
    245         mData->mSockRcv = aSockSnd;
     254        mData->m->mSockRcv = aSockSnd;
    246255    if (aTcpWndSnd)
    247         mData->mTcpSnd = aTcpWndSnd;
     256        mData->m->mTcpSnd = aTcpWndSnd;
    248257    if (aTcpWndRcv)
    249         mData->mTcpRcv = aTcpWndRcv;
     258        mData->m->mTcpRcv = aTcpWndRcv;
    250259
    251260    if (m_fModified)
    … …  
    334343    if (it == mNATRules.end())
    335344        return E_INVALIDARG;
    336     mData.backup();
     345    mData->m.backup();
    337346    settings::NATRule r = it->second;
    338347    Utf8Str strHostIP = r.strHostIP;
    … …  
    347356    mParent->setModified(Machine::IsModified_NetworkAdapters);
    348357    m_fModified = true;
    349     mData.commit();
     358    mData->m.commit();
    350359    alock.release();
    351360    mParent->onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
    … …  
    360369    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    361370    HRESULT rc = S_OK;
    362     mData->mNetwork = data.strNetwork;
    363     mData->mBindIP = data.strBindIP;
    364     mData->mMtu = data.u32Mtu;
    365     mData->mSockSnd = data.u32SockSnd;
    366     mData->mTcpRcv = data.u32TcpRcv;
    367     mData->mTcpSnd = data.u32TcpSnd;
     371    mData->m->mNetwork = data.strNetwork;
     372    mData->m->mBindIP = data.strBindIP;
     373    mData->m->mMtu = data.u32Mtu;
     374    mData->m->mSockSnd = data.u32SockSnd;
     375    mData->m->mTcpRcv = data.u32TcpRcv;
     376    mData->m->mTcpSnd = data.u32TcpSnd;
    368377    /* TFTP */
    369     mData->mTFTPPrefix = data.strTFTPPrefix;
    370     mData->mTFTPBootFile = data.strTFTPBootFile;
    371     mData->mTFTPNextServer = data.strTFTPNextServer;
     378    mData->m->mTFTPPrefix = data.strTFTPPrefix;
     379    mData->m->mTFTPBootFile = data.strTFTPBootFile;
     380    mData->m->mTFTPNextServer = data.strTFTPNextServer;
    372381    /* DNS */
    373     mData->mDNSPassDomain = data.fDNSPassDomain;
    374     mData->mDNSProxy = data.fDNSProxy;
    375     mData->mDNSUseHostResolver = data.fDNSUseHostResolver;
     382    mData->m->mDNSPassDomain = data.fDNSPassDomain;
     383    mData->m->mDNSProxy = data.fDNSProxy;
     384    mData->m->mDNSUseHostResolver = data.fDNSUseHostResolver;
    376385    /* Alias */
    377     mData->mAliasMode  = (data.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
    378     mData->mAliasMode |= (data.fAliasLog          ? NATAliasMode_AliasLog          : 0);
    379     mData->mAliasMode |= (data.fAliasProxyOnly    ? NATAliasMode_AliasProxyOnly    : 0);
     386    mData->m->mAliasMode  = (data.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
     387    mData->m->mAliasMode |= (data.fAliasLog          ? NATAliasMode_AliasLog          : 0);
     388    mData->m->mAliasMode |= (data.fAliasProxyOnly    ? NATAliasMode_AliasProxyOnly    : 0);
    380389    /* port forwarding */
    381390    mNATRules.clear();
    … …  
    397406    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    398407    HRESULT rc = S_OK;
    399     data.strNetwork = mData->mNetwork;
    400     data.strBindIP = mData->mBindIP;
    401     data.u32Mtu = mData->mMtu;
    402     data.u32SockRcv = mData->mSockRcv;
    403     data.u32SockSnd = mData->mSockSnd;
    404     data.u32TcpRcv = mData->mTcpRcv;
    405     data.u32TcpSnd = mData->mTcpSnd;
     408    data.strNetwork = mData->m->mNetwork;
     409    data.strBindIP = mData->m->mBindIP;
     410    data.u32Mtu = mData->m->mMtu;
     411    data.u32SockRcv = mData->m->mSockRcv;
     412    data.u32SockSnd = mData->m->mSockSnd;
     413    data.u32TcpRcv = mData->m->mTcpRcv;
     414    data.u32TcpSnd = mData->m->mTcpSnd;
    406415    /* TFTP */
    407     data.strTFTPPrefix = mData->mTFTPPrefix;
    408     data.strTFTPBootFile = mData->mTFTPBootFile;
    409     data.strTFTPNextServer = mData->mTFTPNextServer;
     416    data.strTFTPPrefix = mData->m->mTFTPPrefix;
     417    data.strTFTPBootFile = mData->m->mTFTPBootFile;
     418    data.strTFTPNextServer = mData->m->mTFTPNextServer;
    410419    /* DNS */
    411     data.fDNSPassDomain = !!mData->mDNSPassDomain;
    412     data.fDNSProxy = !!mData->mDNSProxy;
    413     data.fDNSUseHostResolver = !!mData->mDNSUseHostResolver;
     420    data.fDNSPassDomain = !!mData->m->mDNSPassDomain;
     421    data.fDNSProxy = !!mData->m->mDNSProxy;
     422    data.fDNSUseHostResolver = !!mData->m->mDNSUseHostResolver;
    414423    /* Alias */
    415     data.fAliasLog = !!(mData->mAliasMode & NATAliasMode_AliasLog);
    416     data.fAliasProxyOnly = !!(mData->mAliasMode & NATAliasMode_AliasProxyOnly);
    417     data.fAliasUseSamePorts = !!(mData->mAliasMode & NATAliasMode_AliasUseSamePorts);
     424    data.fAliasLog = !!(mData->m->mAliasMode & NATAliasMode_AliasLog);
     425    data.fAliasProxyOnly = !!(mData->m->mAliasMode & NATAliasMode_AliasProxyOnly);
     426    data.fAliasUseSamePorts = !!(mData->m->mAliasMode & NATAliasMode_AliasUseSamePorts);
    418427
    419428    for (NATRuleMap::iterator it = mNATRules.begin();
    … …  
    427436{
    428437    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    429     if (Bstr(mData->mNetwork) != aNetwork)
    430     {
    431         mData.backup();
    432         mData->mNetwork = aNetwork;
     438    if (Bstr(mData->m->mNetwork) != aNetwork)
     439    {
     440        mData->m.backup();
     441        mData->m->mNetwork = aNetwork;
    433442        mParent->setModified(Machine::IsModified_NetworkAdapters);
    434443        m_fModified = true;
    … …  
    441450{
    442451    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    443     if (!mData->mNetwork.isEmpty())
    444     {
    445         aNetwork = mData->mNetwork;
    446         Log(("Getter (this:%p) Network: %s\n", this, mData->mNetwork.c_str()));
     452    if (!mData->m->mNetwork.isEmpty())
     453    {
     454        aNetwork = mData->m->mNetwork;
     455        Log(("Getter (this:%p) Network: %s\n", this, mData->m->mNetwork.c_str()));
    447456    }
    448457    return S_OK;
    … …  
    452461{
    453462    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    454     if (Bstr(mData->mBindIP) != aHostIP)
    455     {
    456         mData.backup();
    457         mData->mBindIP = aHostIP;
     463    if (Bstr(mData->m->mBindIP) != aHostIP)
     464    {
     465        mData->m.backup();
     466        mData->m->mBindIP = aHostIP;
    458467        mParent->setModified(Machine::IsModified_NetworkAdapters);
    459468        m_fModified = true;
    … …  
    466475    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    467476
    468     if (!mData->mBindIP.isEmpty())
    469         aBindIP = mData->mBindIP;
     477    if (!mData->m->mBindIP.isEmpty())
     478        aBindIP = mData->m->mBindIP;
    470479    return S_OK;
    471480}
    … …  
    474483{
    475484    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    476     if (Bstr(mData->mTFTPPrefix) != aTFTPPrefix)
    477     {
    478         mData.backup();
    479         mData->mTFTPPrefix = aTFTPPrefix;
     485    if (Bstr(mData->m->mTFTPPrefix) != aTFTPPrefix)
     486    {
     487        mData->m.backup();
     488        mData->m->mTFTPPrefix = aTFTPPrefix;
    480489        mParent->setModified(Machine::IsModified_NetworkAdapters);
    481490        m_fModified = true;
    … …  
    489498    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    490499
    491     if (!mData->mTFTPPrefix.isEmpty())
    492     {
    493         aTFTPPrefix = mData->mTFTPPrefix;
    494         Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->mTFTPPrefix.c_str()));
     500    if (!mData->m->mTFTPPrefix.isEmpty())
     501    {
     502        aTFTPPrefix = mData->m->mTFTPPrefix;
     503        Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->m->mTFTPPrefix.c_str()));
    495504    }
    496505    return S_OK;
    … …  
    500509{
    501510    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    502     if (Bstr(mData->mTFTPBootFile) != aTFTPBootFile)
    503     {
    504         mData.backup();
    505         mData->mTFTPBootFile = aTFTPBootFile;
     511    if (Bstr(mData->m->mTFTPBootFile) != aTFTPBootFile)
     512    {
     513        mData->m.backup();
     514        mData->m->mTFTPBootFile = aTFTPBootFile;
    506515        mParent->setModified(Machine::IsModified_NetworkAdapters);
    507516        m_fModified = true;
    … …  
    514523{
    515524    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    516     if (!mData->mTFTPBootFile.isEmpty())
    517     {
    518         aTFTPBootFile = mData->mTFTPBootFile;
    519         Log(("Getter (this:%p) BootFile: %s\n", this, mData->mTFTPBootFile.c_str()));
     525    if (!mData->m->mTFTPBootFile.isEmpty())
     526    {
     527        aTFTPBootFile = mData->m->mTFTPBootFile;
     528        Log(("Getter (this:%p) BootFile: %s\n", this, mData->m->mTFTPBootFile.c_str()));
    520529    }
    521530    return S_OK;
    … …  
    526535{
    527536    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    528     if (Bstr(mData->mTFTPNextServer) != aTFTPNextServer)
    529     {
    530         mData.backup();
    531         mData->mTFTPNextServer = aTFTPNextServer;
     537    if (Bstr(mData->m->mTFTPNextServer) != aTFTPNextServer)
     538    {
     539        mData->m.backup();
     540        mData->m->mTFTPNextServer = aTFTPNextServer;
    532541        mParent->setModified(Machine::IsModified_NetworkAdapters);
    533542        m_fModified = true;
    … …  
    539548{
    540549    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    541     if (!mData->mTFTPNextServer.isEmpty())
    542     {
    543         aTFTPNextServer =  mData->mTFTPNextServer;
    544         Log(("Getter (this:%p) NextServer: %s\n", this, mData->mTFTPNextServer.c_str()));
     550    if (!mData->m->mTFTPNextServer.isEmpty())
     551    {
     552        aTFTPNextServer =  mData->m->mTFTPNextServer;
     553        Log(("Getter (this:%p) NextServer: %s\n", this, mData->m->mTFTPNextServer.c_str()));
    545554    }
    546555    return S_OK;
    … …  
    552561    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    553562
    554     if (mData->mDNSPassDomain != aDNSPassDomain)
    555     {
    556         mData.backup();
    557         mData->mDNSPassDomain = aDNSPassDomain;
     563    if (mData->m->mDNSPassDomain != aDNSPassDomain)
     564    {
     565        mData->m.backup();
     566        mData->m->mDNSPassDomain = aDNSPassDomain;
    558567        mParent->setModified(Machine::IsModified_NetworkAdapters);
    559568        m_fModified = true;
    … …  
    565574{
    566575    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    567     *aDNSPassDomain = mData->mDNSPassDomain;
     576    *aDNSPassDomain = mData->m->mDNSPassDomain;
    568577    return S_OK;
    569578}
    … …  
    574583    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    575584
    576     if (mData->mDNSProxy != aDNSProxy)
    577     {
    578         mData.backup();
    579         mData->mDNSProxy = aDNSProxy;
     585    if (mData->m->mDNSProxy != aDNSProxy)
     586    {
     587        mData->m.backup();
     588        mData->m->mDNSProxy = aDNSProxy;
    580589        mParent->setModified(Machine::IsModified_NetworkAdapters);
    581590        m_fModified = true;
    … …  
    587596{
    588597    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    589     *aDNSProxy = mData->mDNSProxy;
     598    *aDNSProxy = mData->m->mDNSProxy;
    590599    return S_OK;
    591600}
    … …  
    595604{
    596605    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    597     *aDNSUseHostResolver = mData->mDNSUseHostResolver;
     606    *aDNSUseHostResolver = mData->m->mDNSUseHostResolver;
    598607    return S_OK;
    599608}
    … …  
    602611HRESULT NATEngine::setDNSUseHostResolver(BOOL aDNSUseHostResolver)
    603612{
    604     if (mData->mDNSUseHostResolver != aDNSUseHostResolver)
    605     {
    606         mData.backup();
    607         mData->mDNSUseHostResolver = aDNSUseHostResolver;
     613    if (mData->m->mDNSUseHostResolver != aDNSUseHostResolver)
     614    {
     615        mData->m.backup();
     616        mData->m->mDNSUseHostResolver = aDNSUseHostResolver;
    608617        mParent->setModified(Machine::IsModified_NetworkAdapters);
    609618        m_fModified = true;
    … …  
    616625    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    617626
    618     if (mData->mAliasMode != aAliasMode)
    619     {
    620         mData.backup();
    621         mData->mAliasMode = aAliasMode;
     627    if (mData->m->mAliasMode != aAliasMode)
     628    {
     629        mData->m.backup();
     630        mData->m->mAliasMode = aAliasMode;
    622631        mParent->setModified(Machine::IsModified_NetworkAdapters);
    623632        m_fModified = true;
    … …  
    629638{
    630639    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    631     *aAliasMode = mData->mAliasMode;
    632     return S_OK;
    633 }
    634 
     640    *aAliasMode = mData->m->mAliasMode;
     641    return S_OK;
     642}
     643
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