Changeset 49871 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Dec 10, 2013 4:49:59 PM (11 years ago)

Author:

vboxsync

Message:

6813 - User server side API wrapper code in all interfaces.. stage 4 rev 1

Location:

trunk/src/VBox/Main/src-server

Files:

• AudioAdapterImpl.cpp (modified) (15 diffs)
• BIOSSettingsImpl.cpp (modified) (24 diffs)
• HostImpl.cpp (modified) (3 diffs)
• HostNetworkInterfaceImpl.cpp (modified) (28 diffs)
• MachineImpl.cpp (modified) (75 diffs)
• MediumAttachmentImpl.cpp (modified) (33 diffs)
• MediumImpl.cpp (modified) (3 diffs)
• NATEngineImpl.cpp (modified) (26 diffs)
• NetworkAdapterImpl.cpp (modified) (3 diffs)
• ParallelPortImpl.cpp (modified) (20 diffs)
• SnapshotImpl.cpp (modified) (10 diffs)
• USBControllerImpl.cpp (modified) (7 diffs)
• VFSExplorerImpl.cpp (modified) (2 diffs)
• generic/NetIf-generic.cpp (modified) (1 diff)
• xpcom/server.cpp (modified) (4 diffs)

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -26 +26 @@
 #include "AutoCaller.h"
 #include "Logging.h"
+
+struct AudioAdapter::Data
+{
+    Data();
+        BOOL mEnabled;
+        AudioDriverType_T mAudioDriver;
+        AudioControllerType_T mAudioController;
+};
 
 // constructor / destructor
