Changeset 24989 in vbox for trunk/src

Timestamp:

Nov 26, 2009 11:31:46 AM (15 years ago)

Author:

vboxsync

Message:

Main: enable -Wshadow gcc option to warn about shadowed variables and fix all resulting warnings; in particular, rename some stack and member variables and rename getter methods like id() to getId()

Location:

trunk/src/VBox/Main

Files:

• ApplianceImpl.cpp (modified) (9 diffs)
• ConsoleImpl.cpp (modified) (12 diffs)
• ConsoleImpl2.cpp (modified) (1 diff)
• ConsoleImplTeleporter.cpp (modified) (4 diffs)
• HostImpl.cpp (modified) (4 diffs)
• MachineImpl.cpp (modified) (86 diffs)
• MediumAttachmentImpl.cpp (modified) (4 diffs)
• MediumImpl.cpp (modified) (88 diffs)
• ProgressImpl.cpp (modified) (5 diffs)
• SnapshotImpl.cpp (modified) (13 diffs)
• USBControllerImpl.cpp (modified) (14 diffs)
• USBDeviceImpl.cpp (modified) (1 diff)
• VirtualBoxImpl.cpp (modified) (23 diffs)
• generic/NetIf-generic.cpp (modified) (2 diffs)
• hgcm/HGCMObjects.cpp (modified) (1 diff)
• include/AudioAdapterImpl.h (modified) (2 diffs)
• include/BIOSSettingsImpl.h (modified) (2 diffs)
• include/MachineImpl.h (modified) (10 diffs)
• include/MediumAttachmentImpl.h (modified) (2 diffs)
• include/MediumImpl.h (modified) (5 diffs)
• include/NetworkAdapterImpl.h (modified) (2 diffs)
• include/ParallelPortImpl.h (modified) (1 diff)
• include/ProgressImpl.h (modified) (1 diff)
• include/SerialPortImpl.h (modified) (1 diff)
• include/SharedFolderImpl.h (modified) (1 diff)
• include/USBControllerImpl.h (modified) (2 diffs)
• include/VRDPServerImpl.h (modified) (2 diffs)
• include/VirtualBoxBase.h (modified) (5 diffs)
• include/hgcm/HGCMObjects.h (modified) (2 diffs)
• xml/Settings.cpp (modified) (6 diffs)
• xpcom/server.cpp (modified) (1 diff)

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -1106 +1106 @@
 
     const OVFReader reader = *m->pReader;
-        // this is safe to access because this thread only gets started
-        // if pReader != NULL
+    // this is safe to access because this thread only gets started
+    // if pReader != NULL
 
     /* If an manifest file exists, verify the content. Therefor we need all
@@ -1167 +1167 @@
                           vrc);
         /* Cleanup */
-        for (size_t i=1; i < filesList.size(); ++i)
-            RTStrFree(pTestList[i].pszTestDigest);
+        for (size_t j = 1;
+             j < filesList.size();
+             ++j)
+            RTStrFree(pTestList[j].pszTestDigest);
         RTMemFree(pTestList);
         if (FAILED(rc))
@@ -1373 +1375 @@
                         /* We search for the first host network interface which
                          * is usable for bridged networking */