@@ -180 +188 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP AudioAdapter::COMGETTER(Enabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT AudioAdapter::getEnabled(BOOL *aEnabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -194 +197 @@
 }
 
-STDMETHODIMP AudioAdapter::COMSETTER(Enabled)(BOOL aEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT AudioAdapter::setEnabled(BOOL aEnabled)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(mParent);
@@ -218 +218 @@
 }
 
-STDMETHODIMP AudioAdapter::COMGETTER(AudioDriver)(AudioDriverType_T *aAudioDriver)
-{
-    CheckComArgOutPointerValid(aAudioDriver);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT AudioAdapter::getAudioDriver(AudioDriverType_T *aAudioDriver)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -232 +227 @@
 }
 
-STDMETHODIMP AudioAdapter::COMSETTER(AudioDriver)(AudioDriverType_T aAudioDriver)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT AudioAdapter::setAudioDriver(AudioDriverType_T aAudioDriver)
+{
 
     /* the machine needs to be mutable */
@@ -251 +244 @@
             mData.backup();
             mData->mAudioDriver = aAudioDriver;
-
             alock.release();
             AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
@@ -266 +258 @@
 }
 
-STDMETHODIMP AudioAdapter::COMGETTER(AudioController)(AudioControllerType_T *aAudioController)
-{
-    CheckComArgOutPointerValid(aAudioController);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT AudioAdapter::getAudioController(AudioControllerType_T *aAudioController)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -280 +267 @@
 }
 
-STDMETHODIMP AudioAdapter::COMSETTER(AudioController)(AudioControllerType_T aAudioController)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT AudioAdapter::setAudioController(AudioControllerType_T aAudioController)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(mParent);
@@ -306 +290 @@
                 mData.backup();
                 mData->mAudioController = aAudioController;
-
                 alock.release();
                 AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
@@ -346 +329 @@
  *  @note Locks this object for writing.
  */
-HRESULT AudioAdapter::loadSettings(const settings::AudioAdapter &data)
+HRESULT AudioAdapter::i_loadSettings(const settings::AudioAdapter &data)
 {
     AutoCaller autoCaller(this);
@@ -378 +361 @@
  *  @note Locks this object for reading.
  */
-HRESULT AudioAdapter::saveSettings(settings::AudioAdapter &data)
+HRESULT AudioAdapter::i_saveSettings(settings::AudioAdapter &data)
 {
     AutoCaller autoCaller(this);
@@ -394 +377 @@
  *  @note Locks this object for writing.
  */
-void AudioAdapter::rollback()
+void AudioAdapter::i_rollback()
 {
     /* sanity */
@@ -409 +392 @@
  *  for writing) if there is one.
  */
-void AudioAdapter::commit()
+void AudioAdapter::i_commit()
 {
     /* sanity */
@@ -438 +421 @@
  *  represented by @a aThat (locked for reading).
  */
-void AudioAdapter::copyFrom(AudioAdapter *aThat)
+void AudioAdapter::i_copyFrom(AudioAdapter *aThat)
 {
     AssertReturnVoid (aThat != NULL);

trunk/src/VBox/Main/src-server/BIOSSettingsImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -49 +49 @@
 /////////////////////////////////////////////////////////////////////////////
 
+DEFINE_EMPTY_CTOR_DTOR(BIOSSettings)
+
 HRESULT BIOSSettings::FinalConstruct()
 {
@@ -182 +184 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP BIOSSettings::COMGETTER(LogoFadeIn)(BOOL *enabled)
-{
-    if (!enabled)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::getLogoFadeIn(BOOL *enabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -197 +194 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(LogoFadeIn)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT BIOSSettings::setLogoFadeIn(BOOL enable)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -218 +212 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(LogoFadeOut)(BOOL *enabled)
-{
-    if (!enabled)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::getLogoFadeOut(BOOL *enabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -233 +222 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(LogoFadeOut)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setLogoFadeOut(BOOL enable)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -254 +241 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(LogoDisplayTime)(ULONG *displayTime)
+
+HRESULT BIOSSettings::getLogoDisplayTime(ULONG *displayTime)
 {
     if (!displayTime)
         return E_POINTER;
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -269 +254 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(LogoDisplayTime)(ULONG displayTime)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setLogoDisplayTime(ULONG displayTime)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -290 +273 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(LogoImagePath)(BSTR *imagePath)
-{
-    if (!imagePath)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    m->bd->strLogoImagePath.cloneTo(imagePath);
-    return S_OK;
-}
-
-STDMETHODIMP BIOSSettings::COMSETTER(LogoImagePath)(IN_BSTR imagePath)
-{
-    /* NULL strings are not allowed */
-    if (!imagePath)
-        return E_INVALIDARG;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::getLogoImagePath(com::Utf8Str &imagePath)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    imagePath = m->bd->strLogoImagePath;
+    return S_OK;
+}
+
+
+HRESULT BIOSSettings::setLogoImagePath(const com::Utf8Str &imagePath)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -329 +301 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(BootMenuMode)(BIOSBootMenuMode_T *bootMenuMode)
-{
-    if (!bootMenuMode)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT BIOSSettings::getBootMenuMode(BIOSBootMenuMode_T *bootMenuMode)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -343 +309 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(BootMenuMode)(BIOSBootMenuMode_T bootMenuMode)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setBootMenuMode(BIOSBootMenuMode_T bootMenuMode)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -364 +328 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(ACPIEnabled)(BOOL *enabled)
-{
-    if (!enabled)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::getACPIEnabled(BOOL *enabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -379 +338 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(ACPIEnabled)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setACPIEnabled(BOOL enable)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -400 +357 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(IOAPICEnabled)(BOOL *enabled)
-{
-    if (!enabled)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *enabled = m->bd->fIOAPICEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP BIOSSettings::COMSETTER(IOAPICEnabled)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* the machine needs to be mutable */
-    AutoMutableStateDependency adep(m->pMachine);
-    if (FAILED(adep.rc())) return adep.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    m->bd.backup();
-    m->bd->fIOAPICEnabled = !!enable;
-
-    alock.release();
-    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
-    m->pMachine->setModified(Machine::IsModified_BIOS);
-
-    return S_OK;
-}
-
-STDMETHODIMP BIOSSettings::COMGETTER(PXEDebugEnabled)(BOOL *enabled)
-{
-    if (!enabled)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::getIOAPICEnabled(BOOL *aIOAPICEnabled)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aIOAPICEnabled = m->bd->fIOAPICEnabled;
+
+    return S_OK;
+}
+
+
+HRESULT BIOSSettings::setIOAPICEnabled(BOOL aIOAPICEnabled)
+{
+    /* the machine needs to be mutable */
+    AutoMutableStateDependency adep(m->pMachine);
+    if (FAILED(adep.rc())) return adep.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    m->bd.backup();
+
+    m->bd->fIOAPICEnabled = !!aIOAPICEnabled;
+    alock.release();
+    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
+    m->pMachine->setModified(Machine::IsModified_BIOS);
+
+    return S_OK;
+}
+
+
+HRESULT BIOSSettings::getPXEDebugEnabled(BOOL *enabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -451 +396 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(PXEDebugEnabled)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setPXEDebugEnabled(BOOL enable)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -472 +415 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(TimeOffset)(LONG64 *offset)
-{
-    if (!offset)
-        return E_POINTER;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT BIOSSettings::getTimeOffset(LONG64 *offset)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -487 +424 @@
 }
 
-STDMETHODIMP BIOSSettings::COMSETTER(TimeOffset)(LONG64 offset)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT BIOSSettings::setTimeOffset(LONG64 offset)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -508 +443 @@
 }
 
-STDMETHODIMP BIOSSettings::COMGETTER(NonVolatileStorageFile)(BSTR *pbstrPath)
-{
-    CheckComArgOutPointerValid(pbstrPath);
-
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        Bstr bstrEmpty("");
-        hrc = bstrEmpty.cloneToEx(pbstrPath);
-    }
-
-    return hrc;
+HRESULT BIOSSettings::getNonVolatileStorageFile(com::Utf8Str &aNonVolatileStorageFile)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    aNonVolatileStorageFile = "";
+
+    return S_OK;
 }
 
@@ -540 +468 @@
  *  @note Locks this object for writing.
  */
-HRESULT BIOSSettings::loadSettings(const settings::BIOSSettings &data)
+HRESULT BIOSSettings::i_loadSettings(const settings::BIOSSettings &data)
 {
     AutoCaller autoCaller(this);
@@ -560 +488 @@
  *  @note Locks this object for reading.
  */
-HRESULT BIOSSettings::saveSettings(settings::BIOSSettings &data)
+HRESULT BIOSSettings::i_saveSettings(settings::BIOSSettings &data)
 {
     AutoCaller autoCaller(this);
@@ -572 +500 @@
 }
 
-void BIOSSettings::rollback()
+void BIOSSettings::i_rollback()
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -578 +506 @@
 }
 
-void BIOSSettings::commit()
+void BIOSSettings::i_commit()
 {
     /* sanity */
@@ -604 +532 @@
 }
 
-void BIOSSettings::copyFrom (BIOSSettings *aThat)
+void BIOSSettings::i_copyFrom (BIOSSettings *aThat)
 {
     AssertReturnVoid (aThat != NULL);
@@ -625 +553 @@
 }
 
-void BIOSSettings::applyDefaults (GuestOSType *aOsType)
+void BIOSSettings::i_applyDefaults (GuestOSType *aOsType)
 {
     AssertReturnVoid (aOsType != NULL);

trunk/src/VBox/Main/src-server/HostImpl.cpp

@@ -2999 +2999 @@
         {
 # ifdef VBOX_WITH_RESOURCE_USAGE_API
-            (*itOld)->unregisterMetrics(aCollector, this);
+            (*itOld)->i_unregisterMetrics(aCollector, this);
 # endif
         }
@@ -3008 +3008 @@
      */
     for (itNew = list.begin(); itNew != list.end(); ++itNew)
-        (*itNew)->setVirtualBox(m->pParent);
+        (*itNew)->i_setVirtualBox(m->pParent);
     /* At this point listCopy will contain newly discovered interfaces only. */
     for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
@@ -3023 +3023 @@
         {
 # ifdef VBOX_WITH_RESOURCE_USAGE_API
-            (*itNew)->registerMetrics(aCollector, this);
+            (*itNew)->i_registerMetrics(aCollector, this);
 # endif
         }

trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp

@@ -17 +17 @@
  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  */
-
 #include "HostNetworkInterfaceImpl.h"
 #include "AutoCaller.h"
@@ -33 +32 @@
 #endif /* RT_OS_FREEBSD */
 
+#include "VirtualBoxImpl.h"
+
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
@@ -79 +80 @@
 
     unconst(mInterfaceName) = aInterfaceName;
-    unconst(mNetworkName) = composeNetworkName(aShortName);
+    unconst(mNetworkName) = i_composeNetworkName(aShortName);
     unconst(mShortName) = aShortName;
     unconst(mGuid) = aGuid;
@@ -92 +93 @@
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
 
-void HostNetworkInterface::registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
+void HostNetworkInterface::i_registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
 {
     LogFlowThisFunc(("mShortName={%ls}, mInterfaceName={%ls}, mGuid={%s}, mSpeedMbits=%u\n",
@@ -137 +138 @@
 }
 
-void HostNetworkInterface::unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
+void HostNetworkInterface::i_unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
 {
     LogFlowThisFunc(("mShortName={%ls}, mInterfaceName={%ls}, mGuid={%s}\n",
@@ -175 +176 @@
 }
 
-Bstr HostNetworkInterface::composeNetworkName(const Utf8Str aShortName)
+Bstr HostNetworkInterface::i_composeNetworkName(const Utf8Str aShortName)
 {
     return Utf8Str("HostInterfaceNetworking-").append(aShortName);
@@ -203 +204 @@
     if (pIf->szShortName[0])
     {
-        unconst(mNetworkName) = composeNetworkName(pIf->szShortName);
+        unconst(mNetworkName) = i_composeNetworkName(pIf->szShortName);
         unconst(mShortName)   = pIf->szShortName;
     }
     else
     {
-        unconst(mNetworkName) = composeNetworkName(aInterfaceName);
+        unconst(mNetworkName) = i_composeNetworkName(aInterfaceName);
         unconst(mShortName)   = aInterfaceName;
     }
@@ -235 +236 @@
 #endif
 
-// IHostNetworkInterface properties
+// wrapped IHostNetworkInterface properties
 /////////////////////////////////////////////////////////////////////////////
-
 /**
  * Returns the name of the host network interface.
  *
  * @returns COM status code
- * @param   aInterfaceName address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(Name)(BSTR *aInterfaceName)
-{
-    CheckComArgOutPointerValid(aInterfaceName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    mInterfaceName.cloneTo(aInterfaceName);
-
+ * @param   aInterfaceName - Interface Name
+ */
+
+HRESULT HostNetworkInterface::getName(com::Utf8Str &aInterfaceName)
+{
+    aInterfaceName = mInterfaceName;
     return S_OK;
 }
@@ -259 +254 @@
  * Returns the short name of the host network interface.
  *
- * @returns COM status code
- * @param   aShortName address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(ShortName)(BSTR *aShortName)
-{
-    CheckComArgOutPointerValid(aShortName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    mShortName.cloneTo(aShortName);
+ * @returns  COM status code
+ * @param   aShortName Short Name
+ */
+
+HRESULT HostNetworkInterface::getShortName(com::Utf8Str &aShortName)
+{
+    aShortName = mShortName;
 
     return S_OK;
@@ -278 +269 @@
  *
  * @returns COM status code
- * @param   aGuid address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(Id)(BSTR *aGuid)
-{
-    CheckComArgOutPointerValid(aGuid);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    mGuid.toUtf16().cloneTo(aGuid);
-
-    return S_OK;
-}
-
-STDMETHODIMP HostNetworkInterface::COMGETTER(DHCPEnabled)(BOOL *aDHCPEnabled)
-{
-    CheckComArgOutPointerValid(aDHCPEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+ * @param   aGuid GUI Id
+ */
+HRESULT HostNetworkInterface::getId(com::Guid &aGuiId)
+{
+    aGuiId = mGuid;
+
+    return S_OK;
+}
+
+HRESULT HostNetworkInterface::getDHCPEnabled(BOOL *aDHCPEnabled)
+{
     *aDHCPEnabled = m.dhcpEnabled;
 
@@ -309 +290 @@
  *
  * @returns COM status code
- * @param   aIPAddress address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(IPAddress)(BSTR *aIPAddress)
-{
-    CheckComArgOutPointerValid(aIPAddress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+ * @param   aIPAddress  Address name
+ */
+HRESULT HostNetworkInterface::getIPAddress(com::Utf8Str &aIPAddress)
+{
     in_addr tmp;
 #if defined(RT_OS_WINDOWS)
@@ -327 +303 @@
     if (addr)
     {
-        Bstr(addr).detachTo(aIPAddress);
+        aIPAddress = addr;
         return S_OK;
     }
@@ -338 +314 @@
  *
  * @returns COM status code
- * @param   aNetworkMask address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(NetworkMask)(BSTR *aNetworkMask)
-{
-    CheckComArgOutPointerValid(aNetworkMask);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+ * @param   aNetworkMask name.
+ */
+HRESULT HostNetworkInterface::getNetworkMask(com::Utf8Str &aNetworkMask)
+{
 
     in_addr tmp;
@@ -356 +328 @@
     if (addr)
     {
-        Bstr(addr).detachTo(aNetworkMask);
+        aNetworkMask = Utf8Str(addr);
         return S_OK;
     }
@@ -363 +335 @@
 }
 
-STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6Supported)(BOOL *aIPV6Supported)
-{
-    CheckComArgOutPointerValid(aIPV6Supported);
+HRESULT HostNetworkInterface::getIPV6Supported(BOOL *aIPV6Supported)
+{
 #if defined(RT_OS_WINDOWS)
     *aIPV6Supported = FALSE;
@@ -379 +350 @@
  *
  * @returns COM status code
- * @param   aIPV6Address address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6Address)(BSTR *aIPV6Address)
-{
-    CheckComArgOutPointerValid(aIPV6Address);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    m.IPV6Address.cloneTo(aIPV6Address);
-
+ * @param   aIPV6Address
+ */
+HRESULT HostNetworkInterface::getIPV6Address(com::Utf8Str &aIPV6Address)
+{
+    aIPV6Address = m.IPV6Address;
     return S_OK;
 }
@@ -399 +364 @@
  * @param   aIPV6Mask address of result pointer
  */
-STDMETHODIMP HostNetworkInterface::COMGETTER(IPV6NetworkMaskPrefixLength)(ULONG *aIPV6NetworkMaskPrefixLength)
-{
-    CheckComArgOutPointerValid(aIPV6NetworkMaskPrefixLength);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT HostNetworkInterface::getIPV6NetworkMaskPrefixLength(ULONG *aIPV6NetworkMaskPrefixLength)
+{
     *aIPV6NetworkMaskPrefixLength = m.IPV6NetworkMaskPrefixLength;
 
@@ -415 +375 @@
  *
  * @returns COM status code
- * @param   aHardwareAddress address of result pointer
- */
-STDMETHODIMP HostNetworkInterface::COMGETTER(HardwareAddress)(BSTR *aHardwareAddress)
-{
-    CheckComArgOutPointerValid(aHardwareAddress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    m.hardwareAddress.cloneTo(aHardwareAddress);
-
+ * @param   aHardwareAddress hardware address
+ */
+HRESULT HostNetworkInterface::getHardwareAddress(com::Utf8Str &aHardwareAddress)
+{
+    aHardwareAddress = m.hardwareAddress;
     return S_OK;
 }
@@ -435 +389 @@
  * @param   aType address of result pointer
  */
-STDMETHODIMP HostNetworkInterface::COMGETTER(MediumType)(HostNetworkInterfaceMediumType_T *aType)
-{
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT HostNetworkInterface::getMediumType(HostNetworkInterfaceMediumType_T *aType)
+{
     *aType = m.mediumType;
 
@@ -453 +402 @@
  * @param   aStatus address of result pointer
  */
-STDMETHODIMP HostNetworkInterface::COMGETTER(Status)(HostNetworkInterfaceStatus_T *aStatus)
-{
-    CheckComArgOutPointerValid(aStatus);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT HostNetworkInterface::getStatus(HostNetworkInterfaceStatus_T *aStatus)
+{
     *aStatus = m.status;
 
@@ -471 +415 @@
  * @param   aType address of result pointer
  */
-STDMETHODIMP HostNetworkInterface::COMGETTER(InterfaceType)(HostNetworkInterfaceType_T *aType)
-{
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT HostNetworkInterface::getInterfaceType(HostNetworkInterfaceType_T *aType)
+{
     *aType = mIfType;
 
@@ -484 +423 @@
 }
 
-STDMETHODIMP HostNetworkInterface::COMGETTER(NetworkName)(BSTR *aNetworkName)
-{
-    CheckComArgOutPointerValid(aNetworkName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    mNetworkName.cloneTo(aNetworkName);
-
-    return S_OK;
-}
-
-STDMETHODIMP HostNetworkInterface::EnableStaticIPConfig(IN_BSTR aIPAddress, IN_BSTR aNetMask)
+HRESULT HostNetworkInterface::getNetworkName(com::Utf8Str &aNetworkName)
+{
+    aNetworkName = mNetworkName;
+
+    return S_OK;
+}
+
+HRESULT HostNetworkInterface::enableStaticIPConfig(const com::Utf8Str &aIPAddress,
+                                                   const com::Utf8Str &aNetworkMask)
 {
 #ifndef VBOX_WITH_HOSTNETIF_API
     return E_NOTIMPL;
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (Bstr(aIPAddress).isEmpty())
+    if (aIPAddress.isEmpty())
     {
         if (m.IPAddress)
@@ -524 +456 @@
 
     ULONG ip, mask;
-    ip = inet_addr(Utf8Str(aIPAddress).c_str());
+    ip = inet_addr(aIPAddress.c_str());
     if (ip != INADDR_NONE)
     {
-        if (Bstr(aNetMask).isEmpty())
+        if (aNetworkMask.isEmpty())
             mask = 0xFFFFFF;
         else
-            mask = inet_addr(Utf8Str(aNetMask).c_str());
+            mask = inet_addr(aNetworkMask.c_str());
         if (mask != INADDR_NONE)
         {
@@ -541 +473 @@
                 m.realNetworkMask = mask;
                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(),
-                                                       Bstr(aIPAddress).raw())))
+                                               Bstr(aIPAddress).raw())))
                     return E_FAIL;
                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(),
-                                               Bstr(aNetMask).raw())))
+                                               Bstr(aNetworkMask).raw())))
                     return E_FAIL;
                 return S_OK;
@@ -560 +492 @@
 }
 
-STDMETHODIMP HostNetworkInterface::EnableStaticIPConfigV6(IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
+HRESULT HostNetworkInterface::enableStaticIPConfigV6(const com::Utf8Str &aIPV6Address,
+                                                     ULONG aIPV6NetworkMaskPrefixLength)
 {
 #ifndef VBOX_WITH_HOSTNETIF_API
     return E_NOTIMPL;
 #else
-    if (!aIPV6Address)
+    if (aIPV6NetworkMaskPrefixLength > 128)
         return E_INVALIDARG;
-    if (aIPV6MaskPrefixLength > 128)
-        return E_INVALIDARG;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     int rc = S_OK;
-    if (m.realIPV6Address != aIPV6Address || m.realIPV6PrefixLength != aIPV6MaskPrefixLength)
-    {
-        if (aIPV6MaskPrefixLength == 0)
-            aIPV6MaskPrefixLength = 64;
-        rc = NetIfEnableStaticIpConfigV6(mVBox, this, m.IPV6Address.raw(), aIPV6Address, aIPV6MaskPrefixLength);
+    if (m.realIPV6Address != aIPV6Address || m.realIPV6PrefixLength != aIPV6NetworkMaskPrefixLength)
+    {
+        BSTR bstr;
+        aIPV6Address.cloneTo(&bstr);
+        if (aIPV6NetworkMaskPrefixLength == 0)
+            aIPV6NetworkMaskPrefixLength = 64;
+        rc = NetIfEnableStaticIpConfigV6(mVBox, this, m.IPV6Address.raw(), bstr, aIPV6NetworkMaskPrefixLength);
         if (RT_FAILURE(rc))
         {
@@ -587 +517 @@
         {
             m.realIPV6Address = aIPV6Address;
-            m.realIPV6PrefixLength = aIPV6MaskPrefixLength;
+            m.realIPV6PrefixLength = aIPV6NetworkMaskPrefixLength;
             if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()).raw(),
                                            Bstr(aIPV6Address).raw())))
                 return E_FAIL;
             if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", mInterfaceName.raw()).raw(),
-                                           BstrFmt("%u", aIPV6MaskPrefixLength).raw())))
+                                           BstrFmt("%u", aIPV6NetworkMaskPrefixLength).raw())))
                 return E_FAIL;
         }
@@ -601 +531 @@
 }
 
-STDMETHODIMP HostNetworkInterface::EnableDynamicIPConfig()
+HRESULT HostNetworkInterface::HostNetworkInterface::enableDynamicIPConfig()
 {
 #ifndef VBOX_WITH_HOSTNETIF_API
     return E_NOTIMPL;
 #else
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     int rc = NetIfEnableDynamicIpConfig(mVBox, this);
     if (RT_FAILURE(rc))
@@ -619 +546 @@
 }
 
-STDMETHODIMP HostNetworkInterface::DHCPRediscover()
+HRESULT HostNetworkInterface::dHCPRediscover()
 {
 #ifndef VBOX_WITH_HOSTNETIF_API
     return E_NOTIMPL;
 #else
+    int rc = NetIfDhcpRediscover(mVBox, this);
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("Failed to DhcpRediscover with rc=%Rrc\n", rc));
+        return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
+    }
+    return S_OK;
+#endif
+}
+
+HRESULT HostNetworkInterface::i_setVirtualBox(VirtualBox *pVBox)
+{
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    int rc = NetIfDhcpRediscover(mVBox, this);
-    if (RT_FAILURE(rc))
-    {
-        LogRel(("Failed to DhcpRediscover with rc=%Rrc\n", rc));
-        return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
-    }
-    return S_OK;
-#endif
-}
-
-HRESULT HostNetworkInterface::setVirtualBox(VirtualBox *pVBox)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     AssertReturn(mVBox != pVBox, S_OK);
 

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

@@ -340 +340 @@
 
             /* Apply BIOS defaults */
-            mBIOSSettings->applyDefaults(aOsType);
+            mBIOSSettings->i_applyDefaults(aOsType);
 
             /* Apply network adapters defaults */
@@ -4080 +4080 @@
                                       aDevice)))
     {
-        Medium *pMedium = pAttachTemp->getMedium();
+        Medium *pMedium = pAttachTemp->i_getMedium();
         if (pMedium)
         {
@@ -4163 +4163 @@
 
                 /* see if it's the same bus/channel/device */
-                if (pAttachTemp->matches(aControllerName, aControllerPort, aDevice))
+                if (pAttachTemp->i_matches(aControllerName, aControllerPort, aDevice))
                 {
                     /* the simplest case: restore the whole attachment
@@ -4244 +4244 @@
                     uint32_t level = 0;
                     MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
-                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
+                    ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
+                    Assert(!pMedium.isNull() || pAttach->i_getType() != DeviceType_HardDisk);
                     if (pMedium.isNull())
                         continue;
@@ -4262 +4262 @@
                          * descendant of medium will be used
                          */
-                        if (pAttach->matches(aControllerName, aControllerPort, aDevice))
+                        if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
                         {
                             /* the simplest case: restore the whole attachment
@@ -4322 +4322 @@
                 {
                     /* use the previously attached hard disk */
-                    medium = (*foundIt)->getMedium();
+                    medium = (*foundIt)->i_getMedium();
                     mediumCaller.attach(medium);
                     if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
@@ -4358 +4358 @@
                 {
                     MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
-                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
+                    ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
+                    Assert(!pMedium.isNull() || pAttach->i_getType() != DeviceType_HardDisk);
                     if (pMedium.isNull())
                         continue;
@@ -4371 +4371 @@
                          * descendant of medium will be used
                          */
-                        if (    pAttach->getDevice() == aDevice
-                             && pAttach->getPort() == aControllerPort
-                             && pAttach->getControllerName() == aControllerName
+                        if (    pAttach->i_getDevice() == aDevice
+                             && pAttach->i_getPort() == aControllerPort
+                             && pAttach->i_getControllerName() == aControllerName
                            )
                         {
@@ -4391 +4391 @@
                 if (pAttachFound)
                 {
-                    base = pAttachFound->getMedium();
+                    base = pAttachFound->i_getMedium();
                     break;
                 }
@@ -4641 +4641 @@
                         aDevice, aControllerPort, aControllerName);
 
-    if (fHotplug && !pAttach->getHotPluggable())
+    if (fHotplug && !pAttach->i_getHotPluggable())
         return setError(VBOX_E_NOT_SUPPORTED,
                         tr("The device slot %d on port %d of controller '%ls' does not support hotplugging"),
@@ -4706 +4706 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    if (pAttach->getType() != DeviceType_DVD)
+    if (pAttach->i_getType() != DeviceType_DVD)
         return setError(E_INVALIDARG,
                         tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
                         aDevice, aControllerPort, aControllerName);
-    pAttach->updatePassthrough(!!aPassthrough);
+    pAttach->i_updatePassthrough(!!aPassthrough);
 
     return S_OK;
@@ -4746 +4746 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    if (pAttach->getType() != DeviceType_DVD)
+    if (pAttach->i_getType() != DeviceType_DVD)
         return setError(E_INVALIDARG,
                         tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
                         aDevice, aControllerPort, aControllerName);
-    pAttach->updateTempEject(!!aTemporaryEject);
+    pAttach->i_updateTempEject(!!aTemporaryEject);
 
     return S_OK;
@@ -4793 +4793 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    if (pAttach->getType() != DeviceType_HardDisk)
+    if (pAttach->i_getType() != DeviceType_HardDisk)
         return setError(E_INVALIDARG,
                         tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a hard disk"),
                         aDevice, aControllerPort, aControllerName);
-    pAttach->updateNonRotational(!!aNonRotational);
+    pAttach->i_updateNonRotational(!!aNonRotational);
 
     return S_OK;
@@ -4840 +4840 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    if (pAttach->getType() != DeviceType_HardDisk)
+    if (pAttach->i_getType() != DeviceType_HardDisk)
         return setError(E_INVALIDARG,
                         tr("Setting the discard medium flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a hard disk"),
                         aDevice, aControllerPort, aControllerName);
-    pAttach->updateDiscard(!!aDiscard);
+    pAttach->i_updateDiscard(!!aDiscard);
 
     return S_OK;
@@ -4903 +4903 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    if (pAttach->getType() == DeviceType_Floppy)
+    if (pAttach->i_getType() == DeviceType_Floppy)
         return setError(E_INVALIDARG,
                         tr("Setting the hot-pluggable device flag rejected as the device attached to device slot %d on port %d of controller '%ls' is a floppy drive"),
                         aDevice, aControllerPort, aControllerName);
-    pAttach->updateHotPluggable(!!aHotPluggable);
+    pAttach->i_updateHotPluggable(!!aHotPluggable);
 
     return S_OK;
@@ -4966 +4966 @@
     AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
 
-    const Utf8Str strBandwidthGroupOld = pAttach->getBandwidthGroup();
+    const Utf8Str strBandwidthGroupOld = pAttach->i_getBandwidthGroup();
     if (strBandwidthGroupOld.isNotEmpty())
     {
@@ -4975 +4975 @@
 
         pBandwidthGroupOld->i_release();
-        pAttach->updateBandwidthGroup(Utf8Str::Empty);
+        pAttach->i_updateBandwidthGroup(Utf8Str::Empty);
     }
 
@@ -4981 +4981 @@
     {
         group->i_reference();
-        pAttach->updateBandwidthGroup(group->i_getName());
+        pAttach->i_updateBandwidthGroup(group->i_getName());
     }
 
@@ -5051 +5051 @@
      * backup is not necessarily the same thing. */
     ComObjPtr<Medium> oldmedium;
-    oldmedium = pAttach->getMedium();
+    oldmedium = pAttach->i_getMedium();
 
     ComObjPtr<Medium> pMedium = static_cast<Medium*>(aMedium);
@@ -5063 +5063 @@
     if (pMedium)
     {
-        DeviceType_T mediumType = pAttach->getType();
+        DeviceType_T mediumType = pAttach->i_getType();
         switch (mediumType)
         {
@@ -5103 +5103 @@
 
         AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-        pAttach->updateMedium(pMedium);
+        pAttach->i_updateMedium(pMedium);
     }
 
@@ -5129 +5129 @@
         if (!oldmedium.isNull())
             oldmedium->i_addBackReference(mData->mUuid);
-        pAttach->updateMedium(oldmedium);
+        pAttach->i_updateMedium(oldmedium);
     }
 
@@ -5167 +5167 @@
                         aDevice, aControllerPort, aControllerName);
 
-    pAttach->getMedium().queryInterfaceTo(aMedium);
+    pAttach->i_getMedium().queryInterfaceTo(aMedium);
 
     return S_OK;
@@ -6605 +6605 @@
             AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
 
-            if (pAttachTemp->getControllerName() == aName)
+            if (pAttachTemp->i_getControllerName() == aName)
             {
                 rc = detachDevice(pAttachTemp, alock, NULL);
@@ -6743 +6743 @@
     mUSBControllers.backup();
 
-    ctrl->unshare();
+    ctrl->i_unshare();
 
     mUSBControllers->remove(ctrl);
@@ -8820 +8820 @@
              ++it)
         {
-            ComObjPtr<Medium> pMedium = (*it)->getMedium();
+            ComObjPtr<Medium> pMedium = (*it)->i_getMedium();
             if (pMedium.isNull())
                 continue;
@@ -9355 +9355 @@
 
         /* BIOS */
-        rc = mBIOSSettings->loadSettings(data.biosSettings);
+        rc = mBIOSSettings->i_loadSettings(data.biosSettings);
         if (FAILED(rc)) return rc;
 
@@ -9425 +9425 @@
 
             AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
-            rc = mParallelPorts[p.ulSlot]->loadSettings(p);
+            rc = mParallelPorts[p.ulSlot]->i_loadSettings(p);
             if (FAILED(rc)) return rc;
         }
 
         /* AudioAdapter */
-        rc = mAudioAdapter->loadSettings(data.audioAdapter);
+        rc = mAudioAdapter->i_loadSettings(data.audioAdapter);
         if (FAILED(rc)) return rc;
 
@@ -9963 +9963 @@
          ++it)
     {
-        if ((*it)->getName() == aName)
+        if ((*it)->i_getName() == aName)
         {
             aUSBController = (*it);
@@ -9990 +9990 @@
          ++it)
     {
-        if ((*it)->getControllerType() == enmType)
+        if ((*it)->i_getControllerType() == enmType)
             cCtrls++;
     }
@@ -10023 +10023 @@
         AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
 
-        if (pAtt->getControllerName() == aName)
+        if (pAtt->i_getControllerName() == aName)
             atts.push_back(pAtt);
     }
@@ -10405 +10405 @@
  * with it.
  *
-  Caller must hold the machine lock!
+ * Caller must hold the machine lock!
  *
  * This throws XML errors and HRESULT, so the caller must have a catch block!
@@ -10660 +10660 @@
 
         /* BIOS (required) */
-        rc = mBIOSSettings->saveSettings(data.biosSettings);
+        rc = mBIOSSettings->i_saveSettings(data.biosSettings);
         if (FAILED(rc)) throw rc;
 
@@ -10671 +10671 @@
             settings::USBController settingsCtrl;
 
-            settingsCtrl.strName = ctrl->getName();
-            settingsCtrl.enmType = ctrl->getControllerType();
+            settingsCtrl.strName = ctrl->i_getName();
+            settingsCtrl.enmType = ctrl->i_getControllerType();
 
             data.usbSettings.llUSBControllers.push_back(settingsCtrl);
@@ -10723 +10723 @@
             settings::ParallelPort p;
             p.ulSlot = slot;
-            rc = mParallelPorts[slot]->saveSettings(p);
+            rc = mParallelPorts[slot]->i_saveSettings(p);
             if (FAILED(rc)) return rc;
 
@@ -10730 +10730 @@
 
         /* Audio adapter */
-        rc = mAudioAdapter->saveSettings(data.audioAdapter);
+        rc = mAudioAdapter->i_saveSettings(data.audioAdapter);
         if (FAILED(rc)) return rc;
 
@@ -10905 +10905 @@
 
         MediumAttachment *pAttach = *it;
-        Medium *pMedium = pAttach->getMedium();
-
-        dev.deviceType = pAttach->getType();
-        dev.lPort = pAttach->getPort();
-        dev.lDevice = pAttach->getDevice();
-        dev.fPassThrough = pAttach->getPassthrough();
-        dev.fHotPluggable = pAttach->getHotPluggable();
+        Medium *pMedium = pAttach->i_getMedium();
+
+        dev.deviceType = pAttach->i_getType();
+        dev.lPort = pAttach->i_getPort();
+        dev.lDevice = pAttach->i_getDevice();
+        dev.fPassThrough = pAttach->i_getPassthrough();
+        dev.fHotPluggable = pAttach->i_getHotPluggable();
         if (pMedium)
         {
@@ -10918 +10918 @@
             else
                 dev.uuid = pMedium->i_getId();
-            dev.fTempEject = pAttach->getTempEject();
-            dev.fNonRotational = pAttach->getNonRotational();
-            dev.fDiscard = pAttach->getDiscard();
-        }
-
-        dev.strBwGroup = pAttach->getBandwidthGroup();
+            dev.fTempEject = pAttach->i_getTempEject();
+            dev.fNonRotational = pAttach->i_getNonRotational();
+            dev.fDiscard = pAttach->i_getDiscard();
+        }
+
+        dev.strBwGroup = pAttach->i_getBandwidthGroup();
 
         data.llAttachedDevices.push_back(dev);
@@ -11106 +11106 @@
             {
                 MediumAttachment* pAtt = *it;
-                if (pAtt->getType() == DeviceType_HardDisk)
+                if (pAtt->i_getType() == DeviceType_HardDisk)
                 {
-                    Medium* pMedium = pAtt->getMedium();
+                    Medium* pMedium = pAtt->i_getMedium();
                     Assert(pMedium);
 
@@ -11158 +11158 @@
             MediumAttachment* pAtt = *it;
 
-            DeviceType_T devType = pAtt->getType();
-            Medium* pMedium = pAtt->getMedium();
+            DeviceType_T devType = pAtt->i_getType();
+            Medium* pMedium = pAtt->i_getMedium();
 
             if (   devType != DeviceType_HardDisk
@@ -11245 +11245 @@
             rc = attachment->init(this,
                                   diff,
-                                  pAtt->getControllerName(),
-                                  pAtt->getPort(),
-                                  pAtt->getDevice(),
+                                  pAtt->i_getControllerName(),
+                                  pAtt->i_getPort(),
+                                  pAtt->i_getDevice(),
                                   DeviceType_HardDisk,
                                   true /* aImplicit */,
                                   false /* aPassthrough */,
                                   false /* aTempEject */,
-                                  pAtt->getNonRotational(),
-                                  pAtt->getDiscard(),
-                                  pAtt->getHotPluggable(),
-                                  pAtt->getBandwidthGroup());
+                                  pAtt->i_getNonRotational(),
+                                  pAtt->i_getDiscard(),
+                                  pAtt->i_getHotPluggable(),
+                                  pAtt->i_getBandwidthGroup());
             if (FAILED(rc)) throw rc;
 
@@ -11306 +11306 @@
     {
         const ComObjPtr<MediumAttachment> &pAtt = *it;
-        if (pAtt->isImplicit())
+        if (pAtt->i_isImplicit())
         {
             fImplicitDiffs = true;
@@ -11356 +11356 @@
             {
                 MediumAttachment* pAtt = *it;
-                if (pAtt->getType() == DeviceType_HardDisk)
+                if (pAtt->i_getType() == DeviceType_HardDisk)
                 {
-                    Medium* pMedium = pAtt->getMedium();
+                    Medium* pMedium = pAtt->i_getMedium();
                     Assert(pMedium);
 
@@ -11396 +11396 @@
         {
             ComObjPtr<MediumAttachment> pAtt = *it;
-            ComObjPtr<Medium> pMedium = pAtt->getMedium();
+            ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
             if (pMedium.isNull())
                 continue;
 
             // Implicit attachments go on the list for deletion and back references are removed.
-            if (pAtt->isImplicit())
+            if (pAtt->i_isImplicit())
             {
                 /* Deassociate and mark for deletion */
-                LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->getLogName()));
+                LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->i_getLogName()));
                 rc = pMedium->i_removeBackReference(mData->mUuid);
                 if (FAILED(rc))
@@ -11416 +11416 @@
             {
                 /* no: de-associate */
-                LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->getLogName()));
+                LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->i_getLogName()));
                 rc = pMedium->i_removeBackReference(mData->mUuid);
                 if (FAILED(rc))
@@ -11422 +11422 @@
                 continue;
             }
-            LogFlowThisFunc(("Not detaching '%s'\n", pAtt->getLogName()));
+            LogFlowThisFunc(("Not detaching '%s'\n", pAtt->i_getLogName()));
         }
 
@@ -11456 +11456 @@
                 ComObjPtr<MediumAttachment> pAtt = *it;
                 Assert(pAtt);
-                LogFlowThisFunc(("Deleting '%s'\n", pAtt->getLogName()));
-                ComObjPtr<Medium> pMedium = pAtt->getMedium();
+                LogFlowThisFunc(("Deleting '%s'\n", pAtt->i_getLogName()));
+                ComObjPtr<Medium> pMedium = pAtt->i_getMedium();
                 Assert(pMedium);
 
                 rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/);
                 // continue on delete failure, just collect error messages
-                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->getLogName(), pMedium->i_getLocationFull().c_str() ));
+                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(), pMedium->i_getLocationFull().c_str() ));
                 mrc = rc;
             }
@@ -11524 +11524 @@
     {
         MediumAttachment *pAttach = *it;
-        if (pAttach->matches(aControllerName, aControllerPort, aDevice))
+        if (pAttach->i_matches(aControllerName, aControllerPort, aDevice))
             return pAttach;
     }
@@ -11550 +11550 @@
     {
         MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
+        ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
         if (pMediumThis == pMedium)
             return pAttach;
@@ -11577 +11577 @@
     {
         MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
+        ComObjPtr<Medium> pMediumThis = pAttach->i_getMedium();
         if (pMediumThis->i_getId() == id)
             return pAttach;
@@ -11598 +11598 @@
                               Snapshot *pSnapshot)
 {
-    ComObjPtr<Medium> oldmedium = pAttach->getMedium();
-    DeviceType_T mediumType = pAttach->getType();
+    ComObjPtr<Medium> oldmedium = pAttach->i_getMedium();
+    DeviceType_T mediumType = pAttach->i_getType();
 
     LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
 
-    if (pAttach->isImplicit())
+    if (pAttach->i_isImplicit())
     {
         /* attempt to implicitly delete the implicitly created diff */
@@ -11689 +11689 @@
     {
         ComObjPtr<MediumAttachment> &pAttach = *it;
-        ComObjPtr<Medium> pMedium = pAttach->getMedium();
+        ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
 
         if (!pMedium.isNull())
@@ -11780 +11780 @@
         MediumAttachment *pAttach = *it;
 
-        pAttach->commit();
-
-        Medium* pMedium = pAttach->getMedium();
-        bool fImplicit = pAttach->isImplicit();
+        pAttach->i_commit();
+
+        Medium* pMedium = pAttach->i_getMedium();
+        bool fImplicit = pAttach->i_isImplicit();
 
         LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
@@ -11794 +11794 @@
         {
             /* convert implicit attachment to normal */
-            pAttach->setImplicit(false);
+            pAttach->i_setImplicit(false);
 
             if (    aOnline
                  && pMedium
-                 && pAttach->getType() == DeviceType_HardDisk
+                 && pAttach->i_getType() == DeviceType_HardDisk
                )
             {
@@ -11835 +11835 @@
             {
                 MediumAttachment *pOldAttach = *oldIt;
-                if (pOldAttach->getMedium() == pMedium)
+                if (pOldAttach->i_getMedium() == pMedium)
                 {
                     LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
@@ -11854 +11854 @@
     {
         MediumAttachment *pAttach = *it;
-        Medium* pMedium = pAttach->getMedium();
+        Medium* pMedium = pAttach->i_getMedium();
 
         /* Detach only hard disks, since DVD/floppy media is detached
          * instantly in MountMedium. */
-        if (pAttach->getType() == DeviceType_HardDisk && pMedium)
+        if (pAttach->i_getType() == DeviceType_HardDisk && pMedium)
         {
             LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
@@ -11919 +11919 @@
              ++it)
         {
-            (*it)->updateParentMachine(mPeer);
+            (*it)->i_updateParentMachine(mPeer);
         }
 
@@ -11958 +11958 @@
         MediumAttachment *pAttach = *it;
         /* Fix up the backrefs for DVD/floppy media. */
-        if (pAttach->getType() != DeviceType_HardDisk)
-        {
-            Medium* pMedium = pAttach->getMedium();
+        if (pAttach->i_getType() != DeviceType_HardDisk)
+        {
+            Medium* pMedium = pAttach->i_getMedium();
             if (pMedium)
             {
@@ -11968 +11968 @@
         }
 
-        (*it)->rollback();
+        (*it)->i_rollback();
 
         pAttach = *it;
         /* Fix up the backrefs for DVD/floppy media. */
-        if (pAttach->getType() != DeviceType_HardDisk)
-        {
-            Medium* pMedium = pAttach->getMedium();
+        if (pAttach->i_getType() != DeviceType_HardDisk)
+        {
+            Medium* pMedium = pAttach->i_getMedium();
             if (pMedium)
             {
@@ -12097 +12097 @@
             while (it != mUSBControllers->end())
             {
-                (*it)->rollback();
+                (*it)->i_rollback();
                 ++it;
             }
@@ -12111 +12111 @@
 
     if (mBIOSSettings)
-        mBIOSSettings->rollback();
+        mBIOSSettings->i_rollback();
 
     if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
@@ -12117 +12117 @@
 
     if (mAudioAdapter)
-        mAudioAdapter->rollback();
+        mAudioAdapter->i_rollback();
 
     if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
@@ -12152 +12152 @@
         for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
             if (    mParallelPorts[slot]
-                 && mParallelPorts[slot]->isModified())
+                 && mParallelPorts[slot]->i_isModified())
             {
-                mParallelPorts[slot]->rollback();
+                mParallelPorts[slot]->i_rollback();
                 parallelPorts[slot] = mParallelPorts[slot];
             }
@@ -12222 +12222 @@
         commitMedia(Global::IsOnline(mData->mMachineState));
 
-    mBIOSSettings->commit();
+    mBIOSSettings->i_commit();
     mVRDEServer->i_commit();
-    mAudioAdapter->commit();
+    mAudioAdapter->i_commit();
     mUSBDeviceFilters->commit();
     mBandwidthControl->i_commit();
@@ -12282 +12282 @@
         mSerialPorts[slot]->i_commit();
     for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-        mParallelPorts[slot]->commit();
+        mParallelPorts[slot]->i_commit();
 
     bool commitStorageControllers = false;
@@ -12369 +12369 @@
             while (it != mUSBControllers->end())
             {
-                (*it)->commit();
+                (*it)->i_commit();
 
                 /* look if this controller has a peer device */
-                ComObjPtr<USBController> peer = (*it)->getPeer();
+                ComObjPtr<USBController> peer = (*it)->i_getPeer();
                 if (!peer)
                 {
@@ -12421 +12421 @@
         while (it != mUSBControllers->end())
         {
-            (*it)->commit();
+            (*it)->i_commit();
             ++it;
         }
@@ -12471 +12471 @@
     }
 
-    mBIOSSettings->copyFrom(aThat->mBIOSSettings);
+    mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
     mVRDEServer->i_copyFrom(aThat->mVRDEServer);
-    mAudioAdapter->copyFrom(aThat->mAudioAdapter);
+    mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
     mUSBDeviceFilters->copyFrom(aThat->mUSBDeviceFilters);
     mBandwidthControl->i_copyFrom(aThat->mBandwidthControl);
@@ -12509 +12509 @@
         mSerialPorts[slot]->i_copyFrom(aThat->mSerialPorts[slot]);
     for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-        mParallelPorts[slot]->copyFrom(aThat->mParallelPorts[slot]);
+        mParallelPorts[slot]->i_copyFrom(aThat->mParallelPorts[slot]);
 }
 
@@ -12555 +12555 @@
         AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
 
-        if (pAttach->getType() == DeviceType_HardDisk)
-            list.push_back(pAttach->getMedium());
+        if (pAttach->i_getType() == DeviceType_HardDisk)
+            list.push_back(pAttach->i_getMedium());
     }
 }
@@ -13964 +13964 @@
         /* Need to query the details first, as the IMediumAttachment reference
          * might be to the original settings, which we are going to change. */
-        ctrlName = pAttach->getControllerName();
-        lPort = pAttach->getPort();
-        lDevice = pAttach->getDevice();
-        fTempEject = pAttach->getTempEject();
+        ctrlName = pAttach->i_getControllerName();
+        lPort = pAttach->i_getPort();
+        lDevice = pAttach->i_getDevice();
+        fTempEject = pAttach->i_getTempEject();
     }
 
@@ -13975 +13975 @@
          * backup is not necessarily the same thing. */
         ComObjPtr<Medium> oldmedium;
-        oldmedium = pAttach->getMedium();
+        oldmedium = pAttach->i_getMedium();
 
         setModified(IsModified_Storage);
@@ -13995 +13995 @@
                 oldmedium->i_removeBackReference(mData->mUuid);
 
-            pAttach->updateMedium(NULL);
-            pAttach->updateEjected();
+            pAttach->i_updateMedium(NULL);
+            pAttach->i_updateEjected();
         }
 
@@ -14005 +14005 @@
         {
             AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-            pAttach->updateEjected();
+            pAttach->i_updateEjected();
         }
     }
@@ -14715 +14715 @@
     {
         MediumAttachment* pAtt = *it;
-        DeviceType_T devType = pAtt->getType();
-        Medium *pMedium = pAtt->getMedium();
+        DeviceType_T devType = pAtt->i_getType();
+        Medium *pMedium = pAtt->i_getMedium();
 
         MediumLockList *pMediumLockList(new MediumLockList());

trunk/src/VBox/Main/src-server/MediumAttachmentImpl.cpp

@@ -86 +86 @@
 /////////////////////////////////////////////////////////////////////////////
 
+DEFINE_EMPTY_CTOR_DTOR(MediumAttachment)
+
 HRESULT MediumAttachment::FinalConstruct()
 {
@@ -169 +171 @@
                           m->bd->fImplicit ? ":I" : "");
 
-    LogFlowThisFunc(("LEAVE - %s\n", getLogName()));
+    LogFlowThisFunc(("LEAVE - %s\n", i_getLogName()));
     return S_OK;
 }
@@ -209 +211 @@
 void MediumAttachment::uninit()
 {
-    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
+    LogFlowThisFunc(("ENTER - %s\n", i_getLogName()));
 
     /* Enclose the state transition Ready->InUninit->NotReady */
@@ -229 +231 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP MediumAttachment::COMGETTER(Medium)(IMedium **aHardDisk)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aHardDisk);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getMedium(ComPtr<IMedium> &aHardDisk)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m->bd->pMedium.queryInterfaceTo(aHardDisk);
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Controller)(BSTR *aController)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aController);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    aHardDisk = m->bd->pMedium;
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+
+HRESULT MediumAttachment::getController(com::Utf8Str &aController)
+{
+    LogFlowThisFuncEnter();
 
     /* m->controller is constant during life time, no need to lock */
-    m->bd->bstrControllerName.cloneTo(aController);
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-STDMETHODIMP MediumAttachment::COMGETTER(Port)(LONG *aPort)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aPort);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    aController = Utf8Str(m->bd->bstrControllerName);
+
+    LogFlowThisFuncLeave();
+    return S_OK;
+}
+
+
+HRESULT MediumAttachment::getPort(LONG *aPort)
+{
+    LogFlowThisFuncEnter();
 
     /* m->bd->port is constant during life time, no need to lock */
@@ -278 +268 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(Device)(LONG *aDevice)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aDevice);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT  MediumAttachment::getDevice(LONG *aDevice)
+{
+    LogFlowThisFuncEnter();
 
     /* m->bd->device is constant during life time, no need to lock */
@@ -294 +279 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(Type)(DeviceType_T *aType)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT MediumAttachment::getType(DeviceType_T *aType)
+{
+    LogFlowThisFuncEnter();
 
     /* m->bd->type is constant during life time, no need to lock */
@@ -310 +290 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(Passthrough)(BOOL *aPassthrough)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aPassthrough);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getPassthrough(BOOL *aPassthrough)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -327 +303 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(TemporaryEject)(BOOL *aTemporaryEject)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aTemporaryEject);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getTemporaryEject(BOOL *aTemporaryEject)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -344 +316 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(IsEjected)(BOOL *aEjected)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aEjected);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getIsEjected(BOOL *aEjected)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -361 +329 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(NonRotational)(BOOL *aNonRotational)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aNonRotational);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getNonRotational(BOOL *aNonRotational)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -378 +342 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(Discard)(BOOL *aDiscard)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aDiscard);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT MediumAttachment::getDiscard(BOOL *aDiscard)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -395 +354 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(BandwidthGroup) (IBandwidthGroup **aBwGroup)
-{
-    LogFlowThisFuncEnter();
-    CheckComArgOutPointerValid(aBwGroup);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+HRESULT MediumAttachment::getBandwidthGroup(ComPtr<IBandwidthGroup> &aBandwidthGroup)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -414 +370 @@
 
         if (SUCCEEDED(hrc))
-            pBwGroup.queryInterfaceTo(aBwGroup);
+            pBwGroup.queryInterfaceTo(aBandwidthGroup.asOutParam());
     }
 
@@ -421 +377 @@
 }
 
-STDMETHODIMP MediumAttachment::COMGETTER(HotPluggable)(BOOL *aHotPluggable)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aHotPluggable);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+HRESULT MediumAttachment::getHotPluggable(BOOL *aHotPluggable)
+{
+    LogFlowThisFuncEnter();
 
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -441 +392 @@
  *  @note Locks this object for writing.
  */
-void MediumAttachment::rollback()
-{
-    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
+void MediumAttachment::i_rollback()
+{
+    LogFlowThisFunc(("ENTER - %s\n", i_getLogName()));
 
     /* sanity */
@@ -453 +404 @@
     m->bd.rollback();
 
-    LogFlowThisFunc(("LEAVE - %s\n", getLogName()));
+    LogFlowThisFunc(("LEAVE - %s\n", i_getLogName()));
 }
 
@@ -459 +410 @@
  *  @note Locks this object for writing.
  */
-void MediumAttachment::commit()
-{
-    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
+void MediumAttachment::i_commit()
+{
+    LogFlowThisFunc(("ENTER - %s\n", i_getLogName()));
 
     /* sanity */
@@ -472 +423 @@
         m->bd.commit();
 
-    LogFlowThisFunc(("LEAVE - %s\n", getLogName()));
-}
-
-bool MediumAttachment::isImplicit() const
+    LogFlowThisFunc(("LEAVE - %s\n", i_getLogName()));
+}
+
+bool MediumAttachment::i_isImplicit() const
 {
     return m->bd->fImplicit;
 }
 
-void MediumAttachment::setImplicit(bool aImplicit)
+void MediumAttachment::i_setImplicit(bool aImplicit)
 {
     m->bd->fImplicit = aImplicit;
 }
 
-const ComObjPtr<Medium>& MediumAttachment::getMedium() const
+const ComObjPtr<Medium>& MediumAttachment::i_getMedium() const
 {
     return m->bd->pMedium;
 }
 
-Bstr MediumAttachment::getControllerName() const
+const Bstr MediumAttachment::i_getControllerName() const
 {
     return m->bd->bstrControllerName;
 }
 
-LONG MediumAttachment::getPort() const
+LONG MediumAttachment::i_getPort() const
 {
     return m->bd->lPort;
 }
 
-LONG MediumAttachment::getDevice() const
+LONG MediumAttachment::i_getDevice() const
 {
     return m->bd->lDevice;
 }
 
-DeviceType_T MediumAttachment::getType() const
+DeviceType_T MediumAttachment::i_getType() const
 {
     return m->bd->type;
 }
 
-bool MediumAttachment::getPassthrough() const
+bool MediumAttachment::i_getPassthrough() const
 {
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -516 +467 @@
 }
 
-bool MediumAttachment::getTempEject() const
+bool MediumAttachment::i_getTempEject() const
 {
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -522 +473 @@
 }
 
-bool MediumAttachment::getNonRotational() const
+bool MediumAttachment::i_getNonRotational() const
 {
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -528 +479 @@
 }
 
-bool MediumAttachment::getDiscard() const
+bool MediumAttachment::i_getDiscard() const
 {
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -534 +485 @@
 }
 
-bool MediumAttachment::getHotPluggable() const
+bool MediumAttachment::i_getHotPluggable() const
 {
     AutoReadLock lock(this COMMA_LOCKVAL_SRC_POS);
@@ -540 +491 @@
 }
 
-const Utf8Str& MediumAttachment::getBandwidthGroup() const
+Utf8Str& MediumAttachment::i_getBandwidthGroup() const
 {
     return m->bd->strBandwidthGroup;
 }
 
-bool MediumAttachment::matches(CBSTR aControllerName, LONG aPort, LONG aDevice)
+bool MediumAttachment::i_matches(CBSTR aControllerName, LONG aPort, LONG aDevice)
 {
     return (    aControllerName == m->bd->bstrControllerName
@@ -556 +507 @@
  * @param aMedium
  */
-void MediumAttachment::updateMedium(const ComObjPtr<Medium> &aMedium)
+void MediumAttachment::i_updateMedium(const ComObjPtr<Medium> &aMedium)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -567 +518 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updatePassthrough(bool aPassthrough)
+void MediumAttachment::i_updatePassthrough(bool aPassthrough)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -576 +527 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updateTempEject(bool aTempEject)
+void MediumAttachment::i_updateTempEject(bool aTempEject)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -585 +536 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updateEjected()
+void MediumAttachment::i_updateEjected()
 {
     Assert(isWriteLockOnCurrentThread());
@@ -593 +544 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updateNonRotational(bool aNonRotational)
+void MediumAttachment::i_updateNonRotational(bool aNonRotational)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -602 +553 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updateDiscard(bool aDiscard)
+void MediumAttachment::i_updateDiscard(bool aDiscard)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -611 +562 @@
 
 /** Must be called from under this object's write lock. */
-void MediumAttachment::updateHotPluggable(bool aHotPluggable)
+void MediumAttachment::i_updateHotPluggable(bool aHotPluggable)
 {
     Assert(isWriteLockOnCurrentThread());
@@ -619 +570 @@
 }
 
-void MediumAttachment::updateBandwidthGroup(const Utf8Str &aBandwidthGroup)
+void MediumAttachment::i_updateBandwidthGroup(const Utf8Str &aBandwidthGroup)
 {
     LogFlowThisFuncEnter();
@@ -630 +581 @@
 }
 
-void MediumAttachment::updateParentMachine(Machine * const pMachine)
-{
-    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
-
+void MediumAttachment::i_updateParentMachine(Machine * const pMachine)
+{
+    LogFlowThisFunc(("ENTER - %s\n", i_getLogName()));
     /* sanity */
     AutoCaller autoCaller(this);
@@ -642 +592 @@
     unconst(m->pMachine) = pMachine;
 
-    LogFlowThisFunc(("LEAVE - %s\n", getLogName()));
-}
-
+    LogFlowThisFunc(("LEAVE - %s\n", i_getLogName()));
+}
+

trunk/src/VBox/Main/src-server/MediumImpl.cpp

@@ -1474 +1474 @@
     /// registries of portable VMs referring to this medium), this will also
     /// require to add the mRegistered flag to data
-
+    NOREF(aDescription);
     ReturnComNotImplemented();
 }
@@ -1704 +1704 @@
 HRESULT Medium::getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes)
 {
+    NOREF(aAllowedTypes);
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2662 +2663 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    NOREF(aLocation);
+    NOREF(aProgress);
 
     /// @todo NEWMEDIA for file names, add the default extension if no extension

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

@@ -29 +29 @@
 #include <VBox/com/array.h>
 
+struct NATEngine::Data
+{
+    Data() : mMtu(0),
+             mSockRcv(0),
+             mSockSnd(0),
+             mTcpRcv(0),
+             mTcpSnd(0),
+             mDNSPassDomain(TRUE),
+             mDNSProxy(FALSE),
+             mDNSUseHostResolver(FALSE),
+             mAliasMode(0)
+    {}
+
+    com::Utf8Str mNetwork;
+    com::Utf8Str mBindIP;
+    uint32_t mMtu;
+    uint32_t mSockRcv;
+    uint32_t mSockSnd;
+    uint32_t mTcpRcv;
+    uint32_t mTcpSnd;
+    /* TFTP service */
+    Utf8Str mTFTPPrefix;
+    Utf8Str mTFTPBootFile;
+    Utf8Str mTFTPNextServer;
+    /* DNS service */
+    BOOL mDNSPassDomain;
+    BOOL mDNSProxy;
+    BOOL mDNSUseHostResolver;
+    /* Alias service */
+    ULONG mAliasMode;
+};
+
+
 
 // constructor / destructor
@@ -38 +71 @@
 HRESULT NATEngine::FinalConstruct()
 {
-    return S_OK;
-}
+    return BaseFinalConstruct();
+}
+
+void NATEngine::FinalRelease()
+{
+    uninit();
+    BaseFinalRelease();
+}
+
 
 HRESULT NATEngine::init(Machine *aParent, INetworkAdapter *aAdapter)
@@ -106 +146 @@
 
 
-void NATEngine::FinalRelease()
-{
-    uninit();
-    BaseFinalRelease();
-}
-
 void NATEngine::uninit()
 {
@@ -124 +158 @@
 }
 
-bool NATEngine::isModified()
+bool NATEngine::i_isModified()
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -131 +165 @@
 }
 
-bool NATEngine::rollback()
+bool NATEngine::i_rollback()
 {
     AutoCaller autoCaller(this);
@@ -149 +183 @@
 }
 
-void NATEngine::commit()
+void NATEngine::i_commit()
 {
     AutoCaller autoCaller(this);
@@ -178 +212 @@
 }
 
-STDMETHODIMP
-NATEngine::GetNetworkSettings(ULONG *aMtu, ULONG *aSockSnd, ULONG *aSockRcv, ULONG *aTcpWndSnd, ULONG *aTcpWndRcv)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT NATEngine::getNetworkSettings(ULONG *aMtu, ULONG *aSockSnd, ULONG *aSockRcv, ULONG *aTcpWndSnd, ULONG *aTcpWndRcv)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (aMtu)
@@ -190 +220 @@
         *aSockSnd = mData->mSockSnd;
     if (aSockRcv)
-         *aSockRcv = mData->mSockRcv;
+        *aSockRcv = mData->mSockRcv;
     if (aTcpWndSnd)
-         *aTcpWndSnd = mData->mTcpSnd;
+        *aTcpWndSnd = mData->mTcpSnd;
     if (aTcpWndRcv)
-         *aTcpWndRcv = mData->mTcpRcv;
-
-    return S_OK;
-}
-
-STDMETHODIMP
-NATEngine::SetNetworkSettings(ULONG aMtu, ULONG aSockSnd, ULONG aSockRcv, ULONG aTcpWndSnd, ULONG aTcpWndRcv)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+        *aTcpWndRcv = mData->mTcpRcv;
+
+    return S_OK;
+}
+
+HRESULT NATEngine::setNetworkSettings(ULONG aMtu, ULONG aSockSnd, ULONG aSockRcv, ULONG aTcpWndSnd, ULONG aTcpWndRcv)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (   aMtu || aSockSnd || aSockRcv
@@ -228 +254 @@
 }
 
-STDMETHODIMP
-NATEngine::COMGETTER(Redirects)(ComSafeArrayOut(BSTR , aNatRules))
-{
-    CheckComArgOutSafeArrayPointerValid(aNatRules);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-
-    SafeArray<BSTR> sf(mNATRules.size());
+
+HRESULT NATEngine::getRedirects(std::vector<com::Utf8Str> &aRedirects)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    aRedirects.resize(mNATRules.size());
     size_t i = 0;
     NATRuleMap::const_iterator it;
-    for (it = mNATRules.begin();
-         it != mNATRules.end(); ++it, ++i)
+    for (it = mNATRules.begin(); it != mNATRules.end(); ++it, ++i)
     {
         settings::NATRule r = it->second;
-        BstrFmt bstr("%s,%d,%s,%d,%s,%d",
-                     r.strName.c_str(),
-                     r.proto,
-                     r.strHostIP.c_str(),
-                     r.u16HostPort,
-                     r.strGuestIP.c_str(),
-                     r.u16GuestPort);
-        bstr.detachTo(&sf[i]);
-    }
-    sf.detachTo(ComSafeArrayOutArg(aNatRules));
-    return S_OK;
-}
-
-
-STDMETHODIMP
-NATEngine::AddRedirect(IN_BSTR aName, NATProtocol_T aProto, IN_BSTR aBindIp, USHORT aHostPort, IN_BSTR aGuestIP, USHORT aGuestPort)
-{
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+        aRedirects[i] = Utf8StrFmt("%s,%d,%s,%d,%s,%d",
+                                   r.strName.c_str(),
+                                   r.proto,
+                                   r.strHostIP.c_str(),
+                                   r.u16HostPort,
+                                   r.strGuestIP.c_str(),
+                                   r.u16GuestPort);
+    }
+    return S_OK;
+}
+
+HRESULT NATEngine::addRedirect(const com::Utf8Str &aName, NATProtocol_T aProto, const com::Utf8Str &aHostIP, USHORT aHostPort, const com::Utf8Str &aGuestIP, USHORT aGuestPort)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     Utf8Str name = aName;
@@ -292 +303 @@
             return setError(E_INVALIDARG,
                             tr("A NAT rule of this name already exists"));
-        if (   r.strHostIP == Utf8Str(aBindIp)
+        if (   r.strHostIP == aHostIP
             && r.u16HostPort == aHostPort
             && r.proto == aProto)
@@ -301 +312 @@
     r.strName = name.c_str();
     r.proto = aProto;
-    r.strHostIP = aBindIp;
+    r.strHostIP = aHostIP;
     r.u16HostPort = aHostPort;
     r.strGuestIP = aGuestIP;
@@ -317 +328 @@
 }
 
-STDMETHODIMP
-NATEngine::RemoveRedirect(IN_BSTR aName)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT NATEngine::removeRedirect(const com::Utf8Str &aName)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     NATRuleMap::iterator it = mNATRules.find(aName);
@@ -342 +349 @@
     mData.commit();
     alock.release();
-    mParent->onNATRedirectRuleChange(ulSlot, TRUE, aName, proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
-    return S_OK;
-}
-
-HRESULT NATEngine::loadSettings(const settings::NAT &data)
+    mParent->onNATRedirectRuleChange(ulSlot, TRUE, Bstr(aName).raw(), proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
+    return S_OK;
+}
+
+HRESULT NATEngine::i_loadSettings(const settings::NAT &data)
 {
     AutoCaller autoCaller(this);
@@ -383 +390 @@
 
 
-HRESULT NATEngine::saveSettings(settings::NAT &data)
+HRESULT NATEngine::i_saveSettings(settings::NAT &data)
 {
     AutoCaller autoCaller(this);
@@ -417 +424 @@
 }
 
-
-STDMETHODIMP
-NATEngine::COMSETTER(Network)(IN_BSTR aNetwork)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+HRESULT NATEngine::setNetwork(const com::Utf8Str &aNetwork)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (Bstr(mData->mNetwork) != aNetwork)
@@ -434 +437 @@
 }
 
-STDMETHODIMP
-NATEngine::COMGETTER(Network)(BSTR *aNetwork)
-{
-    CheckComArgNotNull(aNetwork);
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+
+HRESULT NATEngine::getNetwork(com::Utf8Str &aNetwork)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (!mData->mNetwork.isEmpty())
     {
-        mData->mNetwork.cloneTo(aNetwork);
+        aNetwork = mData->mNetwork;
         Log(("Getter (this:%p) Network: %s\n", this, mData->mNetwork.c_str()));
     }
@@ -450 +449 @@
 }
 
-STDMETHODIMP
-NATEngine::COMSETTER(HostIP)(IN_BSTR aBindIP)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (Bstr(mData->mBindIP) != aBindIP)
-    {
-        mData.backup();
-        mData->mBindIP = aBindIP;
-        mParent->setModified(Machine::IsModified_NetworkAdapters);
-        m_fModified = true;
-    }
-    return S_OK;
-}
-STDMETHODIMP NATEngine::COMGETTER(HostIP)(BSTR *aBindIP)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+HRESULT NATEngine::setHostIP(const com::Utf8Str &aHostIP)
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    if (Bstr(mData->mBindIP) != aHostIP)
+    {
+        mData.backup();
+        mData->mBindIP = aHostIP;
+        mParent->setModified(Machine::IsModified_NetworkAdapters);
+        m_fModified = true;
+    }
+    return S_OK;
+}
+
+HRESULT NATEngine::getHostIP(com::Utf8Str &aBindIP)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
     if (!mData->mBindIP.isEmpty())
-        mData->mBindIP.cloneTo(aBindIP);
-    return S_OK;
-}
-
-
-STDMETHODIMP
-NATEngine::COMSETTER(TFTPPrefix)(IN_BSTR aTFTPPrefix)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+        aBindIP = mData->mBindIP;
+    return S_OK;
+}
+
+HRESULT NATEngine::setTFTPPrefix(const com::Utf8Str &aTFTPPrefix)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (Bstr(mData->mTFTPPrefix) != aTFTPPrefix)
@@ -493 +484 @@
 }
 
-STDMETHODIMP
-NATEngine::COMGETTER(TFTPPrefix)(BSTR *aTFTPPrefix)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+HRESULT NATEngine::getTFTPPrefix(com::Utf8Str &aTFTPPrefix)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
     if (!mData->mTFTPPrefix.isEmpty())
     {
-        mData->mTFTPPrefix.cloneTo(aTFTPPrefix);
+        aTFTPPrefix = mData->mTFTPPrefix;
         Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->mTFTPPrefix.c_str()));
     }
@@ -508 +497 @@
 }
 
-STDMETHODIMP
-NATEngine::COMSETTER(TFTPBootFile)(IN_BSTR aTFTPBootFile)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+HRESULT NATEngine::setTFTPBootFile(const com::Utf8Str &aTFTPBootFile)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (Bstr(mData->mTFTPBootFile) != aTFTPBootFile)
@@ -524 +510 @@
 }
 
-STDMETHODIMP
-NATEngine::COMGETTER(TFTPBootFile)(BSTR *aTFTPBootFile)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+
+HRESULT NATEngine::getTFTPBootFile(com::Utf8Str &aTFTPBootFile)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (!mData->mTFTPBootFile.isEmpty())
     {
-        mData->mTFTPBootFile.cloneTo(aTFTPBootFile);
+        aTFTPBootFile = mData->mTFTPBootFile;
         Log(("Getter (this:%p) BootFile: %s\n", this, mData->mTFTPBootFile.c_str()));
     }
@@ -539 +522 @@
 }
 
-STDMETHODIMP
-NATEngine::COMSETTER(TFTPNextServer)(IN_BSTR aTFTPNextServer)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+
+HRESULT NATEngine::setTFTPNextServer(const com::Utf8Str &aTFTPNextServer)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (Bstr(mData->mTFTPNextServer) != aTFTPNextServer)
@@ -555 +536 @@
 }
 
-STDMETHODIMP
-NATEngine::COMGETTER(TFTPNextServer)(BSTR *aTFTPNextServer)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+HRESULT NATEngine::getTFTPNextServer(com::Utf8Str &aTFTPNextServer)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     if (!mData->mTFTPNextServer.isEmpty())
     {
-        mData->mTFTPNextServer.cloneTo(aTFTPNextServer);
+        aTFTPNextServer =  mData->mTFTPNextServer;
         Log(("Getter (this:%p) NextServer: %s\n", this, mData->mTFTPNextServer.c_str()));
     }
     return S_OK;
 }
+
 /* DNS */
-STDMETHODIMP
-NATEngine::COMSETTER(DNSPassDomain) (BOOL aDNSPassDomain)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+HRESULT NATEngine::setDNSPassDomain(BOOL aDNSPassDomain)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -586 +561 @@
     return S_OK;
 }
-STDMETHODIMP
-NATEngine::COMGETTER(DNSPassDomain)(BOOL *aDNSPassDomain)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+
+HRESULT NATEngine::getDNSPassDomain(BOOL *aDNSPassDomain)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     *aDNSPassDomain = mData->mDNSPassDomain;
     return S_OK;
 }
-STDMETHODIMP
-NATEngine::COMSETTER(DNSProxy)(BOOL aDNSProxy)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+
+
+HRESULT NATEngine::setDNSProxy(BOOL aDNSProxy)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -612 +583 @@
     return S_OK;
 }
-STDMETHODIMP
-NATEngine::COMGETTER(DNSProxy)(BOOL *aDNSProxy)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+
+HRESULT NATEngine::getDNSProxy(BOOL *aDNSProxy)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     *aDNSProxy = mData->mDNSProxy;
     return S_OK;
 }
-STDMETHODIMP
-NATEngine::COMGETTER(DNSUseHostResolver)(BOOL *aDNSUseHostResolver)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+
+
+HRESULT NATEngine::getDNSUseHostResolver(BOOL *aDNSUseHostResolver)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     *aDNSUseHostResolver = mData->mDNSUseHostResolver;
     return S_OK;
 }
-STDMETHODIMP
-NATEngine::COMSETTER(DNSUseHostResolver)(BOOL aDNSUseHostResolver)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
+
+
+HRESULT NATEngine::setDNSUseHostResolver(BOOL aDNSUseHostResolver)
+{
     if (mData->mDNSUseHostResolver != aDNSUseHostResolver)
     {
@@ -649 +612 @@
 }
 
-STDMETHODIMP NATEngine::COMSETTER(AliasMode)(ULONG aAliasMode)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
+HRESULT NATEngine::setAliasMode(ULONG aAliasMode)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -666 +626 @@
 }
 
-STDMETHODIMP NATEngine::COMGETTER(AliasMode)(ULONG *aAliasMode)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
+HRESULT NATEngine::getAliasMode(ULONG *aAliasMode)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     *aAliasMode = mData->mAliasMode;

trunk/src/VBox/Main/src-server/NetworkAdapterImpl.cpp