-                        for (size_t i=0; i < nwInterfaces.size(); ++i)
+                        for (size_t j = 0;
+                             j < nwInterfaces.size();
+                             ++j)
                         {
                             HostNetworkInterfaceType_T itype;
-                            rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
+                            rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
                             if (FAILED(rc)) throw rc;
                             if (itype == HostNetworkInterfaceType_Bridged)
                             {
                                 Bstr name;
-                                rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
+                                rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
                                 if (FAILED(rc)) throw rc;
                                 /* Set the interface name to attach to */
@@ -1404 +1408 @@
                         /* We search for the first host network interface which
                          * is usable for host only networking */
-                        for (size_t i=0; i < nwInterfaces.size(); ++i)
+                        for (size_t j = 0;
+                             j < nwInterfaces.size();
+                             ++j)
                         {
                             HostNetworkInterfaceType_T itype;
-                            rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
+                            rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
                             if (FAILED(rc)) throw rc;
                             if (itype == HostNetworkInterfaceType_HostOnly)
                             {
                                 Bstr name;
-                                rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
+                                rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
                                 if (FAILED(rc)) throw rc;
                                 /* Set the interface name to attach to */
@@ -1567 +1573 @@
 
                     // CD-ROMs next
-                    for (std::list<VirtualSystemDescriptionEntry*>::const_iterator it = vsdeCDROM.begin();
-                        it != vsdeCDROM.end();
-                        ++it)
+                    for (std::list<VirtualSystemDescriptionEntry*>::const_iterator jt = vsdeCDROM.begin();
+                         jt != vsdeCDROM.end();
+                         ++jt)
                     {
                         // for now always attach to secondary master on IDE controller;
                         // there seems to be no useful information in OVF where else to
-                        // attach it (@todo test with latest versions of OVF software)
+                        // attach jt (@todo test with latest versions of OVF software)
 
                         // find the IDE controller
                         const HardDiskController *pController = NULL;
-                        for (ControllersMap::const_iterator it = vsysThis.mapControllers.begin();
-                             it != vsysThis.mapControllers.end();
-                             ++it)
+                        for (ControllersMap::const_iterator kt = vsysThis.mapControllers.begin();
+                             kt != vsysThis.mapControllers.end();
+                             ++kt)
                         {
-                            if (it->second.system == HardDiskController::IDE)
+                            if (kt->second.system == HardDiskController::IDE)
                             {
-                                pController = &it->second;
+                                pController = &kt->second;
                             }
                         }
@@ -4388 +4394 @@
     CheckComRCReturnRC(autoCaller.rc());
 
-    AutoReadLock alock(this);
+    AutoReadLock alock1(this);
 
     ComObjPtr<VirtualSystemDescription> pNewDesc;
@@ -4394 +4400 @@
     try
     {
-        Bstr bstrName;
+        Bstr bstrName1;
         Bstr bstrDescription;
         Bstr bstrGuestOSType;
@@ -4407 +4413 @@
 
         // get name
-        bstrName = mUserData->mName;
+        bstrName1 = mUserData->mName;
         // get description
         bstrDescription = mUserData->mDescription;
@@ -4454 +4460 @@
 
         /* VM name */
-        Utf8Str strVMName(bstrName);
+        Utf8Str strVMName(bstrName1);
         pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
                            "",

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1055 +1055 @@
         // don't lock the folder because methods we access are const
 
-        Utf8Str name = folder->name();
+        Utf8Str name = folder->getName();
         vrc = SSMR3PutU32(pSSM, (uint32_t)name.length() + 1 /* term. 0 */);
         AssertRC(vrc);
@@ -1061 +1061 @@
         AssertRC(vrc);
 
-        Utf8Str hostPath = folder->hostPath();
+        Utf8Str hostPath = folder->getHostPath();
         vrc = SSMR3PutU32(pSSM, (uint32_t)hostPath.length() + 1 /* term. 0 */);
         AssertRC(vrc);
@@ -1067 +1067 @@
         AssertRC(vrc);
 
-        vrc = SSMR3PutBool(pSSM, !!folder->writable());
+        vrc = SSMR3PutBool(pSSM, !!folder->isWritable());
         AssertRC(vrc);
     }
@@ -2668 +2668 @@
         pTask->mProgress.queryInterfaceTo(aProgress);
     }
-    catch (HRESULT rc)
+    catch (HRESULT erc)
     {
         delete pTask;
-        NOREF(rc);
+        NOREF(erc);
         mptrCancelableProgress.setNull();
     }
@@ -4792 +4792 @@
         for (SharedFolderMap::const_iterator it = mSharedFolders.begin();
              it != mSharedFolders.end(); ++ it)
-            sharedFolders[it->first] = SharedFolderData(it->second->hostPath(), it->second->writable());
+            sharedFolders[it->first] = SharedFolderData(it->second->getHostPath(), it->second->isWritable());
     }
 
@@ -5194 +5194 @@
         {
             PPDMIBASE pBase;
-            int vrc = PDMR3QueryLun(mpVM, "usb-ohci", 0, 0, &pBase);
+            vrc = PDMR3QueryLun(mpVM, "usb-ohci", 0, 0, &pBase);
             if (RT_SUCCESS(vrc))
             {
@@ -6061 +6061 @@
         ComObjPtr<OUSBDevice> device;
         device.createObject();
-        HRESULT hrc = device->init(aHostDevice);
+        hrc = device->init(aHostDevice);
         AssertComRC(hrc);
 
@@ -6629 +6629 @@
      * Mark all existing remote USB devices as dirty.
      */
-    RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
-    while (it != mRemoteUSBDevices.end())
+    for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
+         it != mRemoteUSBDevices.end();
+         ++it)
     {
         (*it)->dirty(true);
-        ++ it;
     }
 
@@ -6653 +6653 @@
         bool fNewDevice = true;
 
-        it = mRemoteUSBDevices.begin();
-        while (it != mRemoteUSBDevices.end())
+        for (RemoteUSBDeviceList::iterator it = mRemoteUSBDevices.begin();
+             it != mRemoteUSBDevices.end();
+             ++it)
         {
             if ((*it)->devId() == e->id
@@ -6664 +6665 @@
                break;
             }
-
-            ++ it;
         }
 
@@ -7309 +7308 @@
 
         /* Pass all custom parameters. */
-        SafeArray<BSTR> names;
-        SafeArray<BSTR> values;
+        SafeArray<BSTR> aNames;
+        SafeArray<BSTR> aValues;
         hrc = medium->GetProperties(NULL,
-                                    ComSafeArrayAsOutParam(names),
-                                    ComSafeArrayAsOutParam(values));            H();
-
-        if (names.size() != 0)
+                                    ComSafeArrayAsOutParam(aNames),
+                                    ComSafeArrayAsOutParam(aValues));            H();
+
+        if (aNames.size() != 0)
         {
             PCFGMNODE pVDC;
             rc = CFGMR3InsertNode(pCur, "VDConfig", &pVDC);             RC_CHECK();
-            for (size_t i = 0; i < names.size(); ++ i)
+            for (size_t i = 0; i < aNames.size(); ++ i)
             {
-                if (values[i])
+                if (aValues[i])
                 {
-                    Utf8Str name = names[i];
-                    Utf8Str value = values[i];
+                    Utf8Str name = aNames[i];
+                    Utf8Str value = aValues[i];
                     rc = CFGMR3InsertString(pVDC, name.c_str(), value.c_str());
                     if (    !(name.compare("HostIPStack"))
@@ -7508 +7507 @@
                  * to access Console.
                  */
-                int vrc = VMR3ReqCallWait(that->mpVM,
-                                          VMCPUID_ANY,
-                                          (PFNRT)reconfigureMedium,
-                                          6,
-                                          that->mpVM,
-                                          lInstance,
-                                          enmController,
-                                          enmBus,
-                                          atts[i],
-                                          &rc);
+                vrc = VMR3ReqCallWait(that->mpVM,
+                                      VMCPUID_ANY,
+                                      (PFNRT)reconfigureMedium,
+                                      6,
+                                      that->mpVM,
+                                      lInstance,
+                                      enmController,
+                                      enmBus,
+                                      atts[i],
+                                      &rc);
                 if (RT_FAILURE(vrc))
                     throw setError(E_FAIL, Console::tr("%Rrc"), vrc);

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -1146 +1146 @@
 
                         /* Pass all custom parameters. */
-                        SafeArray<BSTR> names;
-                        SafeArray<BSTR> values;
+                        SafeArray<BSTR> aNames;
+                        SafeArray<BSTR> aValues;
                         hrc = medium->GetProperties(NULL,
-                                                    ComSafeArrayAsOutParam(names),
-                                                    ComSafeArrayAsOutParam(values));            H();
-
-                        if (names.size() != 0)
+                                                    ComSafeArrayAsOutParam(aNames),
+                                                    ComSafeArrayAsOutParam(aValues));           H();
+
+                        if (aNames.size() != 0)
                         {
                             PCFGMNODE pVDC;
                             rc = CFGMR3InsertNode(pCur, "VDConfig", &pVDC);                     RC_CHECK();
-                            for (size_t ii = 0; ii < names.size(); ++ii)
+                            for (size_t ii = 0; ii < aNames.size(); ++ii)
                             {
-                                if (values[ii])
+                                if (aValues[ii])
                                 {
-                                    Utf8Str name = names[ii];
-                                    Utf8Str value = values[ii];
+                                    Utf8Str name = aNames[ii];
+                                    Utf8Str value = aValues[ii];
                                     rc = CFGMR3InsertString(pVDC, name.c_str(), value.c_str()); AssertRC(rc); /** @todo r=bird: why not RC_HCECK here? (I added the AssertRC.)*/
                                     if (    name.compare("HostIPStack") == 0

trunk/src/VBox/Main/ConsoleImplTeleporter.cpp

@@ -1054 +1054 @@
              * Do the job, when it returns we're done.
              */
-            TeleporterStateTrg State(this, pVM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused);
-            State.mstrPassword      = strPassword;
-            State.mhServer          = hServer;
-
-            void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&State));
+            TeleporterStateTrg theState(this, pVM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused);
+            theState.mstrPassword      = strPassword;
+            theState.mhServer          = hServer;
+
+            void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState));
             if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser))
             {
                 LogRel(("Teleporter: Waiting for incoming VM...\n"));
-                vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &State);
+                vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
                 pProgress->setCancelCallback(NULL, NULL);
 
@@ -1068 +1068 @@
                 if (vrc == VERR_TCP_SERVER_STOP)
                 {
-                    vrc = State.mRc;
+                    vrc = theState.mRc;
                     /* Power off the VM on failure unless the state callback
                        already did that. */
@@ -1252 +1252 @@
 
             pState->moffStream = 0;
-            void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
-            vrc = VMR3LoadFromStream(pState->mpVM, &g_teleporterTcpOps, pvUser,
-                                     teleporterProgressCallback, pvUser);
+            void *pvUser2 = static_cast<void *>(static_cast<TeleporterState *>(pState));
+            vrc = VMR3LoadFromStream(pState->mpVM, &g_teleporterTcpOps, pvUser2,
+                                     teleporterProgressCallback, pvUser2);
             if (RT_FAILURE(vrc))
             {
@@ -1265 +1265 @@
             pState->mfStopReading = false;
             size_t cbRead;
-            vrc = teleporterTcpOpRead(pvUser, pState->moffStream, szCmd, 1, &cbRead);
+            vrc = teleporterTcpOpRead(pvUser2, pState->moffStream, szCmd, 1, &cbRead);
             if (vrc != VERR_EOF)
             {

trunk/src/VBox/Main/HostImpl.cpp

@@ -1348 +1348 @@
     /* notify the proxy (only when the filter is active) */
     if (    m->pUSBProxyService->isActive()
-         && pFilter->data().mActive)
-    {
-        ComAssertRet(pFilter->id() == NULL, E_FAIL);
-        pFilter->id() = m->pUSBProxyService->insertFilter(&pFilter->data().mUSBFilter);
+         && pFilter->getData().mActive)
+    {
+        ComAssertRet(pFilter->getId() == NULL, E_FAIL);
+        pFilter->getId() = m->pUSBProxyService->insertFilter(&pFilter->getData().mUSBFilter);
     }
 
@@ -1402 +1402 @@
 
     /* notify the proxy (only when the filter is active) */
-    if (m->pUSBProxyService->isActive() && filter->data().mActive)
-    {
-        ComAssertRet (filter->id() != NULL, E_FAIL);
-        m->pUSBProxyService->removeFilter (filter->id());
-        filter->id() = NULL;
+    if (m->pUSBProxyService->isActive() && filter->getData().mActive)
+    {
+        ComAssertRet(filter->getId() != NULL, E_FAIL);
+        m->pUSBProxyService->removeFilter(filter->getId());
+        filter->getId() = NULL;
     }
 
@@ -1677 +1677 @@
 
         /* notify the proxy (only when the filter is active) */
-        if (pFilter->data().mActive)
+        if (pFilter->getData().mActive)
         {
             HostUSBDeviceFilter *flt = pFilter; /* resolve ambiguity */
-            flt->id() = m->pUSBProxyService->insertFilter(&pFilter->data().mUSBFilter);
+            flt->getId() = m->pUSBProxyService->insertFilter(&pFilter->getData().mUSBFilter);
         }
     }
@@ -1775 +1775 @@
         {
             // insert/remove the filter from the proxy
-            if (aFilter->data().mActive)
+            if (aFilter->getData().mActive)
             {
-                ComAssertRet (aFilter->id() == NULL, E_FAIL);
-                aFilter->id() = m->pUSBProxyService->insertFilter (&aFilter->data().mUSBFilter);
+                ComAssertRet(aFilter->getId() == NULL, E_FAIL);
+                aFilter->getId() = m->pUSBProxyService->insertFilter(&aFilter->getData().mUSBFilter);
             }
             else
             {
-                ComAssertRet (aFilter->id() != NULL, E_FAIL);
-                m->pUSBProxyService->removeFilter (aFilter->id());
-                aFilter->id() = NULL;
+                ComAssertRet(aFilter->getId() != NULL, E_FAIL);
+                m->pUSBProxyService->removeFilter(aFilter->getId());
+                aFilter->getId() = NULL;
             }
         }
         else
         {
-            if (aFilter->data().mActive)
+            if (aFilter->getData().mActive)
             {
                 // update the filter in the proxy
-                ComAssertRet (aFilter->id() != NULL, E_FAIL);
-                m->pUSBProxyService->removeFilter (aFilter->id());
-                aFilter->id() = m->pUSBProxyService->insertFilter (&aFilter->data().mUSBFilter);
+                ComAssertRet(aFilter->getId() != NULL, E_FAIL);
+                m->pUSBProxyService->removeFilter(aFilter->getId());
+                aFilter->getId() = m->pUSBProxyService->insertFilter(&aFilter->getData().mUSBFilter);
             }
         }

trunk/src/VBox/Main/MachineImpl.cpp

@@ -237 +237 @@
         while (thatIt != thatFolders.end())
         {
-            if (    (*it)->name() == (*thatIt)->name()
-                 && RTPathCompare(Utf8Str((*it)->hostPath()).c_str(),
-                                  Utf8Str((*thatIt)->hostPath()).c_str()
+            if (    (*it)->getName() == (*thatIt)->getName()
+                 && RTPathCompare(Utf8Str((*it)->getHostPath()).c_str(),
+                                  Utf8Str((*thatIt)->getHostPath()).c_str()
                                  ) == 0)
             {
@@ -272 +272 @@
 }
 
-bool Machine::MediaData::operator== (const MediaData &that) const
+bool Machine::MediaData::operator==(const MediaData &that) const
 {
     if (this == &that)
@@ -294 +294 @@
         while (thatIt != thatAtts.end())
         {
-            if ((*it)->matches((*thatIt)->controllerName(),
-                               (*thatIt)->port(),
-                               (*thatIt)->device()) &&
-                (*it)->passthrough() == (*thatIt)->passthrough() &&
-                (*it)->medium().equalsTo ((*thatIt)->medium()))
+            if (    (*it)->matches((*thatIt)->getControllerName(),
+                                   (*thatIt)->getPort(),
+                                   (*thatIt)->getDevice())
+                 && (*it)->getPassthrough() == (*thatIt)->getPassthrough()
+                 && (*it)->getMedium().equalsTo((*thatIt)->getMedium())
+               )
             {
-                thatAtts.erase (thatIt);
+                thatAtts.erase(thatIt);
                 found = true;
                 break;
@@ -404 +405 @@
 
     /* get the full file name */
-    int vrc = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
-    if (RT_FAILURE(vrc))
+    int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
+    if (RT_FAILURE(vrc1))
         return setError(VBOX_E_FILE_ERROR,
                         tr("Invalid machine settings file name '%s' (%Rrc)"),
                         strConfigFile.raw(),
-                        vrc);
+                        vrc1);
 
     if (aMode == Init_Registered)
@@ -1385 +1386 @@
 }
 
-STDMETHODIMP Machine::GetCpuIdLeaf(ULONG id, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
+STDMETHODIMP Machine::GetCpuIdLeaf(ULONG aId, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
 {
     CheckComArgOutPointerValid(aValEax);
@@ -1397 +1398 @@
     AutoReadLock alock(this);
 
-    switch(id)
-    {
-    case 0x0:
-    case 0x1:
-    case 0x2:
-    case 0x3:
-    case 0x4:
-    case 0x5:
-    case 0x6:
-    case 0x7:
-    case 0x8:
-    case 0x9:
-    case 0xA:
-        if (mHWData->mCpuIdStdLeafs[id].ulId != id)
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), id);
-
-        *aValEax = mHWData->mCpuIdStdLeafs[id].ulEax;
-        *aValEbx = mHWData->mCpuIdStdLeafs[id].ulEbx;
-        *aValEcx = mHWData->mCpuIdStdLeafs[id].ulEcx;
-        *aValEdx = mHWData->mCpuIdStdLeafs[id].ulEdx;
-        break;
-
-    case 0x80000000:
-    case 0x80000001:
-    case 0x80000002:
-    case 0x80000003:
-    case 0x80000004:
-    case 0x80000005:
-    case 0x80000006:
-    case 0x80000007:
-    case 0x80000008:
-    case 0x80000009:
-    case 0x8000000A:
-        if (mHWData->mCpuIdExtLeafs[id - 0x80000000].ulId != id)
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), id);
-
-        *aValEax = mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEax;
-        *aValEbx = mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEbx;
-        *aValEcx = mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEcx;
-        *aValEdx = mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEdx;
-        break;
-
-    default:
-        return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), id);
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetCpuIdLeaf(ULONG id, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
+    switch(aId)
+    {
+        case 0x0:
+        case 0x1:
+        case 0x2:
+        case 0x3:
+        case 0x4:
+        case 0x5:
+        case 0x6:
+        case 0x7:
+        case 0x8:
+        case 0x9:
+        case 0xA:
+            if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
+                return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
+
+            *aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
+            *aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
+            *aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
+            *aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
+            break;
+
+        case 0x80000000:
+        case 0x80000001:
+        case 0x80000002:
+        case 0x80000003:
+        case 0x80000004:
+        case 0x80000005:
+        case 0x80000006:
+        case 0x80000007:
+        case 0x80000008:
+        case 0x80000009:
+        case 0x8000000A:
+            if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
+                return setError(E_INVALIDARG, tr("CpuId override leaf %#x is not set"), aId);
+
+            *aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
+            *aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
+            *aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
+            *aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
+            break;
+
+        default:
+            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
+    }
+    return S_OK;
+}
+
+STDMETHODIMP Machine::SetCpuIdLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
 {
     AutoCaller autoCaller(this);
@@ -1455 +1456 @@
     CheckComRCReturnRC(rc);
 
-    switch(id)
-    {
-    case 0x0:
-    case 0x1:
-    case 0x2:
-    case 0x3:
-    case 0x4:
-    case 0x5:
-    case 0x6:
-    case 0x7:
-    case 0x8:
-    case 0x9:
-    case 0xA:
-        AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
-        AssertRelease(id < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-        mHWData->mCpuIdStdLeafs[id].ulId  = id;
-        mHWData->mCpuIdStdLeafs[id].ulEax = aValEax;
-        mHWData->mCpuIdStdLeafs[id].ulEbx = aValEbx;
-        mHWData->mCpuIdStdLeafs[id].ulEcx = aValEcx;
-        mHWData->mCpuIdStdLeafs[id].ulEdx = aValEdx;
-        break;
-
-    case 0x80000000:
-    case 0x80000001:
-    case 0x80000002:
-    case 0x80000003:
-    case 0x80000004:
-    case 0x80000005:
-    case 0x80000006:
-    case 0x80000007:
-    case 0x80000008:
-    case 0x80000009:
-    case 0x8000000A:
-        AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
-        AssertRelease(id - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulId  = id;
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEax = aValEax;
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEbx = aValEbx;
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEcx = aValEcx;
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulEdx = aValEdx;
-        break;
-
-    default:
-        return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), id);
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::RemoveCpuIdLeaf(ULONG id)
+    switch(aId)
+    {
+        case 0x0:
+        case 0x1:
+        case 0x2:
+        case 0x3:
+        case 0x4:
+        case 0x5:
+        case 0x6:
+        case 0x7:
+        case 0x8:
+        case 0x9:
+        case 0xA:
+            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
+            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
+            mHWData->mCpuIdStdLeafs[aId].ulId  = aId;
+            mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
+            mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
+            mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
+            mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
+            break;
+
+        case 0x80000000:
+        case 0x80000001:
+        case 0x80000002:
+        case 0x80000003:
+        case 0x80000004:
+        case 0x80000005:
+        case 0x80000006:
+        case 0x80000007:
+        case 0x80000008:
+        case 0x80000009:
+        case 0x8000000A:
+            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
+            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId  = aId;
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
+            break;
+
+        default:
+            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
+    }
+    return S_OK;
+}
+
+STDMETHODIMP Machine::RemoveCpuIdLeaf(ULONG aId)
 {
     AutoCaller autoCaller(this);
@@ -1513 +1514 @@
     CheckComRCReturnRC(rc);
 
-    switch(id)
-    {
-    case 0x0:
-    case 0x1:
-    case 0x2:
-    case 0x3:
-    case 0x4:
-    case 0x5:
-    case 0x6:
-    case 0x7:
-    case 0x8:
-    case 0x9:
-    case 0xA:
-        AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
-        AssertRelease(id < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-        /* Invalidate leaf. */
-        mHWData->mCpuIdStdLeafs[id].ulId = UINT32_MAX;
-        break;
-
-    case 0x80000000:
-    case 0x80000001:
-    case 0x80000002:
-    case 0x80000003:
-    case 0x80000004:
-    case 0x80000005:
-    case 0x80000006:
-    case 0x80000007:
-    case 0x80000008:
-    case 0x80000009:
-    case 0x8000000A:
-        AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
-        AssertRelease(id - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-        /* Invalidate leaf. */
-        mHWData->mCpuIdExtLeafs[id - 0x80000000].ulId = UINT32_MAX;
-        break;
-
-    default:
-        return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), id);
+    switch(aId)
+    {
+        case 0x0:
+        case 0x1:
+        case 0x2:
+        case 0x3:
+        case 0x4:
+        case 0x5:
+        case 0x6:
+        case 0x7:
+        case 0x8:
+        case 0x9:
+        case 0xA:
+            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xA);
+            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
+            /* Invalidate leaf. */
+            mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
+            break;
+
+        case 0x80000000:
+        case 0x80000001:
+        case 0x80000002:
+        case 0x80000003:
+        case 0x80000004:
+        case 0x80000005:
+        case 0x80000006:
+        case 0x80000007:
+        case 0x80000008:
+        case 0x80000009:
+        case 0x8000000A:
+            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xA);
+            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
+            /* Invalidate leaf. */
+            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
+            break;
+
+        default:
+            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
     }
     return S_OK;
@@ -2345 +2346 @@
                                       aDevice)))
     {
-        Medium *pMedium = pAttachTemp->medium();
+        Medium *pMedium = pAttachTemp->getMedium();
         if (pMedium)
         {
@@ -2351 +2352 @@
             return setError(VBOX_E_OBJECT_IN_USE,
                             tr("Medium '%s' is already attached to device slot %d on port %d of controller '%ls' of this virtual machine"),
-                            pMedium->locationFull().raw(), aDevice, aControllerPort, aControllerName);
+                            pMedium->getLocationFull().raw(),
+                            aDevice,
+                            aControllerPort,
+                            aControllerName);
         }
         else
@@ -2359 +2363 @@
     }
 
-    Guid id(aId);
+    Guid uuid(aId);
 
     ComObjPtr<Medium> medium;
@@ -2366 +2370 @@
         case DeviceType_HardDisk:
             /* find a hard disk by UUID */
-            rc = mParent->findHardDisk(&id, NULL, true /* aSetError */, &medium);
+            rc = mParent->findHardDisk(&uuid, NULL, true /* aSetError */, &medium);
             CheckComRCReturnRC(rc);
             break;
 
         case DeviceType_DVD:
-            if (!id.isEmpty())
+            if (!uuid.isEmpty())
             {
                 /* first search for host drive */
@@ -2382 +2386 @@
                         /// @todo eliminate this conversion
                         ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                        if (med->id() == id)
+                        if (med->getId() == uuid)
                         {
                             medium = med;
@@ -2393 +2397 @@
                 {
                     /* find a DVD image by UUID */
-                    rc = mParent->findDVDImage(&id, NULL, true /* aSetError */, &medium);
+                    rc = mParent->findDVDImage(&uuid, NULL, true /* aSetError */, &medium);
                     CheckComRCReturnRC(rc);
                 }
@@ -2404 +2408 @@
 
         case DeviceType_Floppy:
-            if (!id.isEmpty())
+            if (!uuid.isEmpty())
             {
                 /* first search for host drive */
@@ -2415 +2419 @@
                         /// @todo eliminate this conversion
                         ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                        if (med->id() == id)
+                        if (med->getId() == uuid)
                         {
                             medium = med;
@@ -2426 +2430 @@
                 {
                     /* find a floppy image by UUID */
-                    rc = mParent->findFloppyImage(&id, NULL, true /* aSetError */, &medium);
+                    rc = mParent->findFloppyImage(&uuid, NULL, true /* aSetError */, &medium);
                     CheckComRCReturnRC(rc);
                 }
@@ -2452 +2456 @@
         return setError(VBOX_E_OBJECT_IN_USE,
                         tr("Medium '%s' is already attached to this virtual machine"),
-                        medium->locationFull().raw());
+                        medium->getLocationFull().raw());
     }
 
@@ -2497 +2501 @@
          * hard disks. */
 
-        if (medium->parent().isNull())
+        if (medium->getParent().isNull())
         {
             /* first, investigate the backup copy of the current hard disk
@@ -2515 +2519 @@
                     uint32_t level = 0;
                     MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->medium();
-                    Assert(!pMedium.isNull() || pAttach->type() != DeviceType_HardDisk);
+                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
+                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
                     if (pMedium.isNull())
                         continue;
 
-                    if (pMedium->base(&level).equalsTo(medium))
+                    if (pMedium->getBase(&level).equalsTo(medium))
                     {
                         /* skip the hard disk if its currently attached (we
@@ -2553 +2557 @@
                 {
                     /* use the previously attached hard disk */
-                    medium = (*foundIt)->medium();
+                    medium = (*foundIt)->getMedium();
                     mediumCaller.attach(medium);
                     CheckComRCReturnRC(mediumCaller.rc());
@@ -2584 +2588 @@
                 {
                     MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->medium();
-                    Assert(!pMedium.isNull() || pAttach->type() != DeviceType_HardDisk);
+                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
+                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
                     if (pMedium.isNull())
                         continue;
 
                     uint32_t level = 0;
-                    if (pMedium->base(&level).equalsTo(medium))
+                    if (pMedium->getBase(&level).equalsTo(medium))
                     {
                         /* matched device, channel and bus (i.e. attached to the
@@ -2597 +2601 @@
                          * descendant of medium will be used
                          */
-                        if (    (*it)->device() == aDevice
-                             && (*it)->port() == aControllerPort
-                             && (*it)->controllerName() == aControllerName
+                        if (    (*it)->getDevice() == aDevice
+                             && (*it)->getPort() == aControllerPort
+                             && (*it)->getControllerName() == aControllerName
                            )
                         {
@@ -2617 +2621 @@
                 if (foundIt != snapAtts.end())
                 {
-                    base = (*foundIt)->medium();
+                    base = (*foundIt)->getMedium();
                     break;
                 }
@@ -2726 +2730 @@
                         aDevice, aControllerPort, aControllerName);
 
-    ComObjPtr<Medium> oldmedium = pAttach->medium();
-    DeviceType_T mediumType = pAttach->type();
+    ComObjPtr<Medium> oldmedium = pAttach->getMedium();
+    DeviceType_T mediumType = pAttach->getType();
 
     if (pAttach->isImplicit())
@@ -2806 +2810 @@
     AutoWriteLock attLock(pAttach);
 
-    if (pAttach->type() != DeviceType_DVD)
+    if (pAttach->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"),
@@ -2845 +2849 @@
      * backup is not necessarily the same thing. */
     ComObjPtr<Medium> oldmedium;
-    oldmedium = pAttach->medium();
-
-    Guid id(aId);
+    oldmedium = pAttach->getMedium();
+
+    Guid uuid(aId);
     ComObjPtr<Medium> medium;
-    DeviceType_T mediumType = pAttach->type();
+    DeviceType_T mediumType = pAttach->getType();
     switch (mediumType)
     {
         case DeviceType_DVD:
-            if (!id.isEmpty())
+            if (!uuid.isEmpty())
             {
                 /* find a DVD by host device UUID */
@@ -2864 +2868 @@
                         /// @todo eliminate this conversion
                         ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                        if (id == med->id())
+                        if (uuid == med->getId())
                         {
                             medium = med;
@@ -2873 +2877 @@
                 /* find a DVD by UUID */
                 if (medium.isNull())
-                    rc = mParent->findDVDImage(&id, NULL, true /* aDoSetError */, &medium);
+                    rc = mParent->findDVDImage(&uuid, NULL, true /* aDoSetError */, &medium);
             }
             CheckComRCReturnRC(rc);
             break;
         case DeviceType_Floppy:
-            if (!id.isEmpty())
+            if (!uuid.isEmpty())
             {
                 /* find a Floppy by host device UUID */
@@ -2889 +2893 @@
                         /// @todo eliminate this conversion
                         ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                        if (id == med->id())
+                        if (uuid == med->getId())
                         {
                             medium = med;
@@ -2898 +2902 @@
                 /* find a Floppy by UUID */
                 if (medium.isNull())
-                    rc = mParent->findFloppyImage(&id, NULL, true /* aDoSetError */, &medium);
+                    rc = mParent->findFloppyImage(&uuid, NULL, true /* aDoSetError */, &medium);
             }
             CheckComRCReturnRC(rc);
@@ -2980 +2984 @@
                         aDevice, aControllerPort, aControllerName);
 
-    pAttach->medium().queryInterfaceTo(aMedium);
+    pAttach->getMedium().queryInterfaceTo(aMedium);
 
     return S_OK;
@@ -3287 +3291 @@
     AutoReadLock alock(this);
 
-    Guid id(aId);
+    Guid uuid(aId);
     ComObjPtr<Snapshot> snapshot;
 
-    HRESULT rc = findSnapshot (id, snapshot, true /* aSetError */);
+    HRESULT rc = findSnapshot(uuid, snapshot, true /* aSetError */);
     snapshot.queryInterfaceTo(aSnapshot);
 
@@ -3343 +3347 @@
 
     sharedFolder.createObject();
-    rc = sharedFolder->init (machine(), aName, aHostPath, aWritable);
+    rc = sharedFolder->init(getMachine(), aName, aHostPath, aWritable);
     CheckComRCReturnRC(rc);
 
@@ -3917 +3921 @@
          ++it)
     {
-        if ((*it)->controllerName() == aName)
+        if ((*it)->getControllerName() == aName)
             return setError(VBOX_E_OBJECT_IN_USE,
                             tr("Storage controller named '%ls' has still devices attached"),
@@ -3967 +3971 @@
             {
                 uint32_t cBlocks;
-                int rc = SSMR3GetU32(pSSM, &cBlocks);
+                rc = SSMR3GetU32(pSSM, &cBlocks);
                 AssertRCReturn(rc, rc);
 
@@ -4656 +4660 @@
     }
 
-    Bstr type (aType);
+    Utf8Str strType(aType);
 
     /* Qt is default */
 #ifdef VBOX_WITH_QTGUI
-    if (type == "gui" || type == "GUI/Qt")
+    if (strType == "gui" || strType == "GUI/Qt")
     {
 # ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
@@ -4674 +4678 @@
         const char * args[] = {szPath, "--startvm", idStr.c_str(), 0 };
 # else
-        Utf8Str name = mUserData->mName;
-        const char * args[] = {szPath, "--comment", name.c_str(), "--startvm", idStr.c_str(), 0 };
+        Utf8Str strName = mUserData->mName;
+        const char * args[] = {szPath, "--comment", strName.c_str(), "--startvm", idStr.c_str(), 0 };
 # endif
         vrc = RTProcCreate(szPath, args, env, 0, &pid);
@@ -4687 +4691 @@
 
 #ifdef VBOX_WITH_VBOXSDL
-    if (type == "sdl" || type == "GUI/SDL")
+    if (strType == "sdl" || strType == "GUI/SDL")
     {
         const char VBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
@@ -4697 +4701 @@
         const char * args[] = {szPath, "--startvm", idStr.c_str(), 0 };
 # else
-        Utf8Str name = mUserData->mName;
-        const char * args[] = {szPath, "--comment", name.c_str(), "--startvm", idStr.c_str(), 0 };
+        Utf8Str strName = mUserData->mName;
+        const char * args[] = {szPath, "--comment", strName.c_str(), "--startvm", idStr.c_str(), 0 };
 # endif
         vrc = RTProcCreate(szPath, args, env, 0, &pid);
@@ -4710 +4714 @@
 
 #ifdef VBOX_WITH_HEADLESS
-    if (   type == "headless"
-        || type == "capture"
+    if (   strType == "headless"
+        || strType == "capture"
 #ifdef VBOX_WITH_VRDP
-        || type == "vrdp"
+        || strType == "vrdp"
 #endif
        )
@@ -4726 +4730 @@
         const char * args[] = {szPath, "--startvm", idStr.c_str(), 0, 0, 0 };
 # else
-        Utf8Str name = mUserData->mName;
-        const char * args[] ={szPath, "--comment", name.c_str(), "--startvm", idStr.c_str(), 0, 0, 0 };
+        Utf8Str strName = mUserData->mName;
+        const char * args[] ={szPath, "--comment", strName.c_str(), "--startvm", idStr.c_str(), 0, 0, 0 };
 # endif
 #ifdef VBOX_WITH_VRDP
-        if (type == "headless")
+        if (strType == "headless")
         {
             unsigned pos = RT_ELEMENTS(args) - 3;
@@ -4737 +4741 @@
         }
 #endif
-        if (type == "capture")
+        if (strType == "capture")
         {
             unsigned pos = RT_ELEMENTS(args) - 3;
@@ -4751 +4755 @@
     {
         RTEnvDestroy (env);
-        return setError (E_INVALIDARG,
-            tr ("Invalid session type: '%ls'"), aType);
+        return setError(E_INVALIDARG,
+                        tr("Invalid session type: '%s'"),
+                        strType.c_str());
     }
 
@@ -4758 +4763 @@
 
     if (RT_FAILURE(vrc))
-        return setError (VBOX_E_IPRT_ERROR,
-            tr ("Could not launch a process for the machine '%ls' (%Rrc)"),
-            mUserData->mName.raw(), vrc);
+        return setError(VBOX_E_IPRT_ERROR,
+                        tr("Could not launch a process for the machine '%ls' (%Rrc)"),
+                        mUserData->mName.raw(), vrc);
 
     LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
@@ -4793 +4798 @@
     mData->mSession.mPid = pid;
     mData->mSession.mState = SessionState_Spawning;
-    mData->mSession.mType = type;
+    mData->mSession.mType = strType;
 
     LogFlowThisFuncLeave();
@@ -5040 +5045 @@
         rc = setError(E_FAIL,
                       tr("Virtual machine '%ls' has terminated unexpectedly during startup"),
-                      name().raw());
+                      getName().raw());
 #endif
 
@@ -5520 +5525 @@
              ++it)
         {
-            ComObjPtr<Medium> hd = (*it)->medium();
+            ComObjPtr<Medium> hd = (*it)->getMedium();
             if (hd.isNull())
                 continue;
-            HRESULT rc = hd->detachFrom(mData->mUuid, snapshotId());
+            HRESULT rc = hd->detachFrom(mData->mUuid, getSnapshotId());
             AssertComRC (rc);
         }
@@ -5647 +5652 @@
     {
         AutoWriteLock alock(*it);
-        found = (*it)->name() == aName;
+        found = (*it)->getName() == aName;
         if (found)
             aSharedFolder = *it;
@@ -6220 +6225 @@
                             /// @todo eliminate this conversion
                             ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                            if (    dev.strHostDriveSrc == med->name()
-                                ||  dev.strHostDriveSrc == med->location())
+                            if (    dev.strHostDriveSrc == med->getName()
+                                ||  dev.strHostDriveSrc == med->getLocation())
                             {
                                 medium = med;
@@ -6247 +6252 @@
                             /// @todo eliminate this conversion
                             ComObjPtr<Medium> med = (Medium *)drivevec[i];
-                            if (    hostDriveSrc == med->name()
-                                ||  hostDriveSrc == med->location())
+                            if (    hostDriveSrc == med->getName()
+                                ||  hostDriveSrc == med->getLocation())
                             {
                                 medium = med;
@@ -6280 +6285 @@
                 AutoWriteLock hdLock(medium);
 
-                if (medium->type() == MediumType_Immutable)
+                if (medium->getType() == MediumType_Immutable)
                 {
                     if (mType == IsSnapshotMachine)
@@ -6286 +6291 @@
                                         tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
                                            "of the virtual machine '%ls' ('%s')"),
-                                        medium->locationFull().raw(),
+                                        medium->getLocationFull().raw(),
                                         dev.uuid.raw(),
                                         aSnapshotId->raw(),
@@ -6294 +6299 @@
                     return setError(E_FAIL,
                                     tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%ls' ('%s')"),
-                                    medium->locationFull().raw(),
+                                    medium->getLocationFull().raw(),
                                     dev.uuid.raw(),
                                     mUserData->mName.raw(),
@@ -6301 +6306 @@
 
                 if (    mType != IsSnapshotMachine
-                     && medium->children().size() != 0
+                     && medium->getChildren().size() != 0
                    )
                     return setError(E_FAIL,
                                     tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%ls' ('%s') "
                                        "because it has %d differencing child hard disks"),
-                                    medium->locationFull().raw(),
+                                    medium->getLocationFull().raw(),
                                     dev.uuid.raw(),
                                     mUserData->mName.raw(),
                                     mData->m_strConfigFileFull.raw(),
-                                    medium->children().size());
+                                    medium->getChildren().size());
 
                 if (findAttachment(mMediaData->mAttachments,
@@ -6316 +6321 @@
                     return setError(E_FAIL,
                                     tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%ls' ('%s')"),
-                                    medium->locationFull().raw(),
+                                    medium->getLocationFull().raw(),
                                     dev.uuid.raw(),
                                     mUserData->mName.raw(),
@@ -6327 +6332 @@
                 return setError(E_FAIL,
                                 tr("Device with unknown type is attached to the virtual machine '%s' ('%s')"),
-                                medium->locationFull().raw(),
+                                medium->getLocationFull().raw(),
                                 mUserData->mName.raw(),
                                 mData->m_strConfigFileFull.raw());
@@ -6484 +6489 @@
          ++it)
     {
-        if ((*it)->controllerName() == aName)
+        if ((*it)->getControllerName() == aName)
             atts.push_back(*it);
     }
@@ -7029 +7034 @@
             ComObjPtr<SharedFolder> pFolder = *it;
             settings::SharedFolder sf;
-            sf.strName = pFolder->name();
-            sf.strHostPath = pFolder->hostPath();
-            sf.fWritable = !!pFolder->writable();
+            sf.strName = pFolder->getName();
+            sf.strHostPath = pFolder->getHostPath();
+            sf.fWritable = !!pFolder->isWritable();
 
             data.llSharedFolders.push_back(sf);
@@ -7143 +7148 @@
 
         MediumAttachment *pAttach = *it;
-        Medium *pMedium = pAttach->medium();
-
-        dev.deviceType = pAttach->type();
-        dev.lPort = pAttach->port();
-        dev.lDevice = pAttach->device();
+        Medium *pMedium = pAttach->getMedium();
+
+        dev.deviceType = pAttach->getType();
+        dev.lPort = pAttach->getPort();
+        dev.lDevice = pAttach->getDevice();
         if (pMedium)
         {
@@ -7155 +7160 @@
                 return rc;
             if (fHostDrive)
-                dev.strHostDriveSrc = pMedium->location();
+                dev.strHostDriveSrc = pMedium->getLocation();
             else
-                dev.uuid = pMedium->id();
-            dev.fPassThrough = pAttach->passthrough();
+                dev.uuid = pMedium->getId();
+            dev.fPassThrough = pAttach->getPassthrough();
         }
 
@@ -7294 +7299 @@
             {
                 MediumAttachment* pAtt = *it;
-                if (pAtt->type() == DeviceType_HardDisk)
+                if (pAtt->getType() == DeviceType_HardDisk)
                 {
-                    Medium* pHD = pAtt->medium();
+                    Medium* pHD = pAtt->getMedium();
                     Assert(pHD);
                     rc = pHD->LockRead (NULL);
@@ -7320 +7325 @@
             MediumAttachment* pAtt = *it;
 
-            DeviceType_T devType = pAtt->type();
-            Medium* medium = pAtt->medium();
+            DeviceType_T devType = pAtt->getType();
+            Medium* medium = pAtt->getMedium();
 
             if (   devType != DeviceType_HardDisk
                 || medium == NULL
-                || medium->type() != MediumType_Normal)
+                || medium->getType() != MediumType_Normal)
             {
                 /* copy the attachment as is */
@@ -7339 +7344 @@
                     else
                         aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
-                                                            medium->base()->name().raw()),
+                                                            medium->getBase()->getName().raw()),
                                                     aWeight);        // weight
                 }
@@ -7349 +7354 @@
             /* need a diff */
             aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
-                                                medium->base()->name().raw()),
+                                                medium->getBase()->getName().raw()),
                                         aWeight);        // weight
 
@@ -7395 +7400 @@
             rc = attachment->init(this,
                                   diff,
-                                  pAtt->controllerName(),
-                                  pAtt->port(),
-                                  pAtt->device(),
+                                  pAtt->getControllerName(),
+                                  pAtt->getPort(),
+                                  pAtt->getDevice(),
                                   DeviceType_HardDisk,
                                   true /* aImplicit */);
@@ -7461 +7466 @@
          ++it)
     {
-        ComObjPtr<Medium> hd = (*it)->medium();
+        ComObjPtr<Medium> hd = (*it)->getMedium();
         if (hd.isNull())
             continue;
@@ -7468 +7473 @@
         {
             /* deassociate and mark for deletion */
-            LogFlowThisFunc(("Detaching '%s', pending deletion\n", (*it)->logName()));
+            LogFlowThisFunc(("Detaching '%s', pending deletion\n", (*it)->getLogName()));
             rc = hd->detachFrom(mData->mUuid);
             AssertComRC(rc);
@@ -7479 +7484 @@
         {
             /* no: de-associate */
-            LogFlowThisFunc(("Detaching '%s', no deletion\n", (*it)->logName()));
+            LogFlowThisFunc(("Detaching '%s', no deletion\n", (*it)->getLogName()));
             rc = hd->detachFrom(mData->mUuid);
             AssertComRC(rc);
             continue;
         }
-        LogFlowThisFunc(("Not detaching '%s'\n", (*it)->logName()));
+        LogFlowThisFunc(("Not detaching '%s'\n", (*it)->getLogName()));
     }
 
@@ -7512 +7517 @@
              ++it)
         {
-            LogFlowThisFunc(("Deleting '%s'\n", (*it)->logName()));
-            ComObjPtr<Medium> hd = (*it)->medium();
+            LogFlowThisFunc(("Deleting '%s'\n", (*it)->getLogName()));
+            ComObjPtr<Medium> hd = (*it)->getMedium();
 
             rc = hd->deleteStorageAndWait();
@@ -7519 +7524 @@
             if (rc == VBOX_E_INVALID_OBJECT_STATE)
             {
-                LogFlowFunc(("Applying unlock hack on '%s'! FIXME!\n", (*it)->logName()));
+                LogFlowFunc(("Applying unlock hack on '%s'! FIXME!\n", (*it)->getLogName()));
                 hd->UnlockWrite(NULL);
                 rc = hd->deleteStorageAndWait();
             }
 #endif
-            AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, (*it)->logName(), hd->locationFull().c_str() ));
+            AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, (*it)->getLogName(), hd->getLocationFull().c_str() ));
             mrc = rc;
         }
@@ -7586 +7591 @@
     {
         MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->medium();
+        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
         if (pMediumThis.equalsTo(pMedium))
             return pAttach;
@@ -7613 +7618 @@
     {
         MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->medium();
-        if (pMediumThis->id() == id)
+        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
+        if (pMediumThis->getId() == id)
             return pAttach;
     }
@@ -7669 +7674 @@
             pAttach->commit();
 
-            Medium* pMedium = pAttach->medium();
+            Medium* pMedium = pAttach->getMedium();
             bool fImplicit = pAttach->isImplicit();
 
             LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
-                             (pMedium) ? pMedium->name().raw() : "NULL",
+                             (pMedium) ? pMedium->getName().raw() : "NULL",
                              fImplicit));
 
@@ -7685 +7690 @@
                 if (    aOnline
                      && pMedium
-                     && pAttach->type() == DeviceType_HardDisk
+                     && pAttach->getType() == DeviceType_HardDisk
                    )
                 {
@@ -7698 +7703 @@
                     * new diff for reading if the VM is online */
 
-                    ComObjPtr<Medium> parent = pMedium->parent();
+                    ComObjPtr<Medium> parent = pMedium->getParent();
                     /* make the relock atomic */
                     AutoWriteLock parentLock (parent);
@@ -7726 +7731 @@
                 {
                     MediumAttachment *pOldAttach = *oldIt;
-                    if (pOldAttach->medium().equalsTo(pMedium))
+                    if (pOldAttach->getMedium().equalsTo(pMedium))
                     {
-                        LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->name().raw()));
+                        LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->getName().raw()));
 
                         /* yes: remove from old to avoid de-association */
@@ -7745 +7750 @@
         {
             MediumAttachment *pAttach = *it;
-            Medium* pMedium = pAttach->medium();
+            Medium* pMedium = pAttach->getMedium();
 
             /* Detach only hard disks, since DVD/floppy media is detached
              * instantly in MountMedium. */
-            if (pAttach->type() == DeviceType_HardDisk && pMedium)
+            if (pAttach->getType() == DeviceType_HardDisk && pMedium)
             {
-                LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->name().raw()));
+                LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->getName().raw()));
 
                 /* now de-associate from the current machine state */
@@ -7758 +7763 @@
 
                 if (    aOnline
-                     && pAttach->type() == DeviceType_HardDisk)
+                     && pAttach->getType() == DeviceType_HardDisk)
                 {
                     /* unlock since not used anymore */
@@ -7787 +7792 @@
             MediumAttachment *pAttach = *it;
             /* Fix up the backrefs for DVD/floppy media. */
-            if (pAttach->type() != DeviceType_HardDisk)
+            if (pAttach->getType() != DeviceType_HardDisk)
             {
-                Medium* pMedium = pAttach->medium();
+                Medium* pMedium = pAttach->getMedium();
                 if (pMedium)
                 {
@@ -7801 +7806 @@
             pAttach = *it;
             /* Fix up the backrefs for DVD/floppy media. */
-            if (pAttach->type() != DeviceType_HardDisk)
+            if (pAttach->getType() != DeviceType_HardDisk)
             {
-                Medium* pMedium = pAttach->medium();
+                Medium* pMedium = pAttach->getMedium();
                 if (pMedium)
                 {
@@ -7991 +7996 @@
                      ++cit)
                 {
-                    if ((*cit)->name() != (*rit)->name() ||
-                        (*cit)->hostPath() != (*rit)->hostPath())
+                    if ((*cit)->getName() != (*rit)->getName() ||
+                        (*cit)->getHostPath() != (*rit)->getHostPath())
                     {
                         sharedFoldersChanged = true;
@@ -8263 +8268 @@
         ComObjPtr<SharedFolder> folder;
         folder.createObject();
-        HRESULT rc = folder->initCopy (machine(), *it);
+        HRESULT rc = folder->initCopy(getMachine(), *it);
         AssertComRC (rc);
         *it = folder;
@@ -9882 +9887 @@
              ++it)
         {
-            DeviceType_T devType = (*it)->type();
-            ComObjPtr<Medium> medium = (*it)->medium();
+            DeviceType_T devType = (*it)->getType();
+            ComObjPtr<Medium> medium = (*it)->getMedium();
 
             bool first = true;
@@ -9891 +9896 @@
             while (!medium.isNull())
             {
-                MediumState_T mediumState = medium->state();
+                MediumState_T mediumState = medium->getState();
 
                 /* accessibility check must be first, otherwise locking
@@ -9959 +9964 @@
                  * change the hard disk parent at this point (as it is still
                  * attached to the machine) */
-                medium = medium->parent();
+                medium = medium->getParent();
             }
         }

trunk/src/VBox/Main/MediumAttachmentImpl.cpp

@@ -99 +99 @@
                           aImplicit ? ":I" : "");
 
-    LogFlowThisFunc(("LEAVE - %s\n", logName()));
+    LogFlowThisFunc(("LEAVE - %s\n", getLogName()));
     return S_OK;
 }
@@ -109 +109 @@
 void MediumAttachment::uninit()
 {
-    LogFlowThisFunc(("ENTER - %s\n", logName()));
+    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
 
     /* Enclose the state transition Ready->InUninit->NotReady */
@@ -128 +128 @@
 bool MediumAttachment::rollback()
 {
-    LogFlowThisFunc(("ENTER - %s\n", logName()));
+    LogFlowThisFunc(("ENTER - %s\n", getLogName()));
 
     /* sanity */
@@ -146 +146 @@
     }
 
-    LogFlowThisFunc(("LEAVE - %s - returning %RTbool\n", logName(), changed));
+    LogFlowThisFunc(("LEAVE - %s - returning %RTbool\n", getLogName(), changed));
     return changed;
 }

trunk/src/VBox/Main/MediumImpl.cpp

@@ -179 +179 @@
 struct Medium::Task : public com::SupportErrorInfoBase
 {
-    enum Operation { CreateBase, CreateDiff,
-                     Merge, Clone, Delete, Reset, Compact };
+    enum Operation { CreateBase,
+                     CreateDiff,
+                     Merge,
+                     Clone,
+                     Delete,
+                     Reset,
+                     Compact
+                   };
 
     Medium *that;
-    VirtualBoxBaseProto::AutoCaller autoCaller;
-
-    ComObjPtr <Progress> progress;
-    Operation operation;
+    VirtualBoxBaseProto::AutoCaller m_autoCaller;
+
+    ComObjPtr<Progress> m_pProgress;
+    Operation m_operation;
 
     /** Where to save the result when executed using #runNow(). */
-    HRESULT rc;
-
-    Task(Medium *aThat, Progress *aProgress, Operation aOperation)
-        : that(aThat), autoCaller(aThat)
-        , progress(aProgress)
-        , operation(aOperation)
-        , rc(S_OK) {}
+    HRESULT m_rc;
+
+    Task(Medium *aThat,
+         Progress *aProgress,
+         Operation aOperation)
+        : that(aThat),
+          m_autoCaller(aThat),
+          m_pProgress(aProgress),
+          m_operation(aOperation),
+          m_rc(S_OK)
+    {}
 
     ~Task();
@@ -341 +351 @@
     Medium::taskThread(NIL_RTTHREAD, this);
 
-    return rc;
+    return m_rc;
 }
 
@@ -354 +364 @@
  *
  * @note It is assumed that when modifying methods of this class are called,
- *       Medium::treeLock() is held in read mode.
+ *       Medium::getTreeLock() is held in read mode.
  */
 class Medium::MergeChain : public Medium::List,
@@ -441 +451 @@
         {
             /* we will need to reparent children */
-            for (List::const_iterator it = aMedium->children().begin();
-                 it != aMedium->children().end(); ++ it)
+            for (List::const_iterator it = aMedium->getChildren().begin();
+                 it != aMedium->getChildren().end();
+                 ++it)
             {
-                rc = (*it)->addCaller();
+                ComObjPtr<Medium> pMedium = *it;
+                rc = pMedium->addCaller();
                 CheckComRCReturnRC(rc);
 
-                rc = (*it)->LockWrite(NULL);
+                rc = pMedium->LockWrite(NULL);
                 if (FAILED(rc))
                 {
-                    (*it)->releaseCaller();
+                    pMedium->releaseCaller();
                     return rc;
                 }
 
-                mChildren.push_back(*it);
+                mChildren.push_back(pMedium);
             }
         }
@@ -545 +557 @@
         {
             /* not going to multi-merge as it's too expensive */
-            if (aMedium->children().size() > 1)
+            if (aMedium->getChildren().size() > 1)
             {
                 return setError(E_FAIL,
                                 tr("Medium '%s' involved in the merge operation has more than one child medium (%d)"),
                                 aMedium->m->strLocationFull.raw(),
-                                aMedium->children().size());
+                                aMedium->getChildren().size());
             }
         }
@@ -607 +619 @@
  *
  * @note It is assumed that when modifying methods of this class are called,
- *       Medium::treeLock() is held in read mode.
+ *       Medium::getTreeLock() is held in read mode.
  */
 class Medium::ImageChain : public Medium::List,
@@ -667 +679 @@
         {
             HRESULT rc = S_OK;
-            MediumState_T mediumState = (*it)->state();
+            MediumState_T mediumState = (*it)->getState();
 
             /* accessibility check must be first, otherwise locking
@@ -721 +733 @@
         {
             HRESULT rc = S_OK;
-            MediumState_T mediumState = (*it)->state();
+            MediumState_T mediumState = (*it)->getState();
 
             /* accessibility check must be first, otherwise locking
@@ -1039 +1051 @@
  * @param aNode         Configuration settings.
  *
- * @note Locks VirtualBox lock for writing, treeLock() for writing.
+ * @note Locks VirtualBox lock for writing, getTreeLock() for writing.
  */
 HRESULT Medium::init(VirtualBox *aVirtualBox,
@@ -1066 +1078 @@
     {
         /* we set mParent */
-        AutoWriteLock treeLock(this->treeLock());
+        AutoWriteLock treeLock(this->getTreeLock());
 
         mParent = aParent;
@@ -1154 +1166 @@
          it != data.llChildren.end(); ++ it)
     {
-        const settings::Medium &m = *it;
+        const settings::Medium &med = *it;
 
         ComObjPtr<Medium> pHD;
@@ -1161 +1173 @@
                        this,            // parent
                        aDeviceType,
-                       m);              // child data
+                       med);              // child data
         CheckComRCBreakRC(rc);
 
@@ -1188 +1200 @@
  * @param aDescription  Comment for this host drive.
  *
- * @note Locks VirtualBox lock for writing, treeLock() for writing.
+ * @note Locks VirtualBox lock for writing, getTreeLock() for writing.
  */
 HRESULT Medium::init(VirtualBox *aVirtualBox,
@@ -1246 +1258 @@
  *       uninit() methods.
  *
- * @note Locks treeLock() for writing, VirtualBox for writing.
+ * @note Locks getTreeLock() for writing, VirtualBox for writing.
  */
 void Medium::uninit()
@@ -1274 +1286 @@
         /* we uninit children and reset mParent
          * and VirtualBox::removeDependentChild() needs a write lock */
-        AutoMultiWriteLock2 alock(mVirtualBox->lockHandle(), this->treeLock());
+        AutoMultiWriteLock2 alock(mVirtualBox->lockHandle(), this->getTreeLock());
 
         uninitDependentChildren();
@@ -1405 +1417 @@
     AutoReadLock alock(this);
 
-    name().cloneTo(aName);
+    getName().cloneTo(aName);
 
     return S_OK;
@@ -1505 +1517 @@
 
     /* we access mParent & children() */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     /* cannot change the type of a differencing hard disk */
@@ -1532 +1544 @@
         {
             /* cannot change to writethrough if there are children */
-            if (children().size() != 0)
+            if (getChildren().size() != 0)
                 return setError(E_FAIL,
                                 tr("Cannot change type for hard disk '%s' since it has %d child hard disk(s)"),
-                                m->strLocationFull.raw(), children().size());
+                                m->strLocationFull.raw(), getChildren().size());
             break;
         }
@@ -1558 +1570 @@
 
     /* we access mParent */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     mParent.queryInterfaceTo(aParent);
@@ -1574 +1586 @@
 
     /* we access children */
-    AutoReadLock treeLock(this->treeLock());
-
-    SafeIfaceArray<IMedium> children(this->children());
+    AutoReadLock treeLock(this->getTreeLock());
+
+    SafeIfaceArray<IMedium> children(this->getChildren());
     children.detachTo(ComSafeArrayOutArg(aChildren));
 
@@ -1589 +1601 @@
     /* base() will do callers/locking */
 
-    base().queryInterfaceTo(aBase);
+    getBase().queryInterfaceTo(aBase);
 
     return S_OK;
@@ -1620 +1632 @@
 
         /* we access mParent */
-        AutoReadLock treeLock(this->treeLock());
+        AutoReadLock treeLock(this->getTreeLock());
 
         if (mParent.isNull())
@@ -1636 +1648 @@
     /* base() will do callers/locking */
 
-    return base()->COMGETTER(LogicalSize)(aLogicalSize);
+    return getBase()->COMGETTER(LogicalSize)(aLogicalSize);
 }
 
@@ -1936 +1948 @@
             m->preLockState = m->state;
 
-            LogFlowThisFunc(("Okay - prev state=%d locationFull=%s\n", m->state, locationFull().c_str()));
+            LogFlowThisFunc(("Okay - prev state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
             m->state = MediumState_LockedWrite;
             break;
@@ -1942 +1954 @@
         default:
         {
-            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, locationFull().c_str()));
+            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
             rc = setStateError();
             break;
@@ -1969 +1981 @@
         {
             m->state = m->preLockState;
-            LogFlowThisFunc(("new state=%d locationFull=%s\n", m->state, locationFull().c_str()));
+            LogFlowThisFunc(("new state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
             break;
         }
         default:
         {
-            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, locationFull().c_str()));
+            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
             rc = setError(VBOX_E_INVALID_OBJECT_STATE,
                           tr ("Medium '%s' is not locked for writing"),
@@ -2228 +2240 @@
 
     std::auto_ptr <Task> task(new Task(this, progress, Task::CreateBase));
-    AssertComRCReturnRC(task->autoCaller.rc());
+    AssertComRCReturnRC(task->m_autoCaller.rc());
 
     task->d.size = aLogicalSize;
@@ -2358 +2370 @@
 
         /* we walk the source tree */
-        AutoReadLock srcTreeLock(this->treeLock());
+        AutoReadLock srcTreeLock(this->getTreeLock());
         for (Medium *hd = this; hd; hd = hd->mParent)
         {
@@ -2373 +2385 @@
         AutoReadLock parentTreeLock;
         if (parent)
-            parentTreeLock.attach(parent->treeLock());
+            parentTreeLock.attach(parent->getTreeLock());
         for (Medium *hd = parent; hd; hd = hd->mParent)
         {
@@ -2405 +2417 @@
 
         std::auto_ptr <Task> task(new Task(this, progress, Task::Clone));
-        AssertComRCThrowRC(task->autoCaller.rc());
+        AssertComRCThrowRC(task->m_autoCaller.rc());
 
         task->setData(target, parent);
@@ -2460 +2472 @@
 
         /* we walk the image tree */
-        AutoReadLock srcTreeLock(this->treeLock());
+        AutoReadLock srcTreeLock(this->getTreeLock());
         for (Medium *hd = this; hd; hd = hd->mParent)
         {
@@ -2479 +2491 @@
 
         std::auto_ptr <Task> task(new Task(this, progress, Task::Compact));
-        AssertComRCThrowRC(task->autoCaller.rc());
+        AssertComRCThrowRC(task->m_autoCaller.rc());
 
         task->setData(imgChain.release());
@@ -2552 +2564 @@
 
         std::auto_ptr<Task> task(new Task(this, progress, Task::Reset));
-        AssertComRCThrowRC(task->autoCaller.rc());
+        AssertComRCThrowRC(task->m_autoCaller.rc());
 
         rc = task->startThread();
@@ -2794 +2806 @@
  * @return
  */
-const Guid& Medium::id() const
+const Guid& Medium::getId() const
 {
     return m->id;
@@ -2803 +2815 @@
  * @return
  */
-MediumState_T Medium::state() const
+MediumState_T Medium::getState() const
 {
     return m->state;
@@ -2812 +2824 @@
  * @return
  */
-const Utf8Str& Medium::location() const
+const Utf8Str& Medium::getLocation() const
 {
     return m->strLocation;
@@ -2821 +2833 @@
  * @return
  */
-const Utf8Str& Medium::locationFull() const
+const Utf8Str& Medium::getLocationFull() const
 {
     return m->strLocationFull;
@@ -2830 +2842 @@
  * @return
  */
-uint64_t Medium::size() const
+uint64_t Medium::getSize() const
 {
     return m->size;
@@ -2867 +2879 @@
  * @param aNewPath  New path (full).
  *
- * @note Locks treeLock() for reading, this object and all children for writing.
+ * @note Locks getTreeLock() for reading, this object and all children for writing.
  */
 void Medium::updatePaths(const char *aOldPath, const char *aNewPath)
@@ -2880 +2892 @@
 
     /* we access children() */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     updatePath(aOldPath, aNewPath);
 
     /* update paths of all children */
-    for (List::const_iterator it = children().begin();
-         it != children().end();
+    for (List::const_iterator it = getChildren().begin();
+         it != getChildren().end();
          ++ it)
     {
@@ -2903 +2915 @@
  *                  (zero for the base), may be @c NULL.
  *
- * @note Locks treeLock() for reading.
+ * @note Locks getTreeLock() for reading.
  */
-ComObjPtr<Medium> Medium::base(uint32_t *aLevel /*= NULL*/)
-{
-    ComObjPtr <Medium> base;
+ComObjPtr<Medium> Medium::getBase(uint32_t *aLevel /*= NULL*/)
+{
+    ComObjPtr<Medium> pBase;
     uint32_t level;
 
     AutoCaller autoCaller(this);
-    AssertReturn(autoCaller.isOk(), base);
+    AssertReturn(autoCaller.isOk(), pBase);
 
     /* we access mParent */
-    AutoReadLock treeLock(this->treeLock());
-
-    base = this;
+    AutoReadLock treeLock(this->getTreeLock());
+
+    pBase = this;
     level = 0;
 
@@ -2923 +2935 @@
         for (;;)
         {
-            AutoCaller baseCaller(base);
-            AssertReturn(baseCaller.isOk(), base);
-
-            if (base->mParent.isNull())
+            AutoCaller baseCaller(pBase);
+            AssertReturn(baseCaller.isOk(), pBase);
+
+            if (pBase->mParent.isNull())
                 break;
 
-            base = base->mParent;
-            ++ level;
+            pBase = pBase->mParent;
+            ++level;
         }
     }
@@ -2937 +2949 @@
         *aLevel = level;
 
-    return base;
+    return pBase;
 }
 
@@ -2945 +2957 @@
  * type and posterity, not to the current media state.
  *
- * @note Locks this object and treeLock() for reading.
+ * @note Locks this object and getTreeLock() for reading.
  */
 bool Medium::isReadOnly()
@@ -2955 +2967 @@
 
     /* we access children */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     switch (m->type)
@@ -2961 +2973 @@
         case MediumType_Normal:
         {
-            if (children().size() != 0)
+            if (getChildren().size() != 0)
                 return true;
 
@@ -2992 +3004 @@
  * @param data      Settings struct to be updated.
  *
- * @note Locks this object, treeLock() and children for reading.
+ * @note Locks this object, getTreeLock() and children for reading.
  */
 HRESULT Medium::saveSettings(settings::Medium &data)
@@ -3002 +3014 @@
 
     /* we access mParent */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     data.uuid = m->id;
@@ -3037 +3049 @@
 
     /* save all children */
-    for (List::const_iterator it = children().begin();
-         it != children().end();
+    for (List::const_iterator it = getChildren().begin();
+         it != getChildren().end();
          ++it)
     {
-        settings::Medium m;
-        HRESULT rc = (*it)->saveSettings(m);
+        settings::Medium med;
+        HRESULT rc = (*it)->saveSettings(med);
         AssertComRCReturnRC(rc);
-        data.llChildren.push_back(m);
+        data.llChildren.push_back(med);
     }
 
@@ -3116 +3128 @@
  *                      if no real merge is necessary).
  *
- * @note Locks treeLock() for reading. Locks this object, aTarget and all
+ * @note Locks getTreeLock() for reading. Locks this object, aTarget and all
  *       intermediate hard disks for writing.
  */
@@ -3129 +3141 @@
 
     /* we access mParent & children() */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     AssertReturn(m->type == MediumType_Normal, E_FAIL);
 
-    if (children().size() == 0)
+    if (getChildren().size() == 0)
     {
         /* special treatment of the last hard disk in the chain: */
@@ -3161 +3173 @@
 
     /* not going multi-merge as it's too expensive */
-    if (children().size() > 1)
+    if (getChildren().size() > 1)
         return setError(E_FAIL,
                         tr ("Hard disk '%s' has more than one child hard disk (%d)"),
-                        m->strLocationFull.raw(), children().size());
+                        m->strLocationFull.raw(), getChildren().size());
 
     /* this is a read-only hard disk with children; it must be associated with
@@ -3175 +3187 @@
     AssertReturn(m->backRefs.front().llSnapshotIds.size() == 1, E_FAIL);
 
-    ComObjPtr<Medium> child = children().front();
+    ComObjPtr<Medium> child = getChildren().front();
 
     /* we keep this locked, so lock the affected child to make sure the lock
@@ -3244 +3256 @@
  *
  * @note Locks the hard disks from the chain for writing. Locks the machine
- *       object when the backward merge takes place. Locks treeLock() lock for
+ *       object when the backward merge takes place. Locks getTreeLock() lock for
  *       reading or writing.
  */
@@ -3259 +3271 @@
         AssertComRCReturnRC(autoCaller.rc());
 
-        aProgress->SetNextOperation(BstrFmt(tr("Discarding hard disk '%s'"), name().raw()),
+        aProgress->SetNextOperation(BstrFmt(tr("Discarding hard disk '%s'"), getName().raw()),
                                     ulWeight);        // weight
 
@@ -3267 +3279 @@
 
             /* we access mParent & children() */
-            AutoReadLock treeLock(this->treeLock());
-
-            Assert(children().size() == 0);
+            AutoReadLock treeLock(this->getTreeLock());
+
+            Assert(getChildren().size() == 0);
 
             /* special treatment of the last hard disk in the chain: */
@@ -3322 +3334 @@
  *                      no real merge takes place).
  *
- * @note Locks the hard disks from the chain for writing. Locks treeLock() for
+ * @note Locks the hard disks from the chain for writing. Locks getTreeLock() for
  *       reading.
  */
@@ -3335 +3347 @@
 
         /* we access mParent & children() */
-        AutoReadLock treeLock(this->treeLock());
-
-        Assert(children().size() == 0);
+        AutoReadLock treeLock(this->getTreeLock());
+
+        Assert(getChildren().size() == 0);
 
         /* special treatment of the last hard disk in the chain: */
@@ -3389 +3401 @@
  * @return
  */
-MediumType_T Medium::type() const
+MediumType_T Medium::getType() const
 {
     return m->type;
@@ -3406 +3418 @@
  *    object lock.
  */
-RWLockHandle* Medium::treeLock()
+RWLockHandle* Medium::getTreeLock()
 {
     return &mVirtualBox->hardDiskTreeLockHandle();
@@ -3419 +3431 @@
  * @note Must be called from under this object's read or write lock.
  */
-Utf8Str Medium::name()
-{
-    Utf8Str location(m->strLocationFull);
-
-    Utf8Str name = RTPathFilename(location.c_str());
+Utf8Str Medium::getName()
+{
+    Utf8Str name = RTPathFilename(m->strLocationFull.c_str());
     return name;
 }
@@ -3612 +3622 @@
  *       accessibility.
  *
- * @note Locks treeLock() for reading and writing (for new diff media checked
+ * @note Locks getTreeLock() for reading and writing (for new diff media checked
  *       for the first time). Locks mParent for reading. Locks this object for
  *       writing.
@@ -3824 +3834 @@
 
                     /* we set mParent & children() */
-                    AutoWriteLock treeLock(this->treeLock());
+                    AutoWriteLock treeLock(this->getTreeLock());
 
                     Assert(mParent.isNull());
@@ -3833 +3843 @@
                 {
                     /* we access mParent */
-                    AutoReadLock treeLock(this->treeLock());
+                    AutoReadLock treeLock(this->getTreeLock());
 
                     /* check that parent UUIDs match. Note that there's no need
@@ -3849 +3859 @@
 
                     AutoReadLock parentLock(mParent);
-                    if (mParent->state() != MediumState_Inaccessible &&
-                        mParent->id() != parentId)
+                    if (    mParent->getState() != MediumState_Inaccessible
+                         && mParent->getId() != parentId)
                     {
                         lastAccessError = Utf8StrFmt(
                             tr ("Parent UUID {%RTuuid} of the hard disk '%s' does not match UUID {%RTuuid} of its parent hard disk stored in the media registry ('%s')"),
                             &parentId, location.c_str(),
-                            mParent->id().raw(),
+                            mParent->getId().raw(),
                             mVirtualBox->settingsFilePath().c_str());
                         throw S_OK;
@@ -4017 +4027 @@
  *                      an asynchronous thread.
  *
- * @note Locks mVirtualBox and this object for writing. Locks treeLock() for
+ * @note Locks mVirtualBox and this object for writing. Locks getTreeLock() for
  *       writing.
  */
@@ -4031 +4041 @@
 
     AutoMultiWriteLock2 alock(mVirtualBox->lockHandle(), this->lockHandle());
-    LogFlowThisFunc(("aWait=%RTbool locationFull=%s\n", aWait, locationFull().c_str() ));
+    LogFlowThisFunc(("aWait=%RTbool locationFull=%s\n", aWait, getLocationFull().c_str() ));
 
     if (    !(m->formatObj->capabilities() & (   MediumFormatCapabilities_CreateDynamic
@@ -4084 +4094 @@
 
     /* we need to leave this object's write lock now because of
-     * unregisterWithVirtualBox() that locks treeLock() for writing */
+     * unregisterWithVirtualBox() that locks getTreeLock() for writing */
     alock.leave();
 
@@ -4121 +4131 @@
 
     std::auto_ptr <Task> task(new Task(this, progress, Task::Delete));
-    AssertComRCReturnRC(task->autoCaller.rc());
+    AssertComRCReturnRC(task->m_autoCaller.rc());
 
     if (aWait)
@@ -4262 +4272 @@
 
     std::auto_ptr <Task> task(new Task(this, progress, Task::CreateDiff));
-    AssertComRCReturnRC(task->autoCaller.rc());
+    AssertComRCReturnRC(task->m_autoCaller.rc());
 
     task->setData(aTarget);
@@ -4319 +4329 @@
  *                              hard disk is attached to any VM.
  *
- * @note Locks treeLock() for reading. Locks this object, aTarget and all
+ * @note Locks getTreeLock() for reading. Locks this object, aTarget and all
  *       intermediate hard disks for writing.
  */
@@ -4337 +4347 @@
 
     /* we walk the tree */
-    AutoReadLock treeLock(this->treeLock());
+    AutoReadLock treeLock(this->getTreeLock());
 
     HRESULT rc = S_OK;
@@ -4361 +4371 @@
                 {
                     AutoReadLock alock(this);
-                    tgtLoc = aTarget->locationFull();
+                    tgtLoc = aTarget->getLocationFull();
                 }
 
@@ -4498 +4508 @@
             rc = progress->init(mVirtualBox, static_cast<IMedium*>(this),
                 BstrFmt(tr("Merging hard disk '%s' to '%s'"),
-                         name().raw(), aChain->target()->name().raw()),
+                        getName().raw(),
+                        aChain->target()->getName().raw()),
                 TRUE /* aCancelable */);
             CheckComRCReturnRC(rc);
@@ -4508 +4519 @@
 
     std::auto_ptr <Task> task(new Task(this, progress, Task::Merge));
-    AssertComRCReturnRC(task->autoCaller.rc());
+    AssertComRCReturnRC(task->m_autoCaller.rc());
 
     task->setData(aChain);
@@ -4610 +4621 @@
  * @note Also reused by Medium::Reset().
  *
- * @note Locks treeLock() for reading.
+ * @note Locks getTreeLock() for reading.
  */
 HRESULT Medium::canClose()
 {
     /* we access children */
-    AutoReadLock treeLock(this->treeLock());
-
-    if (children().size() != 0)
+    AutoReadLock treeLock(this->getTreeLock());
+
+    if (getChildren().size() != 0)
         return setError(E_FAIL,
                         tr("Cannot close medium '%s' because it has %d child hard disk(s)"),
-                        m->strLocationFull.raw(), children().size());
+                        m->strLocationFull.raw(), getChildren().size());
 
     return S_OK;
@@ -4629 +4640 @@
  *       from under mVirtualBox write lock.
  *
- * @note Locks treeLock() for writing.
+ * @note Locks getTreeLock() for writing.
  */
 HRESULT Medium::unregisterWithVirtualBox()
@@ -4637 +4648 @@
 
     /* we modify mParent and access children */
-    AutoWriteLock treeLock(this->treeLock());
+    AutoWriteLock treeLock(this->getTreeLock());
 
     const ComObjPtr<Medium, ComWeakRef> parent = mParent;
 
-    AssertReturn(children().size() == 0, E_FAIL);
+    AssertReturn(getChildren().size() == 0, E_FAIL);
 
     if (!mParent.isNull())
@@ -4867 +4878 @@
     VDINTERFACE vdIfProgress;
     PVDINTERFACE vdOperationIfaces = NULL;
-    int vrc = VDInterfaceAdd(&vdIfProgress,
+    int vrc1 = VDInterfaceAdd(&vdIfProgress,
                              "Medium::vdInterfaceProgress",
                              VDINTERFACETYPE_PROGRESS,
-                             &vdIfCallsProgress, task->progress, &vdOperationIfaces);
-    AssertRCReturn(vrc, E_FAIL);
+                             &vdIfCallsProgress,
+                             task->m_pProgress,
+                             &vdOperationIfaces);
+    AssertRCReturn(vrc1, E_FAIL);
 
     /// @todo ugly hack, fix ComAssert... later
@@ -4879 +4892 @@
 
     LogFlowFuncEnter();
-    LogFlowFunc(("{%p}: operation=%d\n", that, task->operation));
+    LogFlowFunc(("{%p}: operation=%d\n", that, task->m_operation));
 
     HRESULT rc = S_OK;
 
-    switch (task->operation)
+    switch (task->m_operation)
     {
         ////////////////////////////////////////////////////////////////////////
@@ -5075 +5088 @@
                  * here), but lock VirtualBox first to follow the rule */
                 AutoMultiWriteLock2 alock(that->mVirtualBox->lockHandle(),
-                                          that->treeLock());
+                                          that->getTreeLock());
 
                 Assert(target->mParent.isNull());
@@ -5089 +5102 @@
                 /* diffs for immutable hard disks are auto-reset by default */
                 target->m->autoReset =
-                    that->base()->m->type == MediumType_Immutable ?
+                    that->getBase()->m->type == MediumType_Immutable ?
                     TRUE : FALSE;
 
@@ -5291 +5304 @@
                  * here), but lock VirtualBox first to follow the rule */
                 AutoMultiWriteLock2 alock(that->mVirtualBox->lockHandle(),
-                                          that->treeLock());
+                                          that->getTreeLock());
 
                 Medium *source = chain->source();
@@ -5327 +5340 @@
                 else
                 {
-                    Assert(target->children().size() == 1);
-                    Medium *targetChild = target->children().front();
+                    Assert(target->getChildren().size() == 1);
+                    Medium *targetChild = target->getChildren().front();
 
                     /* disconnect the deleted branch at the elder end */
@@ -5389 +5402 @@
                          * the caller's responsibility) */
                         if (*it == that)
-                            task->autoCaller.release();
+                            task->m_autoCaller.release();
 
                         /* release the caller added by MergeChain before
@@ -5515 +5528 @@
 
                     PVBOXHDD targetHdd;
-                    int vrc = VDCreate(that->m->vdDiskIfaces, &targetHdd);
+                    vrc = VDCreate(that->m->vdDiskIfaces, &targetHdd);
                     ComAssertRCThrow(vrc, E_FAIL);
 
@@ -5579 +5592 @@
                      * here), but lock VirtualBox first to follow the rule */
                     AutoMultiWriteLock2 alock(that->mVirtualBox->lockHandle(),
-                                               that->treeLock());
+                                               that->getTreeLock());
 
                     Assert(target->mParent.isNull());
@@ -5890 +5903 @@
     if (isAsync)
     {
-        if (!task->progress.isNull())
-            task->progress->notifyComplete(rc);
+        if (!task->m_pProgress.isNull())
+            task->m_pProgress->notifyComplete(rc);
     }
     else
     {
-        task->rc = rc;
+        task->m_rc = rc;
     }
 

trunk/src/VBox/Main/ProgressImpl.cpp

@@ -829 +829 @@
     {
         RTTIMESPEC time;
-        RTTimeNow (&time); /** @todo r=bird: Use monotonic time (RTTimeMilliTS()) here because of daylight saving and things like that. */
+        RTTimeNow(&time); /** @todo r=bird: Use monotonic time (RTTimeMilliTS()) here because of daylight saving and things like that. */
 
         int vrc = VINF_SUCCESS;
         bool fForever = aTimeout < 0;
         int64_t timeLeft = aTimeout;
-        int64_t lastTime = RTTimeSpecGetMilli (&time);
+        int64_t lastTime = RTTimeSpecGetMilli(&time);
 
         while (!mCompleted && (fForever || timeLeft > 0))
@@ -840 +840 @@
             mWaitersCount++;
             alock.leave();
-            int vrc = RTSemEventMultiWait(mCompletedSem,
-                                          fForever ? RT_INDEFINITE_WAIT : (unsigned)timeLeft);
+            vrc = RTSemEventMultiWait(mCompletedSem,
+                                      fForever ? RT_INDEFINITE_WAIT : (unsigned)timeLeft);
             alock.enter();
             mWaitersCount--;
@@ -907 +907 @@
             mWaitersCount ++;
             alock.leave();
-            int vrc = RTSemEventMultiWait(mCompletedSem,
-                                          fForever ? RT_INDEFINITE_WAIT : (unsigned) timeLeft);
+            vrc = RTSemEventMultiWait(mCompletedSem,
+                                      fForever ? RT_INDEFINITE_WAIT : (unsigned) timeLeft);
             alock.enter();
             mWaitersCount--;
@@ -1729 +1729 @@
     AssertReturn(mProgress < mProgresses.size(), E_FAIL);
 
-    ComPtr<IProgress> progress = mProgresses [mProgress];
+    ComPtr<IProgress> progress = mProgresses[mProgress];
     ComAssertRet (!progress.isNull(), E_FAIL);
 
     HRESULT rc = S_OK;
-    BOOL completed = FALSE;
+    BOOL fCompleted = FALSE;
 
     do
     {
-        rc = progress->COMGETTER(Completed) (&completed);
+        rc = progress->COMGETTER(Completed)(&fCompleted);
         if (FAILED (rc))
             return rc;
 
-        if (completed)
+        if (fCompleted)
         {
-            rc = progress->COMGETTER(Canceled) (&mCanceled);
+            rc = progress->COMGETTER(Canceled)(&mCanceled);
             if (FAILED (rc))
                 return rc;
 
             LONG iRc;
-            rc = progress->COMGETTER(ResultCode) (&iRc);
+            rc = progress->COMGETTER(ResultCode)(&iRc);
             if (FAILED (rc))
                 return rc;
@@ -1781 +1781 @@
         }
     }
-    while (completed && !mCompleted);
+    while (fCompleted && !mCompleted);
 
     rc = progress->COMGETTER(OperationPercent) (&m_ulOperationPercent);

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -825 +825 @@
     {
         MediumAttachment *pAtt = *it;
-        Medium *pMedium = pAtt->medium();
+        Medium *pMedium = pAtt->getMedium();
         if (pMedium) // can be NULL for non-harddisk
         {
@@ -1536 +1536 @@
         ComObjPtr<MediumAttachment> &pAttach = *it;
         AutoReadLock attachLock(pAttach);
-        if (pAttach->type() == DeviceType_HardDisk)
+        if (pAttach->getType() == DeviceType_HardDisk)
         {
             ++ulOpCount;
             ++ulTotalWeight;         // assume one MB weight for each differencing hard disk to manage
-            Assert(pAttach->medium());
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->medium()->name().c_str()));
+            Assert(pAttach->getMedium());
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->getMedium()->getName().c_str()));
         }
     }
@@ -1770 +1770 @@
         {
             ComObjPtr<MediumAttachment> pAttach = *it;
-            ComObjPtr<Medium> pMedium = pAttach->medium();
+            ComObjPtr<Medium> pMedium = pAttach->getMedium();
 
             /* while the hard disk is attached, the number of children or the
              * parent cannot change, so no lock */
             if (    !pMedium.isNull()
-                 && pAttach->type() == DeviceType_HardDisk
-                 && !pMedium->parent().isNull()
-                 && pMedium->children().size() == 0
+                 && pAttach->getType() == DeviceType_HardDisk
+                 && !pMedium->getParent().isNull()
+                 && pMedium->getChildren().size() == 0
                )
             {
-                LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->name().raw()));
+                LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->getName().raw()));
 
                 llDiffAttachmentsToDelete.push_back(pAttach);
@@ -1820 +1820 @@
         {
             ComObjPtr<MediumAttachment> pAttach = *it;        // guaranteed to have only attachments where medium != NULL
-            ComObjPtr<Medium> pMedium = pAttach->medium();
+            ComObjPtr<Medium> pMedium = pAttach->getMedium();
 
             AutoWriteLock mlock(pMedium);
 
-            LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->name().raw()));
+            LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->getName().raw()));
 
             // Normally we "detach" the medium by removing the attachment object
@@ -1852 +1852 @@
         {
             ComObjPtr<Medium> &pMedium = *it;
-            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->name().raw()));
+            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->getName().raw()));
 
             HRESULT rc2 = pMedium->deleteStorageAndWait();
@@ -1984 +1984 @@
         ComObjPtr<MediumAttachment> &pAttach = *it;
         AutoReadLock attachLock(pAttach);
-        if (pAttach->type() == DeviceType_HardDisk)
+        if (pAttach->getType() == DeviceType_HardDisk)
         {
-            Assert(pAttach->medium());
-            ComObjPtr<Medium> pHD = pAttach->medium();
+            ComObjPtr<Medium> pHD = pAttach->getMedium();
+            Assert(pHD);
             AutoReadLock mlock(pHD);
-            if (pHD->type() == MediumType_Normal)
+            if (pHD->getType() == MediumType_Normal)
             {
                 ++ulOpCount;
-                ulTotalWeight += pHD->size() / _1M;
+                ulTotalWeight += pHD->getSize() / _1M;
             }
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pHD->name().c_str()));
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pHD->getName().c_str()));
         }
     }
@@ -2116 +2116 @@
 
     /* save the snapshot ID (for callbacks) */
-    Guid snapshotId = aTask.pSnapshot->getId();
+    Guid snapshotId1 = aTask.pSnapshot->getId();
 
     MediumDiscardRecList toDiscard;
@@ -2138 +2138 @@
             ComObjPtr<MediumAttachment> &pAttach = *it;
             AutoReadLock attachLock(pAttach);
-            if (pAttach->type() == DeviceType_HardDisk)
+            if (pAttach->getType() == DeviceType_HardDisk)
             {
-                Assert(pAttach->medium());
-                ComObjPtr<Medium> pHD = pAttach->medium();
+                Assert(pAttach->getMedium());
+                ComObjPtr<Medium> pHD = pAttach->getMedium();
                         // do not lock, prepareDiscared() has a write lock which will hang otherwise
 
@@ -2159 +2159 @@
                 // unless it's a base image:
 
-                if (    pHD->parent().isNull()
+                if (    pHD->getParent().isNull()
                      && chain != NULL
                    )
@@ -2175 +2175 @@
                     // prepareDiscard() should have raised an error already
                     // if there was more than one child
-                    Assert(pHD->children().size() == 1);
-
-                    ComObjPtr<Medium> pReplaceHD = pHD->children().front();
+                    Assert(pHD->getChildren().size() == 1);
+
+                    ComObjPtr<Medium> pReplaceHD = pHD->getChildren().front();
 
                     const Guid *pReplaceMachineId = pReplaceHD->getFirstMachineBackrefId();
@@ -2298 +2298 @@
         {
             rc = it->hd->discard(aTask.pProgress,
-                                 it->hd->size() / _1M,          // weight
+                                 it->hd->getSize() / _1M,          // weight
                                  it->chain);
             CheckComRCBreakRC(rc);
@@ -2328 +2328 @@
                 /* undo hard disk replacement */
 
-                rc2 = it->replaceHd->attachTo (mData->mUuid, it->snapshotId);
+                rc2 = it->replaceHd->attachTo(mData->mUuid, it->snapshotId);
                 AssertComRC(rc2);
 
@@ -2369 +2369 @@
 
     if (SUCCEEDED(rc))
-        mParent->onSnapshotDeleted(mData->mUuid, snapshotId);
+        mParent->onSnapshotDeleted(mData->mUuid, snapshotId1);
 
     LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", rc));

trunk/src/VBox/Main/USBControllerImpl.cpp

@@ -459 +459 @@
 
     /* notify the proxy (only when it makes sense) */
-    if (filter->data().mActive && Global::IsOnline (adep.machineState()))
-    {
-        USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
+    if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
+    {
+        USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
         ComAssertRet (service, E_FAIL);
 
-        ComAssertRet (filter->id() == NULL, E_FAIL);
-        filter->id() = service->insertFilter (&filter->data().mUSBFilter);
+        ComAssertRet(filter->getId() == NULL, E_FAIL);
+        filter->getId() = service->insertFilter (&filter->getData().mUSBFilter);
     }
 
@@ -525 +525 @@
 
     /* notify the proxy (only when it makes sense) */
-    if (filter->data().mActive && Global::IsOnline (adep.machineState()))
-    {
-        USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
+    if (filter->getData().mActive && Global::IsOnline(adep.machineState()))
+    {
+        USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
         ComAssertRet (service, E_FAIL);
 
-        ComAssertRet (filter->id() != NULL, E_FAIL);
-        service->removeFilter (filter->id());
-        filter->id() = NULL;
+        ComAssertRet(filter->getId() != NULL, E_FAIL);
+        service->removeFilter(filter->getId());
+        filter->getId() = NULL;
     }
 
@@ -623 +623 @@
     {
         AutoWriteLock filterLock (*it);
-        const USBDeviceFilter::Data &filterData = (*it)->data();
+        const USBDeviceFilter::Data &filterData = (*it)->getData();
 
         Bstr str;
@@ -728 +728 @@
         while (thatIt != backDevices.end())
         {
-            if ((*it)->data() == (*thatIt)->data())
+            if ((*it)->getData() == (*thatIt)->getData())
             {
                 backDevices.erase (thatIt);
@@ -775 +775 @@
     if (mDeviceFilters.isBackedUp())
     {
-        USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
+        USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
         ComAssertRet (service, false);
 
@@ -787 +787 @@
             {
                 /* notify the proxy (only when it makes sense) */
-                if ((*it)->data().mActive &&
+                if ((*it)->getData().mActive &&
                     Global::IsOnline (adep.machineState()))
                 {
                     USBDeviceFilter *filter = *it;
-                    ComAssertRet (filter->id() != NULL, false);
-                    service->removeFilter (filter->id());
-                    filter->id() = NULL;
+                    ComAssertRet(filter->getId() != NULL, false);
+                    service->removeFilter(filter->getId());
+                    filter->getId() = NULL;
                 }
 
@@ -812 +812 @@
                 {
                     /* notify the proxy (only when necessary) */
-                    if ((*it)->data().mActive)
+                    if ((*it)->getData().mActive)
                     {
                         USBDeviceFilter *flt = *it; /* resolve ambiguity */
-                        ComAssertRet (flt->id() == NULL, false);
-                        flt->id() = service->insertFilter (&flt->data().mUSBFilter);
+                        ComAssertRet(flt->getId() == NULL, false);
+                        flt->getId() = service->insertFilter(&flt->getData().mUSBFilter);
                     }
                 }
@@ -1029 +1029 @@
     if (aFilter->mInList && mParent->isRegistered())
     {
-        USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
+        USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
         ComAssertRet (service, E_FAIL);
 
@@ -1035 +1035 @@
         {
             /* insert/remove the filter from the proxy */
-            if (aFilter->data().mActive)
+            if (aFilter->getData().mActive)
             {
-                ComAssertRet (aFilter->id() == NULL, E_FAIL);
-                aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
+                ComAssertRet(aFilter->getId() == NULL, E_FAIL);
+                aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);
             }
             else
             {
-                ComAssertRet (aFilter->id() != NULL, E_FAIL);
-                service->removeFilter (aFilter->id());
-                aFilter->id() = NULL;
+                ComAssertRet(aFilter->getId() != NULL, E_FAIL);
+                service->removeFilter(aFilter->getId());
+                aFilter->getId() = NULL;
             }
         }
         else
         {
-            if (aFilter->data().mActive)
+            if (aFilter->getData().mActive)
             {
                 /* update the filter in the proxy */
-                ComAssertRet (aFilter->id() != NULL, E_FAIL);
-                service->removeFilter (aFilter->id());
-                aFilter->id() = service->insertFilter (&aFilter->data().mUSBFilter);
+                ComAssertRet(aFilter->getId() != NULL, E_FAIL);
+                service->removeFilter(aFilter->getId());
+                aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);
             }
         }
@@ -1087 +1087 @@
     {
         AutoWriteLock filterLock (*it);
-        if (aDevice->isMatch ((*it)->data()))
+        if (aDevice->isMatch((*it)->getData()))
         {
-            *aMaskedIfs = (*it)->data().mMaskedIfs;
+            *aMaskedIfs = (*it)->getData().mMaskedIfs;
             return true;
         }
@@ -1184 +1184 @@
     {
         AutoWriteLock filterLock (*it);
-        const USBDeviceFilter::Data &aData = (*it)->data();
+        const USBDeviceFilter::Data &aData = (*it)->getData();
 
         if (!aData.mActive)
@@ -1221 +1221 @@
     AutoReadLock alock(this);
 
-    USBProxyService *service = mParent->virtualBox()->host()->usbProxyService();
+    USBProxyService *service = mParent->getVirtualBox()->host()->usbProxyService();
     AssertReturn(service, E_FAIL);
 
@@ -1230 +1230 @@
 
         /* notify the proxy (only if the filter is active) */
-        if (flt->data().mActive)
+        if (flt->getData().mActive)
         {
             if (aInsertFilters)
             {
-                AssertReturn(flt->id() == NULL, E_FAIL);
-                flt->id() = service->insertFilter (&flt->data().mUSBFilter);
+                AssertReturn(flt->getId() == NULL, E_FAIL);
+                flt->getId() = service->insertFilter(&flt->getData().mUSBFilter);
             }
             else
@@ -1242 +1242 @@
                  * when this method gets called (as a result of an early VM
                  * process crash for example. So, don't assert that ID != NULL. */
-                if (flt->id() != NULL)
+                if (flt->getId() != NULL)
                 {
-                    service->removeFilter (flt->id());
-                    flt->id() = NULL;
+                    service->removeFilter(flt->getId());
+                    flt->getId() = NULL;
                 }
             }

trunk/src/VBox/Main/USBDeviceImpl.cpp

@@ -93 +93 @@
     ComAssertComRCRet (hrc, hrc);
 
-    Bstr id;
-    hrc = aUSBDevice->COMGETTER(Id)(id.asOutParam());
-    ComAssertComRCRet (hrc, hrc);
-    unconst(mData.id) = Guid(id);
+    Bstr uuid;
+    hrc = aUSBDevice->COMGETTER(Id)(uuid.asOutParam());
+    ComAssertComRCRet(hrc, hrc);
+    unconst(mData.id) = Guid(uuid);
 
     /* Confirm a successful initialization */

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -295 +295 @@
     /* Get the VirtualBox home directory. */
     {
-        char homeDir[RTPATH_MAX];
-        int vrc = com::GetVBoxUserHomeDirectory(homeDir, sizeof(homeDir));
+        char szHomeDir[RTPATH_MAX];
+        int vrc = com::GetVBoxUserHomeDirectory(szHomeDir, sizeof(szHomeDir));
         if (RT_FAILURE(vrc))
             return setError (E_FAIL,
                 tr ("Could not create the VirtualBox home directory '%s'"
                     "(%Rrc)"),
-                homeDir, vrc);
-
-        unconst(m->strHomeDir) = homeDir;
+                szHomeDir, vrc);
+
+        unconst(m->strHomeDir) = szHomeDir;
     }
 
@@ -944 +944 @@
     const char * url = NULL;
 
+    NOREF(aVersion);
+
     static const struct {
         FirmwareType_T type;
@@ -1005 +1007 @@
         }
 
-       
+
         url = firmwareDesc[i].url;
         /** @todo: account for version in the URL */
@@ -1214 +1216 @@
     /* fire an event */
     if (SUCCEEDED(rc))
-        onMachineRegistered (machine->id(), TRUE);
+        onMachineRegistered(machine->getId(), TRUE);
 
     return rc;
@@ -1261 +1263 @@
          ++ it)
     {
-        AutoLimitedCaller machCaller (*it);
-        AssertComRC (machCaller.rc());
+        ComObjPtr<Machine> &pMachine2 = *it;
+        AutoLimitedCaller machCaller(pMachine2);
+        AssertComRC(machCaller.rc());
 
         /* skip inaccessible machines */
         if (machCaller.state() == Machine::Ready)
         {
-            AutoReadLock machLock (*it);
-            if ((*it)->name() == aName)
-                machine = *it;
+            AutoReadLock machLock(pMachine2);
+            if (pMachine2->getName() == aName)
+                machine = pMachine2;
         }
     }
@@ -2735 +2738 @@
  *  @note Locks this object for reading.
  */
-HRESULT VirtualBox::findMachine (const Guid &aId, bool aSetError,
-                                 ComObjPtr<Machine> *aMachine /* = NULL */)
+HRESULT VirtualBox::findMachine(const Guid &aId,
+                                bool aSetError,
+                                ComObjPtr<Machine> *aMachine /* = NULL */)
 {
     AutoCaller autoCaller(this);
@@ -2750 +2754 @@
              ++ it)
         {
+            ComObjPtr<Machine> pMachine2 = *it;
             /* sanity */
-            AutoLimitedCaller machCaller (*it);
-            AssertComRC (machCaller.rc());
-
-            found = (*it)->id() == aId;
+            AutoLimitedCaller machCaller(pMachine2);
+            AssertComRC(machCaller.rc());
+
+            found = pMachine2->getId() == aId;
             if (found && aMachine)
-                *aMachine = *it;
+                *aMachine = pMachine2;
         }
     }
@@ -2896 +2901 @@
         AutoReadLock imageLock (*it);
 
-        found = (aId && (*it)->id() == *aId) ||
+        found = (aId && (*it)->getId() == *aId) ||
                 (aLocation != NULL &&
                  RTPathCompare(location.c_str(),
-                               (*it)->locationFull().c_str()
+                               (*it)->getLocationFull().c_str()
                               ) == 0);
         if (found)
@@ -2972 +2977 @@
         AutoReadLock imageLock (*it);
 
-        found = (aId && (*it)->id() == *aId) ||
+        found = (aId && (*it)->getId() == *aId) ||
                 (aLocation != NULL &&
                  RTPathCompare(location.c_str(),
-                               (*it)->locationFull().c_str()
+                               (*it)->getLocationFull().c_str()
                               ) == 0);
         if (found)
@@ -3184 +3189 @@
         {
             /* Note: no AutoCaller since bound to this */
-            AutoReadLock mediaLock (hardDisk);
-            aConflict = Utf8StrFmt (
-                tr ("hard disk '%s' with UUID {%RTuuid}"),
-                hardDisk->locationFull().raw(), hardDisk->id().raw());
+            AutoReadLock mediaLock(hardDisk);
+            aConflict = Utf8StrFmt(tr("hard disk '%s' with UUID {%RTuuid}"),
+                                   hardDisk->getLocationFull().raw(),
+                                   hardDisk->getId().raw());
             return S_OK;
         }
@@ -3199 +3204 @@
             /* Note: no AutoCaller since bound to this */
             AutoReadLock mediaLock (image);
-            aConflict = Utf8StrFmt (
-                tr ("CD/DVD image '%s' with UUID {%RTuuid}"),
-                image->locationFull().raw(), image->id().raw());
+            aConflict = Utf8StrFmt(tr("CD/DVD image '%s' with UUID {%RTuuid}"),
+                                   image->getLocationFull().raw(),
+                                   image->getId().raw());
             return S_OK;
         }
@@ -3213 +3218 @@
             /* Note: no AutoCaller since bound to this */
             AutoReadLock mediaLock (image);
-            aConflict = Utf8StrFmt (
-                tr ("floppy image '%s' with UUID {%RTuuid}"),
-                image->locationFull().raw(), image->id().raw());
+            aConflict = Utf8StrFmt(tr("floppy image '%s' with UUID {%RTuuid}"),
+                                   image->getLocationFull().raw(),
+                                   image->getId().raw());
             return S_OK;
         }
@@ -3339 +3344 @@
  *  @note Locks objects!
  */
-HRESULT VirtualBox::registerMachine (Machine *aMachine)
+HRESULT VirtualBox::registerMachine(Machine *aMachine)
 {
     ComAssertRet (aMachine, E_INVALIDARG);
@@ -3351 +3356 @@
 
     {
-        ComObjPtr<Machine> m;
-        rc = findMachine (aMachine->id(), false /* aDoSetError */, &m);
+        ComObjPtr<Machine> pMachine;
+        rc = findMachine(aMachine->getId(), false /* aDoSetError */, &pMachine);
         if (SUCCEEDED(rc))
         {
             /* sanity */
-            AutoLimitedCaller machCaller (m);
-            AssertComRC (machCaller.rc());
-
-            return setError (E_INVALIDARG,
-                tr ("Registered machine with UUID {%RTuuid} ('%ls') already exists"),
-                aMachine->id().raw(), m->settingsFileFull().raw());
-        }
-
-        ComAssertRet (rc == VBOX_E_OBJECT_NOT_FOUND, rc);
+            AutoLimitedCaller machCaller(pMachine);
+            AssertComRC(machCaller.rc());
+
+            return setError(E_INVALIDARG,
+                            tr("Registered machine with UUID {%RTuuid} ('%ls') already exists"),
+                            aMachine->getId().raw(),
+                            pMachine->getSettingsFileFull().raw());
+        }
+
+        ComAssertRet(rc == VBOX_E_OBJECT_NOT_FOUND, rc);
         rc = S_OK;
     }
@@ -3371 +3377 @@
     {
         /* Machine::trySetRegistered() will commit and save machine settings */
-        rc = aMachine->trySetRegistered (TRUE);
+        rc = aMachine->trySetRegistered(TRUE);
         CheckComRCReturnRC(rc);
     }
@@ -3415 +3421 @@
 
     Utf8Str strConflict;
-    HRESULT rc = checkMediaForConflicts2(aHardDisk->id(),
-                                         aHardDisk->locationFull(),
+    HRESULT rc = checkMediaForConflicts2(aHardDisk->getId(),
+                                         aHardDisk->getLocationFull(),
                                          strConflict);
     CheckComRCReturnRC(rc);
@@ -3424 +3430 @@
         return setError(E_INVALIDARG,
                         tr("Cannot register the hard disk '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
-                        aHardDisk->locationFull().raw(),
-                        aHardDisk->id().raw(),
+                        aHardDisk->getLocationFull().raw(),
+                        aHardDisk->getId().raw(),
                         strConflict.raw(),
                         m->strSettingsFilePath.raw());
     }
 
-    if (aHardDisk->parent().isNull())
+    if (aHardDisk->getParent().isNull())
     {
         /* base (root) hard disk */
@@ -3436 +3442 @@
     }
 
-    m->mapHardDisks
-        .insert (HardDiskMap::value_type (
-            aHardDisk->id(), HardDiskMap::mapped_type (aHardDisk)));
+    m->mapHardDisks.insert(HardDiskMap::value_type(aHardDisk->getId(),
+                                                   HardDiskMap::mapped_type(aHardDisk)));
 
     if (aSaveRegistry)
@@ -3480 +3485 @@
     AutoReadLock hardDiskLock (aHardDisk);
 
-    size_t cnt = m->mapHardDisks.erase (aHardDisk->id());
-    Assert (cnt == 1);
+    size_t cnt = m->mapHardDisks.erase(aHardDisk->getId());
+    Assert(cnt == 1);
     NOREF(cnt);
 
-    if (aHardDisk->parent().isNull())
+    if (aHardDisk->getParent().isNull())
     {
         /* base (root) hard disk */
-        m->llHardDisks.remove (aHardDisk);
+        m->llHardDisks.remove(aHardDisk);
     }
 
@@ -3533 +3538 @@
 
     Utf8Str strConflict;
-    HRESULT rc = checkMediaForConflicts2(aImage->id(),
-                                         aImage->locationFull(),
+    HRESULT rc = checkMediaForConflicts2(aImage->getId(),
+                                         aImage->getLocationFull(),
                                          strConflict);
     CheckComRCReturnRC(rc);
@@ -3542 +3547 @@
         return setError(VBOX_E_INVALID_OBJECT_STATE,
                         tr("Cannot register the CD/DVD image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
-                        aImage->locationFull().raw(),
-                        aImage->id().raw(),
+                        aImage->getLocationFull().raw(),
+                        aImage->getId().raw(),
                         strConflict.raw(),
                         m->strSettingsFilePath.raw());
@@ -3636 +3641 @@
 
     Utf8Str strConflict;
-    HRESULT rc = checkMediaForConflicts2(aImage->id(),
-                                         aImage->locationFull(),
+    HRESULT rc = checkMediaForConflicts2(aImage->getId(),
+                                         aImage->getLocationFull(),
                                          strConflict);
     CheckComRCReturnRC(rc);
@@ -3645 +3650 @@
         return setError(VBOX_E_INVALID_OBJECT_STATE,
                         tr("Cannot register the floppy image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
-                        aImage->locationFull().raw(),
-                        aImage->id().raw(),
+                        aImage->getLocationFull().raw(),
+                        aImage->getId().raw(),
                         strConflict.raw(),
                         m->strSettingsFilePath.raw());

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

@@ -139 +139 @@
 
     ComPtr<IHost> host;
-    HRESULT rc = pVBox->COMGETTER(Host)(host.asOutParam());
-    if(SUCCEEDED(rc))
-    {
-        rc = progress->init (pVBox, host,
+    HRESULT hrc = pVBox->COMGETTER(Host)(host.asOutParam());
+    if (SUCCEEDED(hrc))
+    {
+        hrc = progress->init(pVBox, host,
                              Bstr ("Creating host only network interface"),
                              FALSE /* aCancelable */);
-        if(SUCCEEDED(rc))
+        if (SUCCEEDED(hrc))
         {
-            CheckComRCReturnRC(rc);
             progress.queryInterfaceTo(aProgress);
 
@@ -208 +207 @@
     }
 
-    return rc;
+    return hrc;
 
 #else

trunk/src/VBox/Main/hgcm/HGCMObjects.cpp

@@ -90 +90 @@
     if (RT_SUCCESS(rc))
     {
-        ObjectAVLCore *pCore = &pObject->Core;
+        ObjectAVLCore *pCore = &pObject->m_core;
 
         /* Generate a new handle value. */

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

@@ -100 +100 @@
     void copyFrom (AudioAdapter *aThat);
 
-    // public methods for internal purposes only
-    // (ensure there is a caller and a read lock before calling them!)
-
-    const Backupable <Data> &data() const { return mData; }
-
     // for VirtualBoxSupportErrorInfoImpl
     static const wchar_t *getComponentName() { return L"AudioAdapter"; }
@@ -113 +108 @@
     const ComObjPtr<AudioAdapter> mPeer;
 
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

trunk/src/VBox/Main/include/BIOSSettingsImpl.h

@@ -125 +125 @@
     HRESULT saveSettings(settings::BIOSSettings &data);
 
-    const Backupable <Data> &data() const { return mData; }
-
     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
@@ -141 +139 @@
     ComObjPtr<Machine, ComWeakRef> mParent;
     ComObjPtr<BIOSSettings> mPeer;
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

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

@@ -636 +636 @@
     // public methods only for internal purposes
 
-    InstanceType type() const { return mType; }
+    InstanceType getType() const { return mType; }
 
     /// @todo (dmik) add lock and make non-inlined after revising classes
@@ -653 +653 @@
      * one) or after doing addCaller() manually.
      */
-    const ComObjPtr<VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
+    const ComObjPtr<VirtualBox, ComWeakRef>& getVirtualBox() const { return mParent; }
 
     /**
@@ -662 +662 @@
      * one) or after adding a caller manually.
      */
-    const Guid &id() const { return mData->mUuid; }
+    const Guid& getId() const { return mData->mUuid; }
 
     /**
@@ -672 +672 @@
      * one) or after adding a caller manually.
      */
-    inline const Guid &snapshotId() const;
+    inline const Guid& getSnapshotId() const;
 
     /**
@@ -681 +681 @@
      * for reading.
      */
-    const Utf8Str &settingsFileFull() const { return mData->m_strConfigFileFull; }
+    const Utf8Str& getSettingsFileFull() const { return mData->m_strConfigFileFull; }
 
     /**
@@ -690 +690 @@
      * for reading.
      */
-    const Bstr &name() const { return mUserData->mName; }
+    const Bstr& getName() const { return mUserData->mName; }
 
     // callback handlers
@@ -798 +798 @@
     HRESULT checkStateDependency(StateDependency aDepType);
 
-    inline Machine *machine();
+    inline Machine *getMachine();
 
     void ensureNoStateDependencies();
@@ -1149 +1149 @@
     // a caller and a read lock before calling them!)
 
-    const Guid &snapshotId() const { return mSnapshotId; }
+    const Guid& getSnapshotId() const { return mSnapshotId; }
 
 private:
@@ -1160 +1160 @@
 // third party methods that depend on SnapshotMachine definiton
 
-inline const Guid &Machine::snapshotId() const
+inline const Guid &Machine::getSnapshotId() const
 {
     return mType != IsSnapshotMachine ? Guid::Empty :
-                    static_cast<const SnapshotMachine *>(this)->snapshotId();
+                    static_cast<const SnapshotMachine *>(this)->getSnapshotId();
 }
 
@@ -1176 +1176 @@
  *  (primary) machine pointer.
  */
-inline Machine *Machine::machine()
+inline Machine *Machine::getMachine()
 {
     if (mType == IsSessionMachine)

trunk/src/VBox/Main/include/MediumAttachmentImpl.h

@@ -80 +80 @@
     void setImplicit(bool aImplicit) { m->implicit = aImplicit; }
 
-    const ComObjPtr<Medium> &medium() const { return m->medium; }
-    Bstr controllerName() const { return m->controllerName; }
-    LONG port() const { return m->port; }
-    LONG device() const { return m->device; }
-    DeviceType_T type() const { return m->type; }
-    bool passthrough() const { AutoReadLock lock(this); return m->passthrough; }
+    const ComObjPtr<Medium>& getMedium() const { return m->medium; }
+    Bstr getControllerName() const { return m->controllerName; }
+    LONG getPort() const { return m->port; }
+    LONG getDevice() const { return m->device; }
+    DeviceType_T getType() const { return m->type; }
+    bool getPassthrough() const { AutoReadLock lock(this); return m->passthrough; }
 
     bool matches(CBSTR aControllerName, LONG aPort, LONG aDevice)
@@ -110 +110 @@
 
     /** Get a unique and somewhat descriptive name for logging. */
-    const char *logName(void) const { return mLogName.c_str(); }
+    const char* getLogName(void) const { return mLogName.c_str(); }
 
     /** For com::SupportErrorInfoImpl. */

trunk/src/VBox/Main/include/MediumImpl.h

@@ -167 +167 @@
 #endif
 
-    const Guid& id() const;
-    MediumState_T state() const;
-    const Utf8Str& location() const;
-    const Utf8Str& locationFull() const;
-    uint64_t size() const;
+    const Guid& getId() const;
+    MediumState_T getState() const;
+    const Utf8Str& getLocation() const;
+    const Utf8Str& getLocationFull() const;
+    uint64_t getSize() const;
 
     const Guid* getFirstMachineBackrefId() const;
@@ -179 +179 @@
      * Shortcut to VirtualBoxBaseWithTypedChildrenNEXT::dependentChildren().
      */
-    const List &children() const { return dependentChildren(); }
+    const List& getChildren() const { return dependentChildren(); }
 
     void updatePaths(const char *aOldPath, const char *aNewPath);
 
-    ComObjPtr<Medium> base(uint32_t *aLevel = NULL);
+    ComObjPtr<Medium> getBase(uint32_t *aLevel = NULL);
 
     bool isReadOnly();
@@ -244 +244 @@
     void cancelMergeTo(MergeChain *aChain);
 
-    Utf8Str name();
+    Utf8Str getName();
 
     HRESULT prepareDiscard(MergeChain * &aChain);
@@ -256 +256 @@
     // a caller and a read lock before calling them!)
 
-    ComObjPtr<Medium> parent() const { return static_cast<Medium *>(mParent); }
-    MediumType_T type() const;
+    ComObjPtr<Medium> getParent() const { return static_cast<Medium *>(mParent); }
+    MediumType_T getType() const;
 
     /** For com::SupportErrorInfoImpl. */
@@ -264 +264 @@
 protected:
 
-    RWLockHandle* treeLock();
+    RWLockHandle* getTreeLock();
 
     /** Reimplements VirtualBoxWithTypedChildren::childrenLock() to return
      *  treeLock(). */
-    RWLockHandle *childrenLock() { return treeLock(); }
+    RWLockHandle *childrenLock() { return getTreeLock(); }
 
 private:

trunk/src/VBox/Main/include/NetworkAdapterImpl.h

@@ -147 +147 @@
     void applyDefaults (GuestOSType *aOsType);
 
-    // public methods for internal purposes only
-    // (ensure there is a caller and a read lock before calling them!)
-
-    const Backupable <Data> &data() const { return mData; }
-
     // for VirtualBoxSupportErrorInfoImpl
     static const wchar_t *getComponentName() { return L"NetworkAdapter"; }
@@ -163 +158 @@
     const ComObjPtr<NetworkAdapter> mPeer;
 
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

trunk/src/VBox/Main/include/ParallelPortImpl.h

@@ -125 +125 @@
     const ComObjPtr<ParallelPort> mPeer;
 
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

trunk/src/VBox/Main/include/ProgressImpl.h

@@ -94 +94 @@
     // a caller and a read lock before calling them!)
 
-    BOOL completed() const { return mCompleted; }
-    HRESULT resultCode() const { return mResultCode; }
+    BOOL getCompleted() const { return mCompleted; }
+    HRESULT getResultCode() const { return mResultCode; }
     double calcTotalPercent();
 

trunk/src/VBox/Main/include/SerialPortImpl.h

@@ -138 +138 @@
     const ComObjPtr<SerialPort> mPeer;
 
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

trunk/src/VBox/Main/include/SharedFolderImpl.h

@@ -85 +85 @@
     // (ensure there is a caller added before calling them!)
 
-    const Bstr &name() const { return m.name; }
-    const Bstr &hostPath() const { return m.hostPath; }
-    BOOL writable() const { return m.writable; }
+    const Bstr& getName() const { return m.name; }
+    const Bstr& getHostPath() const { return m.hostPath; }
+    BOOL isWritable() const { return m.writable; }
 
     // for VirtualBoxSupportErrorInfoImpl

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

@@ -137 +137 @@
     const ComObjPtr<Machine, ComWeakRef> &parent() { return mParent; };
 
-    const Backupable<Data> &data() { return mData; }
+    const Backupable<Data>& getData() { return mData; }
 
     // for VirtualBoxSupportErrorInfoImpl
@@ -162 +162 @@
     const ComObjPtr<USBController> mPeer;
     /** Data. */
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 
 #ifdef VBOX_WITH_USB

trunk/src/VBox/Main/include/VRDPServerImpl.h

@@ -119 +119 @@
     void copyFrom (VRDPServer *aThat);
 
-    // public methods for internal purposes only
-    // (ensure there is a caller and a read lock before calling them!)
-
-    const Backupable <Data> &data() const { return mData; }
-
     // for VirtualBoxSupportErrorInfoImpl
     static const wchar_t *getComponentName() { return L"VRDPServer"; }
@@ -132 +127 @@
     const ComObjPtr<VRDPServer> mPeer;
 
-    Backupable <Data> mData;
+    Backupable<Data> mData;
 };
 

trunk/src/VBox/Main/include/VirtualBoxBase.h

@@ -1163 +1163 @@
                               bool aLimited = false) \
     { \
-        VirtualBoxBaseProto::State state; \
-        HRESULT rc = VirtualBoxBaseProto::addCaller(&state, aLimited); \
+        VirtualBoxBaseProto::State protoState; \
+        HRESULT rc = VirtualBoxBaseProto::addCaller(&protoState, aLimited); \
         if (FAILED(rc)) \
         { \
-            if (state == VirtualBoxBaseProto::Limited) \
+            if (protoState == VirtualBoxBaseProto::Limited) \
                 rc = setError(rc, tr("The object functionality is limited")); \
             else \
@@ -1173 +1173 @@
         } \
         if (aState) \
-            *aState = state; \
+            *aState = protoState; \
         return rc; \
     } \
@@ -2233 +2233 @@
     }
 
-    void attach(D *data) {
-        AssertMsg(data, ("new data must not be NULL"));
-        if (data && mData != data) {
+    void attach(D *d) {
+        AssertMsg(d, ("new data must not be NULL"));
+        if (d && mData != d) {
             if (mData && !mIsShared)
                 delete mData;
-            mData = data;
+            mData = d;
             mIsShared = false;
         }
     }
 
-    void attach(Shareable &data) {
+    void attach(Shareable &d) {
         AssertMsg(
-            data.mData == mData || !data.mIsShared,
+            d.mData == mData || !d.mIsShared,
             ("new data must not be shared")
         );
-        if (this != &data && !data.mIsShared) {
-            attach (data.mData);
-            data.mIsShared = true;
+        if (this != &d && !d.mIsShared) {
+            attach(d.mData);
+            d.mIsShared = true;
         }
     }
 
-    void share(D *data) {
-        AssertMsg(data, ("new data must not be NULL"));
-        if (mData != data) {
+    void share(D *d) {
+        AssertMsg(d, ("new data must not be NULL"));
+        if (mData != d) {
             if (mData && !mIsShared)
                 delete mData;
-            mData = data;
+            mData = d;
             mIsShared = true;
         }
     }
 
-    void share(const Shareable &data) { share (data.mData); }
-
-    void attachCopy(const D *data) {
-        AssertMsg(data, ("data to copy must not be NULL"));
-        if (data)
-            attach(new D(*data));
-    }
-
-    void attachCopy(const Shareable &data) {
-        attachCopy(data.mData);
+    void share(const Shareable &d) { share(d.mData); }
+
+    void attachCopy(const D *d) {
+        AssertMsg(d, ("data to copy must not be NULL"));
+        if (d)
+            attach(new D(*d));
+    }
+
+    void attachCopy(const Shareable &d) {
+        attachCopy(d.mData);
     }
 
@@ -2330 +2330 @@
     }
 
-    void share(const Backupable &data)
-    {
-        AssertMsg(!data.isBackedUp(), ("data to share must not be backed up"));
-        if (!data.isBackedUp())
-            Shareable<D>::share(data.mData);
+    void share(const Backupable &d)
+    {
+        AssertMsg(!d.isBackedUp(), ("data to share must not be backed up"));
+        if (!d.isBackedUp())
+            Shareable<D>::share(d.mData);
     }
 
@@ -2410 +2410 @@
     }
 
-    void assignCopy(const D *data)
+    void assignCopy(const D *pData)
     {
         AssertMsg(this->mData, ("data must not be NULL"));
-        AssertMsg(data, ("data to copy must not be NULL"));
-        if (this->mData && data)
+        AssertMsg(pData, ("data to copy must not be NULL"));
+        if (this->mData && pData)
         {
             if (!mBackupData)
             {
-                D *pNewData = new D(*data);
+                D *pNewData = new D(*pData);
                 mBackupData = this->mData;
                 this->mData = pNewData;
             }
             else
-                *this->mData = *data;
+                *this->mData = *pData;
         }
     }
 
-    void assignCopy(const Backupable &data)
-    {
-        assignCopy(data.mData);
+    void assignCopy(const Backupable &d)
+    {
+        assignCopy(d.mData);
     }
 

trunk/src/VBox/Main/include/hgcm/HGCMObjects.h

@@ -50 +50 @@
 {
     private:
-    friend uint32_t hgcmObjMake (HGCMObject *pObject, uint32_t u32HandleIn);
+        friend uint32_t hgcmObjMake(HGCMObject *pObject, uint32_t u32HandleIn);
 
-        int32_t volatile cRef;
-        HGCMOBJ_TYPE     enmObjType;
+        int32_t volatile m_cRefs;
+        HGCMOBJ_TYPE     m_enmObjType;
 
-        ObjectAVLCore Core;
+        ObjectAVLCore   m_core;
 
     protected:
-        virtual ~HGCMObject (void) {};
+        virtual ~HGCMObject()
+        {};
 
     public:
-        HGCMObject (HGCMOBJ_TYPE enmObjType) : cRef (0)
+        HGCMObject(HGCMOBJ_TYPE enmObjType)
+            : m_cRefs(0)
         {
-            this->enmObjType  = enmObjType;
+            this->m_enmObjType  = enmObjType;
         };
 
-        void Reference (void)
+        void Reference()
         {
-            int32_t refCnt = ASMAtomicIncS32 (&cRef);
+            int32_t refCnt = ASMAtomicIncS32(&m_cRefs);
             NOREF(refCnt);
             Log(("Reference: refCnt = %d\n", refCnt));
         }
 
-        void Dereference (void)
+        void Dereference()
         {
-            int32_t refCnt = ASMAtomicDecS32 (&cRef);
+            int32_t refCnt = ASMAtomicDecS32(&m_cRefs);
 
             Log(("Dereference: refCnt = %d\n", refCnt));
-            
+
             AssertRelease(refCnt >= 0);
 
@@ -89 +91 @@
         }
 
-        uint32_t Handle (void)
+        uint32_t Handle()
         {
-            return Core.AvlCore.Key;
+            return m_core.AvlCore.Key;
         };
 
-        HGCMOBJ_TYPE Type (void)
+        HGCMOBJ_TYPE Type()
         {
-            return enmObjType;
+            return m_enmObjType;
         };
 };
 
-int hgcmObjInit (void);
+int hgcmObjInit();
 
-void hgcmObjUninit (void);
+void hgcmObjUninit();
 
-uint32_t hgcmObjGenerateHandle (HGCMObject *pObject);
-uint32_t hgcmObjAssignHandle (HGCMObject *pObject, uint32_t u32Handle);
+uint32_t hgcmObjGenerateHandle(HGCMObject *pObject);
+uint32_t hgcmObjAssignHandle(HGCMObject *pObject, uint32_t u32Handle);
 
-void hgcmObjDeleteHandle (uint32_t handle);
+void hgcmObjDeleteHandle(uint32_t handle);
 
-HGCMObject *hgcmObjReference (uint32_t handle, HGCMOBJ_TYPE enmObjType);
+HGCMObject *hgcmObjReference(uint32_t handle, HGCMOBJ_TYPE enmObjType);
 
-void hgcmObjDereference (HGCMObject *pObject);
+void hgcmObjDereference(HGCMObject *pObject);
 
-uint32_t hgcmObjQueryHandleCount ();
-void     hgcmObjSetHandleCount (uint32_t u32HandleCount);
+uint32_t hgcmObjQueryHandleCount();
+void     hgcmObjSetHandleCount(uint32_t u32HandleCount);
 
 #endif /* __HGCMOBJECTS__H */

trunk/src/VBox/Main/xml/Settings.cpp

@@ -179 +179 @@
         va_list args;
         va_start(args, pcszFormat);
-        Utf8StrFmtVA what(pcszFormat, args);
+        Utf8StrFmtVA strWhat(pcszFormat, args);
         va_end(args);
 
@@ -190 +190 @@
                        file->m->strFilename.c_str(),
                        (pcsz) ? pcsz : "",
-                       what.c_str());
+                       strWhat.c_str());
 
         setWhat(str.c_str());
@@ -1089 +1089 @@
  */
 void MainConfigFile::writeHardDisk(xml::ElementNode &elmMedium,
-                                   const Medium &m,
+                                   const Medium &mdm,
                                    uint32_t level)          // 0 for "root" call, incremented with each recursion
 {
     xml::ElementNode *pelmHardDisk = elmMedium.createChild("HardDisk");
-    pelmHardDisk->setAttribute("uuid", makeString(m.uuid));
-    pelmHardDisk->setAttribute("location", m.strLocation);
-    pelmHardDisk->setAttribute("format", m.strFormat);
-    if (m.fAutoReset)
-        pelmHardDisk->setAttribute("autoReset", m.fAutoReset);
-    if (m.strDescription.length())
-        pelmHardDisk->setAttribute("Description", m.strDescription);
-
-    for (PropertiesMap::const_iterator it = m.properties.begin();
-         it != m.properties.end();
+    pelmHardDisk->setAttribute("uuid", makeString(mdm.uuid));
+    pelmHardDisk->setAttribute("location", mdm.strLocation);
+    pelmHardDisk->setAttribute("format", mdm.strFormat);
+    if (mdm.fAutoReset)
+        pelmHardDisk->setAttribute("autoReset", mdm.fAutoReset);
+    if (mdm.strDescription.length())
+        pelmHardDisk->setAttribute("Description", mdm.strDescription);
+
+    for (PropertiesMap::const_iterator it = mdm.properties.begin();
+         it != mdm.properties.end();
          ++it)
     {
@@ -1114 +1114 @@
     {
         const char *pcszType =
-            m.hdType == MediumType_Normal ? "Normal" :
-            m.hdType == MediumType_Immutable ? "Immutable" :
-            /*m.hdType == MediumType_Writethrough ?*/ "Writethrough";
+            mdm.hdType == MediumType_Normal ? "Normal" :
+            mdm.hdType == MediumType_Immutable ? "Immutable" :
+            /*mdm.hdType == MediumType_Writethrough ?*/ "Writethrough";
         pelmHardDisk->setAttribute("type", pcszType);
     }
 
-    for (MediaList::const_iterator it = m.llChildren.begin();
-         it != m.llChildren.end();
+    for (MediaList::const_iterator it = mdm.llChildren.begin();
+         it != mdm.llChildren.end();
          ++it)
     {
@@ -1171 +1171 @@
          ++it)
     {
-        const Medium &m = *it;
+        const Medium &mdm = *it;
         xml::ElementNode *pelmMedium = pelmDVDImages->createChild("Image");
-        pelmMedium->setAttribute("uuid", makeString(m.uuid));
-        pelmMedium->setAttribute("location", m.strLocation);
-        if (m.strDescription.length())
-            pelmMedium->setAttribute("Description", m.strDescription);
+        pelmMedium->setAttribute("uuid", makeString(mdm.uuid));
+        pelmMedium->setAttribute("location", mdm.strLocation);
+        if (mdm.strDescription.length())
+            pelmMedium->setAttribute("Description", mdm.strDescription);
     }
 
@@ -1184 +1184 @@
          ++it)
     {
-        const Medium &m = *it;
+        const Medium &mdm = *it;
         xml::ElementNode *pelmMedium = pelmFloppyImages->createChild("Image");
-        pelmMedium->setAttribute("uuid", makeString(m.uuid));
-        pelmMedium->setAttribute("location", m.strLocation);
-        if (m.strDescription.length())
-            pelmMedium->setAttribute("Description", m.strDescription);
+        pelmMedium->setAttribute("uuid", makeString(mdm.uuid));
+        pelmMedium->setAttribute("location", mdm.strLocation);
+        if (mdm.strDescription.length())
+            pelmMedium->setAttribute("Description", mdm.strDescription);
     }
 

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

@@ -677 +677 @@
 static nsresult
 RegisterSelfComponents(nsIComponentRegistrar *registrar,
-                       const nsModuleComponentInfoEx *components,
+                       const nsModuleComponentInfoEx *aComponents,
                        PRUint32 count)
 {
     nsresult rc = NS_OK;
-    const nsModuleComponentInfoEx *info = components;
+    const nsModuleComponentInfoEx *info = aComponents;
     for (PRUint32 i = 0; i < count && NS_SUCCEEDED(rc); i++, info++)
     {