@@ -1251 +1251 @@
     }
 
-    mNATEngine->loadSettings(data.nat);
+    mNATEngine->i_loadSettings(data.nat);
     mData->mBridgedInterface = data.strBridgedName;
     mData->mInternalNetwork = data.strInternalNetworkName;
@@ -1306 +1306 @@
     data.mode = mData->mAttachmentType;
 
-    mNATEngine->commit();
-    mNATEngine->saveSettings(data.nat);
+    mNATEngine->i_commit();
+    mNATEngine->i_saveSettings(data.nat);
 
     data.strBridgedName = mData->mBridgedInterface;
@@ -1333 +1333 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     bool fChanged = m_fModified;
-    fChanged |= (mData->mAdapterType == NetworkAttachmentType_NAT? mNATEngine->isModified() : false);
+    fChanged |= (mData->mAdapterType == NetworkAttachmentType_NAT? mNATEngine->i_isModified() : false);
     return fChanged;
 }

trunk/src/VBox/Main/src-server/ParallelPortImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -52 +52 @@
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
+DEFINE_EMPTY_CTOR_DTOR(ParallelPort)
 
 HRESULT ParallelPort::FinalConstruct()
@@ -194 +195 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP ParallelPort::COMGETTER(Enabled) (BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT ParallelPort::getEnabled(BOOL *aEnabled)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -208 +204 @@
 }
 
-STDMETHODIMP ParallelPort::COMSETTER(Enabled) (BOOL aEnabled)
+HRESULT ParallelPort::setEnabled(BOOL aEnabled)
 {
     LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -246 +238 @@
 }
 
-STDMETHODIMP ParallelPort::COMGETTER(Slot) (ULONG *aSlot)
-{
-    CheckComArgOutPointerValid(aSlot);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT ParallelPort::getSlot(ULONG *aSlot)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -260 +247 @@
 }
 
-STDMETHODIMP ParallelPort::COMGETTER(IRQ) (ULONG *aIRQ)
-{
-    CheckComArgOutPointerValid(aIRQ);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT ParallelPort::getIRQ(ULONG *aIRQ)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -274 +256 @@
 }
 
-STDMETHODIMP ParallelPort::COMSETTER(IRQ)(ULONG aIRQ)
+HRESULT ParallelPort::setIRQ(ULONG aIRQ)
 {
     /* check IRQ limits
@@ -283 +265 @@
                         m->bd->ulSlot, aIRQ, 255);
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -311 +290 @@
 }
 
-STDMETHODIMP ParallelPort::COMGETTER(IOBase) (ULONG *aIOBase)
-{
-    CheckComArgOutPointerValid(aIOBase);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT ParallelPort::getIOBase(ULONG *aIOBase)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -325 +299 @@
 }
 
-STDMETHODIMP ParallelPort::COMSETTER(IOBase)(ULONG aIOBase)
+HRESULT ParallelPort::setIOBase(ULONG aIOBase)
 {
     /* check IOBase limits
@@ -334 +308 @@
                         m->bd->ulSlot, aIOBase, 0, 0xFFFF);
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -362 +333 @@
 }
 
-STDMETHODIMP ParallelPort::COMGETTER(Path) (BSTR *aPath)
-{
-    CheckComArgOutPointerValid(aPath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    m->bd->strPath.cloneTo(aPath);
-
-    return S_OK;
-}
-
-STDMETHODIMP ParallelPort::COMSETTER(Path) (IN_BSTR aPath)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+
+HRESULT ParallelPort::getPath(com::Utf8Str &aPath)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    aPath = m->bd->strPath;
+    return S_OK;
+}
+
+
+HRESULT ParallelPort::setPath(const com::Utf8Str &aPath)
+{
     /* the machine needs to be mutable */
     AutoMutableStateDependency adep(m->pMachine);
@@ -387 +350 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    Utf8Str str(aPath);
-    if (str != m->bd->strPath)
+    if (aPath != m->bd->strPath)
     {
-        HRESULT rc = checkSetPath(str);
+        HRESULT rc = i_checkSetPath(aPath);
         if (FAILED(rc)) return rc;
 
         m->bd.backup();
-        m->bd->strPath = str;
+        m->bd->strPath = aPath;
 
         m->fModified = true;
+
         // leave the lock before informing callbacks
         alock.release();
@@ -421 +384 @@
  *  @note Locks this object for writing.
  */
-HRESULT ParallelPort::loadSettings(const settings::ParallelPort &data)
+HRESULT ParallelPort::i_loadSettings(const settings::ParallelPort &data)
 {
     AutoCaller autoCaller(this);
@@ -439 +402 @@
  *  Note that the given Port node is completely empty on input.
  *
- *  @param aPortNode <Port> node.
+ *  @param  <data> node.
  *
  *  @note Locks this object for reading.
  */
-HRESULT ParallelPort::saveSettings(settings::ParallelPort &data)
+HRESULT ParallelPort::i_saveSettings(settings::ParallelPort &data)
 {
     AutoCaller autoCaller(this);
@@ -460 +423 @@
  * @return
  */
-bool ParallelPort::isModified()
+bool ParallelPort::i_isModified()
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -469 +432 @@
  *  @note Locks this object for writing.
  */
-void ParallelPort::rollback()
+void ParallelPort::i_rollback()
 {
     /* sanity */
@@ -484 +447 @@
  *  for writing) if there is one.
  */
-void ParallelPort::commit()
+void ParallelPort::i_commit()
 {
     /* sanity */
@@ -513 +476 @@
  *  represented by @a aThat (locked for reading).
  */
-void ParallelPort::copyFrom(ParallelPort *aThat)
+void ParallelPort::i_copyFrom(ParallelPort *aThat)
 {
     AssertReturnVoid (aThat != NULL);
@@ -537 +500 @@
  *  Validates COMSETTER(Path) arguments.
  */
-HRESULT ParallelPort::checkSetPath(const Utf8Str &str)
+HRESULT ParallelPort::i_checkSetPath(const Utf8Str &str)
 {
     AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);

trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

@@ -1045 +1045 @@
     {
         MediumAttachment *pAtt = *it;
-        Medium *pMedium = pAtt->getMedium();
+        Medium *pMedium = pAtt->i_getMedium();
         if (pMedium) // can be NULL for non-harddisk
         {
@@ -1777 +1777 @@
         ComObjPtr<MediumAttachment> &pAttach = *it;
         AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
-        if (pAttach->getType() == DeviceType_HardDisk)
+        if (pAttach->i_getType() == DeviceType_HardDisk)
         {
             ++ulOpCount;
             ++ulTotalWeight;         // assume one MB weight for each differencing hard disk to manage
-            Assert(pAttach->getMedium());
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->getMedium()->i_getName().c_str()));
+            Assert(pAttach->i_getMedium());
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->i_getMedium()->i_getName().c_str()));
         }
     }
@@ -1964 +1964 @@
         {
             ComObjPtr<MediumAttachment> pAttach = *it;
-            ComObjPtr<Medium> pMedium = pAttach->getMedium();
+            ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
 
             /* while the hard disk is attached, the number of children or the
              * parent cannot change, so no lock */
             if (    !pMedium.isNull()
-                 && pAttach->getType() == DeviceType_HardDisk
+                 && pAttach->i_getType() == DeviceType_HardDisk
                  && !pMedium->i_getParent().isNull()
                  && pMedium->i_getChildren().size() == 0
@@ -2008 +2008 @@
         {
             ComObjPtr<MediumAttachment> pAttach = *it;        // guaranteed to have only attachments where medium != NULL
-            ComObjPtr<Medium> pMedium = pAttach->getMedium();
+            ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
 
             AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
@@ -2176 +2176 @@
                         mUserData->s.strName.c_str());
 
-
     /* If the snapshot being deleted is the current one, ensure current
      * settings are committed and saved.
@@ -2214 +2213 @@
         ComObjPtr<MediumAttachment> &pAttach = *it;
         AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
-        if (pAttach->getType() == DeviceType_HardDisk)
-        {
-            ComObjPtr<Medium> pHD = pAttach->getMedium();
+        if (pAttach->i_getType() == DeviceType_HardDisk)
+        {
+            ComObjPtr<Medium> pHD = pAttach->i_getMedium();
             Assert(pHD);
             AutoReadLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
@@ -2437 +2436 @@
             ComObjPtr<MediumAttachment> &pAttach = *it;
             AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
-            if (pAttach->getType() != DeviceType_HardDisk)
+            if (pAttach->i_getType() != DeviceType_HardDisk)
                 continue;
 
-            ComObjPtr<Medium> pHD = pAttach->getMedium();
+            ComObjPtr<Medium> pHD = pAttach->i_getMedium();
             Assert(!pHD.isNull());
 
@@ -2479 +2478 @@
                 pOnlineMediumAttachment =
                     findAttachment(mMediaData->mAttachments,
-                                   pAttach->getControllerName().raw(),
-                                   pAttach->getPort(),
-                                   pAttach->getDevice());
+                                   pAttach->i_getControllerName().raw(),
+                                   pAttach->i_getPort(),
+                                   pAttach->i_getDevice());
                 if (pOnlineMediumAttachment)
                 {
@@ -2873 +2872 @@
                 {
                     AutoWriteLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
-                    pAtt->updateMedium(it->mpTarget);
+                    pAtt->i_updateMedium(it->mpTarget);
                     it->mpTarget->i_addBackReference(pMachine->mData->mUuid, childSnapshotId);
                 }
@@ -3649 +3648 @@
     {
         AutoWriteLock attLock(pDeleteRec->mpOnlineMediumAttachment COMMA_LOCKVAL_SRC_POS);
-        pDeleteRec->mpOnlineMediumAttachment->updateMedium(pDeleteRec->mpTarget);
+        pDeleteRec->mpOnlineMediumAttachment->i_updateMedium(pDeleteRec->mpTarget);
     }
 

trunk/src/VBox/Main/src-server/USBControllerImpl.cpp

@@ -234 +234 @@
 
 
-// IUSBController properties
-/////////////////////////////////////////////////////////////////////////////
-STDMETHODIMP USBController::COMGETTER(Name) (BSTR *aName)
-{
-    CheckComArgOutPointerValid(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+// Wrapped IUSBController properties
+/////////////////////////////////////////////////////////////////////////////
+HRESULT USBController::getName(com::Utf8Str &aName)
+{
     /* strName is constant during life time, no need to lock */
-    m->bd->strName.cloneTo(aName);
-
-    return S_OK;
-}
-
-STDMETHODIMP USBController::COMGETTER(Type)(USBControllerType_T *aType)
-{
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+    aName = m->bd->strName;
+
+    return S_OK;
+}
+
+HRESULT USBController::getType(USBControllerType_T *aType)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -263 +253 @@
 }
 
-STDMETHODIMP USBController::COMGETTER(USBStandard)(USHORT *aUSBStandard)
-{
-    CheckComArgOutPointerValid(aUSBStandard);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT USBController::getUSBStandard(USHORT *aUSBStandard)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -292 +277 @@
 
 /** @note Locks objects for writing! */
-void USBController::rollback()
+void USBController::i_rollback()
 {
     AutoCaller autoCaller(this);
@@ -310 +295 @@
  *  for writing) if there is one.
  */
-void USBController::commit()
+void USBController::i_commit()
 {
     /* sanity */
@@ -340 +325 @@
  *  represented by @a aThat (locked for reading).
  */
-void USBController::copyFrom(USBController *aThat)
+void USBController::i_copyFrom(USBController *aThat)
 {
     AssertReturnVoid(aThat != NULL);
@@ -374 +359 @@
  *  represented by @a aThat (locked for reading).
  */
-void USBController::unshare()
+void USBController::i_unshare()
 {
     /* sanity */
@@ -400 +385 @@
 }
 
-const Utf8Str& USBController::getName() const
+const Utf8Str &USBController::i_getName() const
 {
     return m->bd->strName;
 }
 
-USBControllerType_T USBController::getControllerType() const
+const USBControllerType_T &USBController::i_getControllerType() const
 {
     return m->bd->enmType;
 }
 
-ComObjPtr<USBController> USBController::getPeer()
+ComObjPtr<USBController> USBController::i_getPeer()
 {
     return m->pPeer;
 }
 
-// private methods
 /////////////////////////////////////////////////////////////////////////////
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

trunk/src/VBox/Main/src-server/VFSExplorerImpl.cpp

@@ -36 +36 @@
 
 #include <memory>
+
+struct VFSExplorer::Data
+{
+    struct DirEntry
+    {
+        DirEntry(Utf8Str strName, VFSFileType_T fileType, uint64_t cbSize, uint32_t fMode)
+           : name(strName)
+           , type(fileType)
+           , size(cbSize)
+           , mode(fMode) {}
+
+        Utf8Str name;
+        VFSFileType_T type;
+        uint64_t size;
+        uint32_t mode;
+    };
+
+    VFSType_T storageType;
+    Utf8Str strUsername;
+    Utf8Str strPassword;
+    Utf8Str strHostname;
+    Utf8Str strPath;
+    Utf8Str strBucket;
+    std::list<DirEntry> entryList;
+};
+
 
 VFSExplorer::VFSExplorer()
@@ -538 +564 @@
 
      if (SUCCEEDED(rc))
-        /* Return progress to the caller */
-        progress.queryInterfaceTo(aProgress.asOutParam());
+         /* Return progress to the caller */
+         progress.queryInterfaceTo(aProgress.asOutParam());
 
     return rc;

trunk/src/VBox/Main/src-server/generic/NetIf-generic.cpp

@@ -266 +266 @@
                             iface.createObject();
                             iface->init(IfName, HostNetworkInterfaceType_HostOnly, pInfo);
-                            iface->setVirtualBox(pVBox);
+                            iface->i_setVirtualBox(pVBox);
                             iface.queryInterfaceTo(aHostNetworkInterface);
                         }

trunk/src/VBox/Main/src-server/xpcom/server.cpp

@@ -113 +113 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Snapshot, ISnapshot)
 
-NS_DECL_CLASSINFO(MediumAttachment)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumAttachment, IMediumAttachment)
-
 NS_DECL_CLASSINFO(Progress)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
@@ -125 +122 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(SharedFolder, ISharedFolder)
 
-NS_DECL_CLASSINFO(HostNetworkInterface)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HostNetworkInterface, IHostNetworkInterface)
-
 NS_DECL_CLASSINFO(NetworkAdapter)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NetworkAdapter, INetworkAdapter)
-
-NS_DECL_CLASSINFO(NATEngine)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(NATEngine, INATEngine)
-
-NS_DECL_CLASSINFO(ParallelPort)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(ParallelPort, IParallelPort)
-
-NS_DECL_CLASSINFO(USBController)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(USBController, IUSBController)
 
 NS_DECL_CLASSINFO(USBDeviceFilters)
@@ -153 +138 @@
 NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HostUSBDeviceFilter, IUSBDeviceFilter, IHostUSBDeviceFilter)
 #endif
-
-NS_DECL_CLASSINFO(AudioAdapter)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(AudioAdapter, IAudioAdapter)
 
 NS_DECL_CLASSINFO(SystemProperties)
@@ -166 +148 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(PerformanceMetric, IPerformanceMetric)
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-NS_DECL_CLASSINFO(BIOSSettings)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(BIOSSettings, IBIOSSettings)
 
 #ifdef VBOX_WITH_EXTPACK