VirtualBox

Changeset 51612 in vbox for trunk/src/VBox/Main/src-client


Ignore:
Timestamp:
Jun 12, 2014 4:46:20 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
94351
Message:

6813 Use of server side API wrapper code - ConsoleImpl.cpp

Location:
trunk/src/VBox/Main/src-client
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/src-client/AudioSnifferInterface.cpp

    r45029 r51612  
    100100     */
    101101    VRDEAUDIOFORMAT format = VRDE_AUDIO_FMT_MAKE(samplesPerSec, nChannels, bitsPerSample, !fUnsigned);
    102     pDrv->pAudioSniffer->getParent()->consoleVRDPServer()->SendAudioSamples(pvSamples, cSamples, format);
     102    pDrv->pAudioSniffer->getParent()->i_consoleVRDPServer()->SendAudioSamples(pvSamples, cSamples, format);
    103103}
    104104
    … …  
    110110     * Just call the VRDP server with the data.
    111111     */
    112     pDrv->pAudioSniffer->getParent()->consoleVRDPServer()->SendAudioVolume(left, right);
     112    pDrv->pAudioSniffer->getParent()->i_consoleVRDPServer()->SendAudioVolume(left, right);
    113113}
    114114
    … …  
    123123    PDRVAUDIOSNIFFER pDrv = PDMIAUDIOSNIFFERCONNECTOR_2_MAINAUDIOSNIFFER(pInterface);
    124124
    125     return pDrv->pAudioSniffer->getParent()->consoleVRDPServer()->SendAudioInputBegin(ppvUserCtx,
     125    return pDrv->pAudioSniffer->getParent()->i_consoleVRDPServer()->SendAudioInputBegin(ppvUserCtx,
    126126                                                                                      pvContext,
    127127                                                                                      cSamples,
    … …  
    136136    PDRVAUDIOSNIFFER pDrv = PDMIAUDIOSNIFFERCONNECTOR_2_MAINAUDIOSNIFFER(pInterface);
    137137
    138     pDrv->pAudioSniffer->getParent()->consoleVRDPServer()->SendAudioInputEnd(pvUserCtx);
     138    pDrv->pAudioSniffer->getParent()->i_consoleVRDPServer()->SendAudioInputEnd(pvUserCtx);
    139139}
    140140

  • trunk/src/VBox/Main/src-client/BusAssignmentManager.cpp

    r50721 r51612  
    77
    88/*
    9  * Copyright (C) 2010-2013 Oracle Corporation
     9 * Copyright (C) 2010-2014 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    269269    const char* findAlias(const char* pszName);
    270270    void addMatchingRules(const char* pszName, PCIRulesList& aList);
    271     void listAttachedPCIDevices(ComSafeArrayOut(IPCIDeviceAttachment*, aAttached));
     271    void listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached);
    272272};
    273273
    … …  
    395395}
    396396
    397 
    398 void BusAssignmentManager::State::listAttachedPCIDevices(ComSafeArrayOut(IPCIDeviceAttachment*, aAttached))
    399 {
    400     com::SafeIfaceArray<IPCIDeviceAttachment> result(mPCIMap.size());
    401 
    402     size_t iIndex = 0;
     397void BusAssignmentManager::State::listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached)
     398{
     399    aAttached.resize(mPCIMap.size());
     400
     401    size_t i = 0;
    403402    ComObjPtr<PCIDeviceAttachment> dev;
    404     for (PCIMap::const_iterator it = mPCIMap.begin(); it !=  mPCIMap.end(); ++it)
     403    for (PCIMap::const_iterator it = mPCIMap.begin(); it !=  mPCIMap.end(); ++it, ++i)
    405404    {
    406405        dev.createObject();
    … …  
    409408                  it->second.HostAddress.valid() ? it->second.HostAddress.asLong() : -1,
    410409                  it->first.asLong(), it->second.HostAddress.valid());
    411         result.setElement(iIndex++, dev);
    412     }
    413 
    414     result.detachTo(ComSafeArrayOutArg(aAttached));
     410        dev.queryInterfaceTo(aAttached[i].asOutParam());
     411    }
    415412}
    416413
    … …  
    508505    return pState->findPCIAddress(pszDevName, iInstance, Address);
    509506}
    510 
    511 void BusAssignmentManager::listAttachedPCIDevices(ComSafeArrayOut(IPCIDeviceAttachment*, aAttached))
    512 {
    513     pState->listAttachedPCIDevices(ComSafeArrayOutArg(aAttached));
    514 }
     507void BusAssignmentManager::listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached)
     508{
     509    pState->listAttachedPCIDevices(aAttached);
     510}

  • trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

    r51552 r51612  
    317317            {
    318318                Bstr id;
    319                 ComPtr<IMachine> pMachine = mConsole->machine();
     319                ComPtr<IMachine> pMachine = mConsole->i_machine();
    320320                ComPtr<INATRedirectEvent> pNREv = aEvent;
    321321                HRESULT rc = E_FAIL;
    … …  
    346346                if (FAILED(rc))
    347347                    break;
    348                 mConsole->onNATRedirectRuleChange(ulSlot, fRemove, proto, hostIp.raw(), hostPort, guestIp.raw(), guestPort);
     348                mConsole->i_onNATRedirectRuleChange(ulSlot, fRemove, proto, hostIp.raw(), hostPort, guestIp.raw(), guestPort);
    349349            }
    350350            break;
    … …  
    373373                if (FAILED(hrc)) break;
    374374
    375                 mConsole->onExtraDataChange(strMachineId.raw(), strKey.raw(), strVal.raw());
     375                mConsole->i_onExtraDataChange(strMachineId.raw(), strKey.raw(), strVal.raw());
    376376                break;
    377377            }
    … …  
    448448    pVmm2UserMethods->u32Magic          = VMM2USERMETHODS_MAGIC;
    449449    pVmm2UserMethods->u32Version        = VMM2USERMETHODS_VERSION;
    450     pVmm2UserMethods->pfnSaveState      = Console::vmm2User_SaveState;
    451     pVmm2UserMethods->pfnNotifyEmtInit  = Console::vmm2User_NotifyEmtInit;
    452     pVmm2UserMethods->pfnNotifyEmtTerm  = Console::vmm2User_NotifyEmtTerm;
    453     pVmm2UserMethods->pfnNotifyPdmtInit = Console::vmm2User_NotifyPdmtInit;
    454     pVmm2UserMethods->pfnNotifyPdmtTerm = Console::vmm2User_NotifyPdmtTerm;
    455     pVmm2UserMethods->pfnNotifyResetTurnedIntoPowerOff = Console::vmm2User_NotifyResetTurnedIntoPowerOff;
     450    pVmm2UserMethods->pfnSaveState      = Console::i_vmm2User_SaveState;
     451    pVmm2UserMethods->pfnNotifyEmtInit  = Console::i_vmm2User_NotifyEmtInit;
     452    pVmm2UserMethods->pfnNotifyEmtTerm  = Console::i_vmm2User_NotifyEmtTerm;
     453    pVmm2UserMethods->pfnNotifyPdmtInit = Console::i_vmm2User_NotifyPdmtInit;
     454    pVmm2UserMethods->pfnNotifyPdmtTerm = Console::i_vmm2User_NotifyPdmtTerm;
     455    pVmm2UserMethods->pfnNotifyResetTurnedIntoPowerOff = Console::i_vmm2User_NotifyResetTurnedIntoPowerOff;
    456456    pVmm2UserMethods->u32EndMagic       = VMM2USERMETHODS_MAGIC;
    457457    pVmm2UserMethods->pConsole          = this;
    … …  
    542542        /* Grab global and machine shared folder lists */
    543543
    544         rc = fetchSharedFolders(true /* aGlobal */);
     544        rc = i_fetchSharedFolders(true /* aGlobal */);
    545545        AssertComRCReturnRC(rc);
    546         rc = fetchSharedFolders(false /* aGlobal */);
     546        rc = i_fetchSharedFolders(false /* aGlobal */);
    547547        AssertComRCReturnRC(rc);
    548548
    … …  
    671671    if (mpUVM)
    672672    {
    673         powerDown();
     673        i_powerDown();
    674674        Assert(mpUVM == NULL);
    675675    }
    … …  
    803803 *       back into the VM process and the HGCM service.)
    804804 */
    805 void Console::guestPropertiesHandleVMReset(void)
     805void Console::i_guestPropertiesHandleVMReset(void)
    806806{
    807807    com::SafeArray<BSTR>   arrNames;
    … …  
    809809    com::SafeArray<LONG64> arrTimestamps;
    810810    com::SafeArray<BSTR>   arrFlags;
    811     HRESULT hrc = enumerateGuestProperties(Bstr("*").raw(),
    812                                            ComSafeArrayAsOutParam(arrNames),
    813                                            ComSafeArrayAsOutParam(arrValues),
    814                                            ComSafeArrayAsOutParam(arrTimestamps),
    815                                            ComSafeArrayAsOutParam(arrFlags));
     811    HRESULT hrc = i_enumerateGuestProperties(Bstr("*").raw(),
     812                                             ComSafeArrayAsOutParam(arrNames),
     813                                             ComSafeArrayAsOutParam(arrValues),
     814                                             ComSafeArrayAsOutParam(arrTimestamps),
     815                                             ComSafeArrayAsOutParam(arrFlags));
    816816    if (SUCCEEDED(hrc))
    817817    {
    … …  
    832832}
    833833
    834 bool Console::guestPropertiesVRDPEnabled(void)
     834bool Console::i_guestPropertiesVRDPEnabled(void)
    835835{
    836836    Bstr value;
    … …  
    843843}
    844844
    845 void Console::guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain)
    846 {
    847     if (!guestPropertiesVRDPEnabled())
     845void Console::i_guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain)
     846{
     847    if (!i_guestPropertiesVRDPEnabled())
    848848        return;
    849849
    … …  
    880880}
    881881
    882 void Console::guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId)
    883 {
    884     if (!guestPropertiesVRDPEnabled())
     882void Console::i_guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId)
     883{
     884    if (!i_guestPropertiesVRDPEnabled())
    885885        return;
    886886
    … …  
    899899}
    900900
    901 void Console::guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName)
    902 {
    903     if (!guestPropertiesVRDPEnabled())
     901void Console::i_guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName)
     902{
     903    if (!i_guestPropertiesVRDPEnabled())
    904904        return;
    905905
    … …  
    918918}
    919919
    920 void Console::guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr)
    921 {
    922     if (!guestPropertiesVRDPEnabled())
     920void Console::i_guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr)
     921{
     922    if (!i_guestPropertiesVRDPEnabled())
    923923        return;
    924924
    … …  
    937937}
    938938
    939 void Console::guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation)
    940 {
    941     if (!guestPropertiesVRDPEnabled())
     939void Console::i_guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation)
     940{
     941    if (!i_guestPropertiesVRDPEnabled())
    942942        return;
    943943
    … …  
    956956}
    957957
    958 void Console::guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo)
    959 {
    960     if (!guestPropertiesVRDPEnabled())
     958void Console::i_guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo)
     959{
     960    if (!i_guestPropertiesVRDPEnabled())
    961961        return;
    962962
    … …  
    975975}
    976976
    977 void Console::guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached)
    978 {
    979     if (!guestPropertiesVRDPEnabled())
     977void Console::i_guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached)
     978{
     979    if (!i_guestPropertiesVRDPEnabled())
    980980        return;
    981981
    … …  
    994994}
    995995
    996 void Console::guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId)
    997 {
    998     if (!guestPropertiesVRDPEnabled())
     996void Console::i_guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId)
     997{
     998    if (!i_guestPropertiesVRDPEnabled())
    999999        return;
    10001000
    … …  
    10311031#endif /* VBOX_WITH_GUEST_PROPS */
    10321032
    1033 bool Console::isResetTurnedIntoPowerOff(void)
     1033bool Console::i_isResetTurnedIntoPowerOff(void)
    10341034{
    10351035    Bstr value;
    … …  
    10481048 * @returns The extension pack manager.
    10491049 */
    1050 ExtPackManager *Console::getExtPackManager()
     1050ExtPackManager *Console::i_getExtPackManager()
    10511051{
    10521052    return mptrExtPackManager;
    … …  
    10551055
    10561056
    1057 int Console::VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
     1057int Console::i_VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
    10581058{
    10591059    LogFlowFuncEnter();
    … …  
    12491249
    12501250#ifdef VBOX_WITH_GUEST_PROPS
    1251     guestPropertiesVRDPUpdateLogon(u32ClientId, pszUser, pszDomain);
     1251    i_guestPropertiesVRDPUpdateLogon(u32ClientId, pszUser, pszDomain);
    12521252#endif /* VBOX_WITH_GUEST_PROPS */
    12531253
    … …  
    12651265        Bstr flags;
    12661266
    1267         hrc = getGuestProperty(Bstr("/VirtualBox/GuestInfo/OS/NoLoggedInUsers").raw(),
    1268                                noLoggedInUsersValue.asOutParam(), &ul64Timestamp, flags.asOutParam());
     1267        hrc = i_getGuestProperty(Bstr("/VirtualBox/GuestInfo/OS/NoLoggedInUsers").raw(),
     1268                                 noLoggedInUsersValue.asOutParam(), &ul64Timestamp, flags.asOutParam());
    12691269
    12701270        if (SUCCEEDED(hrc) && noLoggedInUsersValue != Bstr("false"))
    … …  
    12961296}
    12971297
    1298 void Console::VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus)
     1298void Console::i_VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus)
    12991299{
    13001300    LogFlowFuncEnter();
    … …  
    13091309    if (RTStrICmp(pszStatus, "ATTACH") == 0)
    13101310    {
    1311         guestPropertiesVRDPUpdateClientAttach(u32ClientId, true);
     1311        i_guestPropertiesVRDPUpdateClientAttach(u32ClientId, true);
    13121312    }
    13131313    else if (RTStrICmp(pszStatus, "DETACH") == 0)
    13141314    {
    1315         guestPropertiesVRDPUpdateClientAttach(u32ClientId, false);
     1315        i_guestPropertiesVRDPUpdateClientAttach(u32ClientId, false);
    13161316    }
    13171317    else if (RTStrNICmp(pszStatus, "NAME=", strlen("NAME=")) == 0)
    13181318    {
    1319         guestPropertiesVRDPUpdateNameChange(u32ClientId, pszStatus + strlen("NAME="));
     1319        i_guestPropertiesVRDPUpdateNameChange(u32ClientId, pszStatus + strlen("NAME="));
    13201320    }
    13211321    else if (RTStrNICmp(pszStatus, "CIPA=", strlen("CIPA=")) == 0)
    13221322    {
    1323         guestPropertiesVRDPUpdateIPAddrChange(u32ClientId, pszStatus + strlen("CIPA="));
     1323        i_guestPropertiesVRDPUpdateIPAddrChange(u32ClientId, pszStatus + strlen("CIPA="));
    13241324    }
    13251325    else if (RTStrNICmp(pszStatus, "CLOCATION=", strlen("CLOCATION=")) == 0)
    13261326    {
    1327         guestPropertiesVRDPUpdateLocationChange(u32ClientId, pszStatus + strlen("CLOCATION="));
     1327        i_guestPropertiesVRDPUpdateLocationChange(u32ClientId, pszStatus + strlen("CLOCATION="));
    13281328    }
    13291329    else if (RTStrNICmp(pszStatus, "COINFO=", strlen("COINFO=")) == 0)
    13301330    {
    1331         guestPropertiesVRDPUpdateOtherInfoChange(u32ClientId, pszStatus + strlen("COINFO="));
     1331        i_guestPropertiesVRDPUpdateOtherInfoChange(u32ClientId, pszStatus + strlen("COINFO="));
    13321332    }
    13331333#endif
    … …  
    13361336}
    13371337
    1338 void Console::VRDPClientConnect(uint32_t u32ClientId)
     1338void Console::i_VRDPClientConnect(uint32_t u32ClientId)
    13391339{
    13401340    LogFlowFuncEnter();
    … …  
    13471347    PPDMIVMMDEVPORT pPort;
    13481348    if (    (u32Clients == 1)
    1349          && ((pDev = getVMMDev()))
     1349         && ((pDev = i_getVMMDev()))
    13501350         && ((pPort = pDev->getVMMDevPort()))
    13511351       )
    … …  
    13601360
    13611361#ifdef VBOX_WITH_GUEST_PROPS
    1362     guestPropertiesVRDPUpdateActiveClient(u32ClientId);
     1362    i_guestPropertiesVRDPUpdateActiveClient(u32ClientId);
    13631363#endif /* VBOX_WITH_GUEST_PROPS */
    13641364
    … …  
    13671367}
    13681368
    1369 void Console::VRDPClientDisconnect(uint32_t u32ClientId,
    1370                                    uint32_t fu32Intercepted)
     1369void Console::i_VRDPClientDisconnect(uint32_t u32ClientId,
     1370                                     uint32_t fu32Intercepted)
    13711371{
    13721372    LogFlowFuncEnter();
    … …  
    13821382
    13831383    if (    (u32Clients == 0)
    1384          && ((pDev = getVMMDev()))
     1384         && ((pDev = i_getVMMDev()))
    13851385         && ((pPort = pDev->getVMMDevPort()))
    13861386       )
    … …  
    14341434
    14351435#ifdef VBOX_WITH_GUEST_PROPS
    1436     guestPropertiesVRDPUpdateDisconnect(u32ClientId);
     1436    i_guestPropertiesVRDPUpdateDisconnect(u32ClientId);
    14371437    if (u32Clients == 0)
    1438         guestPropertiesVRDPUpdateActiveClient(0);
     1438        i_guestPropertiesVRDPUpdateActiveClient(0);
    14391439#endif /* VBOX_WITH_GUEST_PROPS */
    14401440
    … …  
    14461446}
    14471447
    1448 void Console::VRDPInterceptAudio(uint32_t u32ClientId)
     1448void Console::i_VRDPInterceptAudio(uint32_t u32ClientId)
    14491449{
    14501450    LogFlowFuncEnter();
    … …  
    14781478}
    14791479
    1480 void Console::VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept)
     1480void Console::i_VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept)
    14811481{
    14821482    LogFlowFuncEnter();
    … …  
    14931493}
    14941494
    1495 void Console::VRDPInterceptClipboard(uint32_t u32ClientId)
     1495void Console::i_VRDPInterceptClipboard(uint32_t u32ClientId)
    14961496{
    14971497    LogFlowFuncEnter();
    … …  
    15481548 * @note The caller must lock this object for writing.
    15491549 */
    1550 HRESULT Console::loadDataFromSavedState()
     1550HRESULT Console::i_loadDataFromSavedState()
    15511551{
    15521552    if (mMachineState != MachineState_Saved || mSavedStateDataLoaded)
    … …  
    15671567        {
    15681568            if (RT_SUCCESS(vrc))
    1569                 vrc = loadStateFileExecInternal(ssm, version);
     1569                vrc = i_loadStateFileExecInternal(ssm, version);
    15701570            else if (vrc == VERR_SSM_UNIT_NOT_FOUND)
    15711571                vrc = VINF_SUCCESS;
    … …  
    15961596 */
    15971597//static
    1598 DECLCALLBACK(void)
    1599 Console::saveStateFileExec(PSSMHANDLE pSSM, void *pvUser)
     1598DECLCALLBACK(void) Console::i_saveStateFileExec(PSSMHANDLE pSSM, void *pvUser)
    16001599{
    16011600    LogFlowFunc(("\n"));
    … …  
    16551654//static
    16561655DECLCALLBACK(int)
    1657 Console::loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
     1656Console::i_loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
    16581657{
    16591658    LogFlowFunc(("\n"));
    … …  
    16801679 * @note Locks the Console object for writing.
    16811680 */
    1682 int
    1683 Console::loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version)
     1681int Console::i_loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version)
    16841682{
    16851683    AutoCaller autoCaller(this);
    … …  
    17451743
    17461744// static
    1747 DECLCALLBACK(int) Console::doGuestPropNotification(void *pvExtension,
    1748                                                    uint32_t u32Function,
    1749                                                    void *pvParms,
    1750                                                    uint32_t cbParms)
     1745DECLCALLBACK(int) Console::i_doGuestPropNotification(void *pvExtension,
     1746                                                     uint32_t u32Function,
     1747                                                     void *pvParms,
     1748                                                     uint32_t cbParms)
    17511749{
    17521750    using namespace guestProp;
    … …  
    17841782}
    17851783
    1786 HRESULT Console::doEnumerateGuestProperties(CBSTR aPatterns,
    1787                                             ComSafeArrayOut(BSTR, aNames),
    1788                                             ComSafeArrayOut(BSTR, aValues),
    1789                                             ComSafeArrayOut(LONG64, aTimestamps),
    1790                                             ComSafeArrayOut(BSTR, aFlags))
     1784HRESULT Console::i_doEnumerateGuestProperties(CBSTR aPatterns,
     1785                                              ComSafeArrayOut(BSTR, aNames),
     1786                                              ComSafeArrayOut(BSTR, aValues),
     1787                                              ComSafeArrayOut(LONG64, aTimestamps),
     1788                                              ComSafeArrayOut(BSTR, aFlags))
    17911789{
    17921790    AssertReturn(m_pVMMDev, E_FAIL);
    … …  
    18881886// IConsole properties
    18891887/////////////////////////////////////////////////////////////////////////////
    1890 
    1891 STDMETHODIMP Console::COMGETTER(Machine)(IMachine **aMachine)
    1892 {
    1893     CheckComArgOutPointerValid(aMachine);
    1894 
    1895     AutoCaller autoCaller(this);
    1896     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1897 
     1888HRESULT Console::getMachine(ComPtr<IMachine> &aMachine)
     1889{
    18981890    /* mMachine is constant during life time, no need to lock */
    1899     mMachine.queryInterfaceTo(aMachine);
     1891    mMachine.queryInterfaceTo(aMachine.asOutParam());
    19001892
    19011893    /* callers expect to get a valid reference, better fail than crash them */
    … …  
    19061898}
    19071899
    1908 STDMETHODIMP Console::COMGETTER(State)(MachineState_T *aMachineState)
    1909 {
    1910     CheckComArgOutPointerValid(aMachineState);
    1911 
    1912     AutoCaller autoCaller(this);
    1913     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1914 
     1900HRESULT Console::getState(MachineState_T *aState)
     1901{
    19151902    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    19161903
    19171904    /* we return our local state (since it's always the same as on the server) */
    1918     *aMachineState = mMachineState;
     1905    *aState = mMachineState;
    19191906
    19201907    return S_OK;
    19211908}
    19221909
    1923 STDMETHODIMP Console::COMGETTER(Guest)(IGuest **aGuest)
    1924 {
    1925     CheckComArgOutPointerValid(aGuest);
    1926 
    1927     AutoCaller autoCaller(this);
    1928     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1929 
     1910HRESULT Console::getGuest(ComPtr<IGuest> &aGuest)
     1911{
    19301912    /* mGuest is constant during life time, no need to lock */
    1931     mGuest.queryInterfaceTo(aGuest);
     1913    mGuest.queryInterfaceTo(aGuest.asOutParam());
    19321914
    19331915    return S_OK;
    19341916}
    19351917
    1936 STDMETHODIMP Console::COMGETTER(Keyboard)(IKeyboard **aKeyboard)
    1937 {
    1938     CheckComArgOutPointerValid(aKeyboard);
    1939 
    1940     AutoCaller autoCaller(this);
    1941     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1942 
     1918HRESULT Console::getKeyboard(ComPtr<IKeyboard> &aKeyboard)
     1919{
    19431920    /* mKeyboard is constant during life time, no need to lock */
    1944     mKeyboard.queryInterfaceTo(aKeyboard);
     1921    mKeyboard.queryInterfaceTo(aKeyboard.asOutParam());
    19451922
    19461923    return S_OK;
    19471924}
    19481925
    1949 STDMETHODIMP Console::COMGETTER(Mouse)(IMouse **aMouse)
    1950 {
    1951     CheckComArgOutPointerValid(aMouse);
    1952 
    1953     AutoCaller autoCaller(this);
    1954     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1955 
     1926HRESULT Console::getMouse(ComPtr<IMouse> &aMouse)
     1927{
    19561928    /* mMouse is constant during life time, no need to lock */
    1957     mMouse.queryInterfaceTo(aMouse);
     1929    mMouse.queryInterfaceTo(aMouse.asOutParam());
    19581930
    19591931    return S_OK;
    19601932}
    19611933
    1962 STDMETHODIMP Console::COMGETTER(Display)(IDisplay **aDisplay)
    1963 {
    1964     CheckComArgOutPointerValid(aDisplay);
    1965 
    1966     AutoCaller autoCaller(this);
    1967     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1968 
     1934HRESULT Console::getDisplay(ComPtr<IDisplay> &aDisplay)
     1935{
    19691936    /* mDisplay is constant during life time, no need to lock */
    1970     mDisplay.queryInterfaceTo(aDisplay);
     1937    mDisplay.queryInterfaceTo(aDisplay.asOutParam());
    19711938
    19721939    return S_OK;
    19731940}
    19741941
    1975 STDMETHODIMP Console::COMGETTER(Debugger)(IMachineDebugger **aDebugger)
    1976 {
    1977     CheckComArgOutPointerValid(aDebugger);
    1978 
    1979     AutoCaller autoCaller(this);
    1980     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    1981 
     1942HRESULT Console::getDebugger(ComPtr<IMachineDebugger> &aDebugger)
     1943{
    19821944    /* we need a write lock because of the lazy mDebugger initialization*/
    19831945    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    19901952    }
    19911953
    1992     mDebugger.queryInterfaceTo(aDebugger);
     1954    mDebugger.queryInterfaceTo(aDebugger.asOutParam());
    19931955
    19941956    return S_OK;
    19951957}
    19961958
    1997 STDMETHODIMP Console::COMGETTER(USBDevices)(ComSafeArrayOut(IUSBDevice *, aUSBDevices))
    1998 {
    1999     CheckComArgOutSafeArrayPointerValid(aUSBDevices);
    2000 
    2001     AutoCaller autoCaller(this);
    2002     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2003 
     1959HRESULT Console::getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices)
     1960{
    20041961    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    20051962
    2006     SafeIfaceArray<IUSBDevice> collection(mUSBDevices);
    2007     collection.detachTo(ComSafeArrayOutArg(aUSBDevices));
     1963    size_t i = 0;
     1964    for (USBDeviceList::const_iterator it = mUSBDevices.begin(); it != mUSBDevices.end(); ++i, ++it)
     1965        (*it).queryInterfaceTo(aUSBDevices[i].asOutParam());
    20081966
    20091967    return S_OK;
    20101968}
    20111969
    2012 STDMETHODIMP Console::COMGETTER(RemoteUSBDevices)(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices))
    2013 {
    2014     CheckComArgOutSafeArrayPointerValid(aRemoteUSBDevices);
    2015 
    2016     AutoCaller autoCaller(this);
    2017     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2018 
     1970
     1971HRESULT Console::getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices)
     1972{
    20191973    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    20201974
    2021     SafeIfaceArray<IHostUSBDevice> collection(mRemoteUSBDevices);
    2022     collection.detachTo(ComSafeArrayOutArg(aRemoteUSBDevices));
     1975    size_t i = 0;
     1976    for (RemoteUSBDeviceList::const_iterator it = mRemoteUSBDevices.begin(); it != mRemoteUSBDevices.end(); ++i, ++it)
     1977        (*it).queryInterfaceTo(aRemoteUSBDevices[i].asOutParam());
    20231978
    20241979    return S_OK;
    20251980}
    20261981
    2027 STDMETHODIMP Console::COMGETTER(VRDEServerInfo)(IVRDEServerInfo **aVRDEServerInfo)
    2028 {
    2029     CheckComArgOutPointerValid(aVRDEServerInfo);
    2030 
    2031     AutoCaller autoCaller(this);
    2032     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2033 
     1982HRESULT Console::getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo)
     1983{
    20341984    /* mVRDEServerInfo is constant during life time, no need to lock */
    2035     mVRDEServerInfo.queryInterfaceTo(aVRDEServerInfo);
     1985    mVRDEServerInfo.queryInterfaceTo(aVRDEServerInfo.asOutParam());
    20361986
    20371987    return S_OK;
    20381988}
    20391989
    2040 STDMETHODIMP Console::COMGETTER(EmulatedUSB)(IEmulatedUSB **aEmulatedUSB)
    2041 {
    2042     CheckComArgOutPointerValid(aEmulatedUSB);
    2043 
    2044     AutoCaller autoCaller(this);
    2045     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2046 
     1990HRESULT Console::getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB)
     1991{
    20471992    /* mEmulatedUSB is constant during life time, no need to lock */
    2048     mEmulatedUSB.queryInterfaceTo(aEmulatedUSB);
     1993    mEmulatedUSB.queryInterfaceTo(aEmulatedUSB.asOutParam());
    20491994
    20501995    return S_OK;
    20511996}
    20521997
    2053 STDMETHODIMP
    2054 Console::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
    2055 {
    2056     CheckComArgOutSafeArrayPointerValid(aSharedFolders);
    2057 
    2058     AutoCaller autoCaller(this);
    2059     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2060 
     1998HRESULT Console::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
     1999{
    20612000    /* loadDataFromSavedState() needs a write lock */
    20622001    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    20632002
    20642003    /* Read console data stored in the saved state file (if not yet done) */
    2065     HRESULT rc = loadDataFromSavedState();
     2004    HRESULT rc = i_loadDataFromSavedState();
    20662005    if (FAILED(rc)) return rc;
    20672006
    2068     SafeIfaceArray<ISharedFolder> sf(m_mapSharedFolders);
    2069     sf.detachTo(ComSafeArrayOutArg(aSharedFolders));
     2007    size_t i = 0;
     2008    for (SharedFolderMap::const_iterator it = m_mapSharedFolders.begin(); it != m_mapSharedFolders.end(); ++i, ++it)
     2009        (it)->second.queryInterfaceTo(aSharedFolders[i].asOutParam());
    20702010
    20712011    return S_OK;
    20722012}
    20732013
    2074 
    2075 STDMETHODIMP Console::COMGETTER(EventSource)(IEventSource ** aEventSource)
    2076 {
    2077     CheckComArgOutPointerValid(aEventSource);
    2078 
    2079     AutoCaller autoCaller(this);
    2080     HRESULT hrc = autoCaller.rc();
    2081     if (SUCCEEDED(hrc))
    2082     {
    2083         // no need to lock - lifetime constant
    2084         mEventSource.queryInterfaceTo(aEventSource);
    2085     }
    2086 
    2087     return hrc;
    2088 }
    2089 
    2090 STDMETHODIMP Console::COMGETTER(AttachedPCIDevices)(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachments))
    2091 {
    2092     CheckComArgOutSafeArrayPointerValid(aAttachments);
    2093 
    2094     AutoCaller autoCaller(this);
    2095     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2096 
     2014HRESULT Console::getEventSource(ComPtr<IEventSource> &aEventSource)
     2015{
     2016    // no need to lock - lifetime constant
     2017    mEventSource.queryInterfaceTo(aEventSource.asOutParam());
     2018
     2019    return S_OK;
     2020}
     2021
     2022HRESULT Console::getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices)
     2023{
    20972024    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    20982025
    20992026    if (mBusMgr)
    2100         mBusMgr->listAttachedPCIDevices(ComSafeArrayOutArg(aAttachments));
     2027        mBusMgr->listAttachedPCIDevices(aAttachedPCIDevices);
    21012028    else
    2102     {
    2103         com::SafeIfaceArray<IPCIDeviceAttachment> result((size_t)0);
    2104         result.detachTo(ComSafeArrayOutArg(aAttachments));
    2105     }
     2029        aAttachedPCIDevices.resize(0);
    21062030
    21072031    return S_OK;
    21082032}
    21092033
    2110 STDMETHODIMP Console::COMGETTER(UseHostClipboard)(BOOL *aUseHostClipboard)
    2111 {
    2112     CheckComArgOutPointerValid(aUseHostClipboard);
    2113 
    2114     AutoCaller autoCaller(this);
    2115     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2116 
     2034HRESULT Console::getUseHostClipboard(BOOL *aUseHostClipboard)
     2035{
    21172036    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    21182037
    … …  
    21222041}
    21232042
    2124 STDMETHODIMP Console::COMSETTER(UseHostClipboard)(BOOL aUseHostClipboard)
    2125 {
    2126     AutoCaller autoCaller(this);
    2127     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2128 
    2129     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    2130 
     2043HRESULT Console::setUseHostClipboard(BOOL aUseHostClipboard)
     2044{
    21312045    mfUseHostClipboard = !!aUseHostClipboard;
    21322046
    … …  
    21372051/////////////////////////////////////////////////////////////////////////////
    21382052
    2139 
    2140 STDMETHODIMP Console::PowerUp(IProgress **aProgress)
    2141 {
    2142     return powerUp(aProgress, false /* aPaused */);
    2143 }
    2144 
    2145 STDMETHODIMP Console::PowerUpPaused(IProgress **aProgress)
    2146 {
    2147     return powerUp(aProgress, true /* aPaused */);
    2148 }
    2149 
    2150 STDMETHODIMP Console::PowerDown(IProgress **aProgress)
     2053HRESULT Console::powerUp(ComPtr<IProgress> &aProgress)
     2054{
     2055    ComObjPtr<IProgress> pProgress;
     2056    i_powerUp(pProgress.asOutParam(), false /* aPaused */);
     2057    pProgress.queryInterfaceTo(aProgress.asOutParam());
     2058    return S_OK;
     2059}
     2060
     2061HRESULT Console::powerUpPaused(ComPtr<IProgress> &aProgress)
     2062{
     2063    ComObjPtr<IProgress> pProgress;
     2064    i_powerUp(pProgress.asOutParam(), true /* aPaused */);
     2065    pProgress.queryInterfaceTo(aProgress.asOutParam());
     2066    return S_OK;
     2067}
     2068
     2069HRESULT Console::powerDown(ComPtr<IProgress> &aProgress)
    21512070{
    21522071    LogFlowThisFuncEnter();
    2153 
    2154     CheckComArgOutPointerValid(aProgress);
    2155 
    2156     AutoCaller autoCaller(this);
    2157     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    21582072
    21592073    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    22242138        alock.release();
    22252139
    2226         if (isResetTurnedIntoPowerOff())
     2140        if (i_isResetTurnedIntoPowerOff())
    22272141        {
    22282142            mMachine->DeleteGuestProperty(Bstr("/VirtualBox/HostInfo/VMPowerOffReason").raw());
    … …  
    22472161
    22482162        /* sync the state with the server */
    2249         setMachineStateLocally(MachineState_Stopping);
     2163        i_setMachineStateLocally(MachineState_Stopping);
    22502164
    22512165        /* setup task object and thread to carry out the operation asynchronously */
    … …  
    22532167        AssertBreakStmt(task->isOk(), rc = E_FAIL);
    22542168
    2255         int vrc = RTThreadCreate(NULL, Console::powerDownThread,
     2169        int vrc = RTThreadCreate(NULL, Console::i_powerDownThread,
    22562170                                 (void *) task.get(), 0,
    22572171                                 RTTHREADTYPE_MAIN_WORKER, 0,
    … …  
    22672181
    22682182        /* pass the progress to the caller */
    2269         pProgress.queryInterfaceTo(aProgress);
     2183        pProgress.queryInterfaceTo(aProgress.asOutParam());
    22702184    }
    22712185    while (0);
    … …  
    22852199            mControl->EndPoweringDown(eik.getResultCode(), eik.getText().raw());        }
    22862200
    2287         setMachineStateLocally(lastMachineState);
     2201        i_setMachineStateLocally(lastMachineState);
    22882202    }
    22892203
    … …  
    22942208}
    22952209
    2296 STDMETHODIMP Console::Reset()
     2210HRESULT Console::reset()
    22972211{
    22982212    LogFlowThisFuncEnter();
    2299 
    2300     AutoCaller autoCaller(this);
    2301     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    23022213
    23032214    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    23092220        /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
    23102221       )
    2311         return setInvalidMachineStateError();
     2222        return i_setInvalidMachineStateError();
    23122223
    23132224    /* protect mpUVM */
    … …  
    23312242}
    23322243
    2333 /*static*/ DECLCALLBACK(int) Console::unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
     2244/*static*/ DECLCALLBACK(int) Console::i_unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
    23342245{
    23352246    LogFlowFunc(("pThis=%p pVM=%p idCpu=%u\n", pThis, pUVM, idCpu));
    … …  
    23432254}
    23442255
    2345 HRESULT Console::doCPURemove(ULONG aCpu, PUVM pUVM)
     2256HRESULT Console::i_doCPURemove(ULONG aCpu, PUVM pUVM)
    23462257{
    23472258    HRESULT rc = S_OK;
    … …  
    23632274        && mMachineState != MachineState_LiveSnapshotting
    23642275       )
    2365         return setInvalidMachineStateError();
     2276        return i_setInvalidMachineStateError();
    23662277
    23672278    /* Check if the CPU is present */
    … …  
    24202331        PVMREQ pReq;
    24212332        vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    2422                            (PFNRT)unplugCpu, 3,
     2333                           (PFNRT)i_unplugCpu, 3,
    24232334                           this, pUVM, (VMCPUID)aCpu);
    24242335        if (vrc == VERR_TIMEOUT || RT_SUCCESS(vrc))
    … …  
    24502361}
    24512362
    2452 /*static*/ DECLCALLBACK(int) Console::plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
     2363/*static*/ DECLCALLBACK(int) Console::i_plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu)
    24532364{
    24542365    LogFlowFunc(("pThis=%p uCpu=%u\n", pThis, idCpu));
    … …  
    24872398}
    24882399
    2489 HRESULT Console::doCPUAdd(ULONG aCpu, PUVM pUVM)
     2400HRESULT Console::i_doCPUAdd(ULONG aCpu, PUVM pUVM)
    24902401{
    24912402    HRESULT rc = S_OK;
    … …  
    25042415        /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
    25052416       )
    2506         return setInvalidMachineStateError();
     2417        return i_setInvalidMachineStateError();
    25072418
    25082419    AssertReturn(m_pVMMDev, E_FAIL);
    … …  
    25262437    PVMREQ pReq;
    25272438    int vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    2528                            (PFNRT)plugCpu, 3,
     2439                           (PFNRT)i_plugCpu, 3,
    25292440                           this, pUVM, aCpu);
    25302441
    … …  
    25612472}
    25622473
    2563 STDMETHODIMP Console::Pause()
     2474HRESULT Console::pause()
    25642475{
    25652476    LogFlowThisFuncEnter();
    25662477
    2567     HRESULT rc = pause(Reason_Unspecified);
     2478    HRESULT rc = i_pause(Reason_Unspecified);
    25682479
    25692480    LogFlowThisFunc(("rc=%Rhrc\n", rc));
    … …  
    25722483}
    25732484
    2574 STDMETHODIMP Console::Resume()
     2485HRESULT Console::resume()
    25752486{
    25762487    LogFlowThisFuncEnter();
    25772488
    2578     HRESULT rc = resume(Reason_Unspecified);
     2489    HRESULT rc = i_resume(Reason_Unspecified);
    25792490
    25802491    LogFlowThisFunc(("rc=%Rhrc\n", rc));
    … …  
    25832494}
    25842495
    2585 STDMETHODIMP Console::PowerButton()
     2496HRESULT Console::powerButton()
    25862497{
    25872498    LogFlowThisFuncEnter();
    2588 
    2589     AutoCaller autoCaller(this);
    2590     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    25912499
    25922500    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    25962504        && mMachineState != MachineState_LiveSnapshotting
    25972505       )
    2598         return setInvalidMachineStateError();
     2506        return i_setInvalidMachineStateError();
    25992507
    26002508    /* get the VM handle. */
    … …  
    26282536}
    26292537
    2630 STDMETHODIMP Console::GetPowerButtonHandled(BOOL *aHandled)
     2538HRESULT Console::getPowerButtonHandled(BOOL *aHandled)
    26312539{
    26322540    LogFlowThisFuncEnter();
    26332541
    2634     CheckComArgOutPointerValid(aHandled);
    2635 
    26362542    *aHandled = FALSE;
    2637 
    2638     AutoCaller autoCaller(this);
    26392543
    26402544    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    26442548        && mMachineState != MachineState_LiveSnapshotting
    26452549       )
    2646         return setInvalidMachineStateError();
     2550        return i_setInvalidMachineStateError();
    26472551
    26482552    /* get the VM handle. */
    … …  
    26812585}
    26822586
    2683 STDMETHODIMP Console::GetGuestEnteredACPIMode(BOOL *aEntered)
     2587HRESULT Console::getGuestEnteredACPIMode(BOOL *aEntered)
    26842588{
    26852589    LogFlowThisFuncEnter();
    26862590
    2687     CheckComArgOutPointerValid(aEntered);
    2688 
    26892591    *aEntered = FALSE;
    2690 
    2691     AutoCaller autoCaller(this);
    26922592
    26932593    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    27302630}
    27312631
    2732 STDMETHODIMP Console::SleepButton()
     2632HRESULT Console::sleepButton()
    27332633{
    27342634    LogFlowThisFuncEnter();
    2735 
    2736     AutoCaller autoCaller(this);
    2737     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    27382635
    27392636    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    27422639        && mMachineState != MachineState_Teleporting
    27432640        && mMachineState != MachineState_LiveSnapshotting)
    2744         return setInvalidMachineStateError();
     2641        return i_setInvalidMachineStateError();
    27452642
    27462643    /* get the VM handle. */
    … …  
    27742671}
    27752672
    2776 STDMETHODIMP Console::SaveState(IProgress **aProgress)
     2673HRESULT Console::saveState(ComPtr<IProgress> &aProgress)
    27772674{
    27782675    LogFlowThisFuncEnter();
    2779 
    2780     HRESULT rc = saveState(Reason_Unspecified, aProgress);
     2676    ComObjPtr<IProgress> pProgress;
     2677
     2678    HRESULT rc = i_saveState(Reason_Unspecified, pProgress.asOutParam());
     2679    pProgress.queryInterfaceTo(aProgress.asOutParam());
    27812680
    27822681    LogFlowThisFunc(("rc=%Rhrc\n", rc));
    … …  
    27852684}
    27862685
    2787 STDMETHODIMP Console::AdoptSavedState(IN_BSTR aSavedStateFile)
    2788 {
    2789     CheckComArgStrNotEmptyOrNull(aSavedStateFile);
    2790 
    2791     AutoCaller autoCaller(this);
    2792     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2793 
     2686HRESULT Console::adoptSavedState(const com::Utf8Str &aSavedStateFile)
     2687{
    27942688    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    27952689
    … …  
    28022696            Global::stringifyMachineState(mMachineState));
    28032697
    2804     return mControl->AdoptSavedState(aSavedStateFile);
    2805 }
    2806 
    2807 STDMETHODIMP Console::DiscardSavedState(BOOL aRemoveFile)
    2808 {
    2809     AutoCaller autoCaller(this);
    2810     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2811 
     2698    return mControl->AdoptSavedState(BSTR(aSavedStateFile.c_str()));
     2699}
     2700
     2701HRESULT Console::discardSavedState(BOOL aFRemoveFile)
     2702{
    28122703    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    28132704
    … …  
    28172708            Global::stringifyMachineState(mMachineState));
    28182709
    2819     HRESULT rc = mControl->SetRemoveSavedStateFile(aRemoveFile);
     2710    HRESULT rc = mControl->SetRemoveSavedStateFile(aFRemoveFile);
    28202711    if (FAILED(rc)) return rc;
    28212712
    … …  
    28242715     * and properly handled.
    28252716     */
    2826     rc = setMachineState(MachineState_PoweredOff);
     2717    rc = i_setMachineState(MachineState_PoweredOff);
    28272718
    28282719    return rc;
    … …  
    28392730}
    28402731
    2841 STDMETHODIMP Console::GetDeviceActivity(DeviceType_T aDeviceType,
    2842                                         DeviceActivity_T *aDeviceActivity)
    2843 {
    2844     CheckComArgNotNull(aDeviceActivity);
    2845 
    2846     AutoCaller autoCaller(this);
    2847     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2848 
     2732HRESULT Console::getDeviceActivity(DeviceType_T aType,
     2733                                   DeviceActivity_T *aActivity)
     2734{
    28492735    /*
    28502736     * Note: we don't lock the console object here because
    … …  
    28542740    /* Get LED array to read */
    28552741    PDMLEDCORE SumLed = {0};
    2856     switch (aDeviceType)
     2742    switch (aType)
    28572743    {
    28582744        case DeviceType_Floppy:
    … …  
    28612747        {
    28622748            for (unsigned i = 0; i < RT_ELEMENTS(mapStorageLeds); ++i)
    2863                 if (maStorageDevType[i] == aDeviceType)
     2749                if (maStorageDevType[i] == aType)
    28642750                    SumLed.u32 |= readAndClearLed(mapStorageLeds[i]);
    28652751            break;
    … …  
    28952781            return setError(E_INVALIDARG,
    28962782                tr("Invalid device type: %d"),
    2897                 aDeviceType);
     2783                aType);
    28982784    }
    28992785
    … …  
    29022788    {
    29032789        case 0:
    2904             *aDeviceActivity = DeviceActivity_Idle;
     2790            *aActivity = DeviceActivity_Idle;
    29052791            break;
    29062792        case PDMLED_READING:
    2907             *aDeviceActivity = DeviceActivity_Reading;
     2793            *aActivity = DeviceActivity_Reading;
    29082794            break;
    29092795        case PDMLED_WRITING:
    29102796        case PDMLED_READING | PDMLED_WRITING:
    2911             *aDeviceActivity = DeviceActivity_Writing;
     2797            *aActivity = DeviceActivity_Writing;
    29122798            break;
    29132799    }
    … …  
    29162802}
    29172803
    2918 STDMETHODIMP Console::AttachUSBDevice(IN_BSTR aId)
     2804HRESULT Console::attachUSBDevice(const com::Guid &aId)
    29192805{
    29202806#ifdef VBOX_WITH_USB
    2921     AutoCaller autoCaller(this);
    2922     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    2923 
    29242807    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    29252808
    … …  
    29452828
    29462829    /* Request the device capture */
    2947     return mControl->CaptureUSBDevice(aId);
     2830    return mControl->CaptureUSBDevice(BSTR(aId.toString().c_str()));
    29482831
    29492832#else   /* !VBOX_WITH_USB */
    … …  
    29532836}
    29542837
    2955 STDMETHODIMP Console::DetachUSBDevice(IN_BSTR aId, IUSBDevice **aDevice)
     2838HRESULT Console::detachUSBDevice(const com::Guid &aId, ComPtr<IUSBDevice> &aDevice)
    29562839{
    29572840#ifdef VBOX_WITH_USB
    2958     CheckComArgOutPointerValid(aDevice);
    2959 
    2960     AutoCaller autoCaller(this);
    2961     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    29622841
    29632842    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    29662845    ComObjPtr<OUSBDevice> pUSBDevice;
    29672846    USBDeviceList::iterator it = mUSBDevices.begin();
    2968     Guid uuid(aId);
    29692847    while (it != mUSBDevices.end())
    29702848    {
    2971         if ((*it)->i_id() == uuid)
     2849        if ((*it)->i_id() == aId)
    29722850        {
    29732851            pUSBDevice = *it;
    … …  
    29802858        return setError(E_INVALIDARG,
    29812859            tr("USB device with UUID {%RTuuid} is not attached to this machine"),
    2982             Guid(aId).raw());
     2860            aId.raw());
    29832861
    29842862    /* Remove the device from the collection, it is re-added below for failures */
    … …  
    29892867     */
    29902868    alock.release();
    2991     HRESULT rc = mControl->DetachUSBDevice(aId, false /* aDone */);
     2869    HRESULT rc = mControl->DetachUSBDevice(BSTR(aId.toString().c_str()), false /* aDone */);
    29922870    if (FAILED(rc))
    29932871    {
    … …  
    29992877
    30002878    /* Request the PDM to detach the USB device. */
    3001     rc = detachUSBDevice(pUSBDevice);
     2879    rc = i_detachUSBDevice(pUSBDevice);
    30022880    if (SUCCEEDED(rc))
    30032881    {
    30042882        /* Request the device release. Even if it fails, the device will
    30052883         * remain as held by proxy, which is OK for us (the VM process). */
    3006         rc = mControl->DetachUSBDevice(aId, true /* aDone */);
     2884        rc = mControl->DetachUSBDevice(BSTR(aId.toString().c_str()), true /* aDone */);
    30072885    }
    30082886    else
    … …  
    30222900}
    30232901
    3024 STDMETHODIMP Console::FindUSBDeviceByAddress(IN_BSTR aAddress, IUSBDevice **aDevice)
     2902
     2903HRESULT Console::findUSBDeviceByAddress(const com::Utf8Str &aName, ComPtr<IUSBDevice> &aDevice)
    30252904{
    30262905#ifdef VBOX_WITH_USB
    3027     CheckComArgStrNotEmptyOrNull(aAddress);
    3028     CheckComArgOutPointerValid(aDevice);
    3029 
    3030     *aDevice = NULL;
     2906
     2907    aDevice = NULL;
    30312908
    30322909    SafeIfaceArray<IUSBDevice> devsvec;
    … …  
    30392916        rc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
    30402917        if (FAILED(rc)) return rc;
    3041         if (address == aAddress)
     2918        if (address == Bstr(aName))
    30422919        {
    30432920            ComObjPtr<OUSBDevice> pUSBDevice;
    30442921            pUSBDevice.createObject();
    30452922            pUSBDevice->init(devsvec[i]);
    3046             return pUSBDevice.queryInterfaceTo(aDevice);
     2923            return pUSBDevice.queryInterfaceTo(aDevice.asOutParam());
    30472924        }
    30482925    }
    30492926
    30502927    return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
    3051         tr("Could not find a USB device with address '%ls'"),
    3052         aAddress);
     2928        tr("Could not find a USB device with address '%s'"),
     2929        aName.c_str());
    30532930
    30542931#else   /* !VBOX_WITH_USB */
    … …  
    30572934}
    30582935
    3059 STDMETHODIMP Console::FindUSBDeviceById(IN_BSTR aId, IUSBDevice **aDevice)
     2936HRESULT Console::findUSBDeviceById(const com::Guid &aId, ComPtr<IUSBDevice> &aDevice)
    30602937{
    30612938#ifdef VBOX_WITH_USB
    3062     CheckComArgExpr(aId, Guid(aId).isValid());
    3063     CheckComArgOutPointerValid(aDevice);
    3064 
    3065     *aDevice = NULL;
     2939
     2940    aDevice = NULL;
    30662941
    30672942    SafeIfaceArray<IUSBDevice> devsvec;
    … …  
    30742949        rc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
    30752950        if (FAILED(rc)) return rc;
    3076         if (id == aId)
     2951        if (id == BSTR(aId.toString().c_str()))
    30772952        {
    30782953            ComObjPtr<OUSBDevice> pUSBDevice;
    30792954            pUSBDevice.createObject();
    30802955            pUSBDevice->init(devsvec[i]);
    3081             return pUSBDevice.queryInterfaceTo(aDevice);
     2956            ComObjPtr<IUSBDevice> iUSBDevice = static_cast <ComObjPtr<IUSBDevice> > (pUSBDevice);
     2957            return iUSBDevice.queryInterfaceTo(aDevice.asOutParam());
    30822958        }
    30832959    }
    … …  
    30922968}
    30932969
    3094 STDMETHODIMP
    3095 Console::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
    3096 {
    3097     CheckComArgStrNotEmptyOrNull(aName);
    3098     CheckComArgStrNotEmptyOrNull(aHostPath);
    3099 
    3100     LogFlowThisFunc(("Entering for '%ls' -> '%ls'\n", aName, aHostPath));
    3101 
    3102     AutoCaller autoCaller(this);
    3103     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3104 
    3105     Utf8Str strName(aName);
    3106     Utf8Str strHostPath(aHostPath);
     2970HRESULT Console::createSharedFolder(const com::Utf8Str &aName, const com::Utf8Str &aHostPath, BOOL aWritable, BOOL aAutomount)
     2971{
     2972    LogFlowThisFunc(("Entering for '%s' -> '%s'\n", aName.c_str(), aHostPath.c_str()));
    31072973
    31082974    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    … …  
    31232989
    31242990    ComObjPtr<SharedFolder> pSharedFolder;
    3125     HRESULT rc = findSharedFolder(strName, pSharedFolder, false /* aSetError */);
     2991    HRESULT rc = i_findSharedFolder(aName, pSharedFolder, false /* aSetError */);
    31262992    if (SUCCEEDED(rc))
    31272993        return setError(VBOX_E_FILE_ERROR,
    31282994                        tr("Shared folder named '%s' already exists"),
    3129                         strName.c_str());
     2995                        aName.c_str());
    31302996
    31312997    pSharedFolder.createObject();
    31322998    rc = pSharedFolder->init(this,
    3133                              strName,
    3134                              strHostPath,
     2999                             aName,
     3000                             aHostPath,
    31353001                             !!aWritable,
    3136                              !!aAutoMount,
     3002                             !!aAutomount,
    31373003                             true /* fFailOnError */);
    31383004    if (FAILED(rc)) return rc;
    … …  
    31483014        /* first, remove the machine or the global folder if there is any */
    31493015        SharedFolderDataMap::const_iterator it;
    3150         if (findOtherSharedFolder(aName, it))
     3016        if (i_findOtherSharedFolder(aName, it))
    31513017        {
    31523018            rc = removeSharedFolder(aName);
    … …  
    31563022
    31573023        /* second, create the given folder */
    3158         rc = createSharedFolder(aName, SharedFolderData(aHostPath, !!aWritable, !!aAutoMount));
     3024        rc = i_createSharedFolder(aName, SharedFolderData(aHostPath, !!aWritable, !!aAutomount));
    31593025        if (FAILED(rc))
    31603026            return rc;
    … …  
    31673033    fireSharedFolderChangedEvent(mEventSource, Scope_Session);
    31683034
    3169     LogFlowThisFunc(("Leaving for '%ls' -> '%ls'\n", aName, aHostPath));
     3035    LogFlowThisFunc(("Leaving for '%s' -> '%s'\n", aName.c_str(), aHostPath.c_str()));
    31703036
    31713037    return rc;
    31723038}
    31733039
    3174 STDMETHODIMP Console::RemoveSharedFolder(IN_BSTR aName)
    3175 {
    3176     CheckComArgStrNotEmptyOrNull(aName);
    3177 
    3178     AutoCaller autoCaller(this);
    3179     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3180 
    3181     LogFlowThisFunc(("Entering for '%ls'\n", aName));
     3040HRESULT Console::removeSharedFolder(const com::Utf8Str &aName)
     3041{
     3042    LogFlowThisFunc(("Entering for '%s'\n", aName.c_str()));
    31823043
    31833044    Utf8Str strName(aName);
    … …  
    32003061
    32013062    ComObjPtr<SharedFolder> pSharedFolder;
    3202     HRESULT rc = findSharedFolder(aName, pSharedFolder, true /* aSetError */);
     3063    HRESULT rc = i_findSharedFolder(aName, pSharedFolder, true /* aSetError */);
    32033064    if (FAILED(rc)) return rc;
    32043065
    … …  
    32193080        /* first, remove the machine or the global folder if there is any */
    32203081        SharedFolderDataMap::const_iterator it;
    3221         if (findOtherSharedFolder(strName, it))
    3222         {
    3223             rc = createSharedFolder(strName, it->second);
     3082        if (i_findOtherSharedFolder(strName, it))
     3083        {
     3084            rc = i_createSharedFolder(strName, it->second);
    32243085            /* don't check rc here because we need to remove the console
    32253086             * folder from the collection even on failure */
    … …  
    32333094    fireSharedFolderChangedEvent(mEventSource, Scope_Session);
    32343095
    3235     LogFlowThisFunc(("Leaving for '%ls'\n", aName));
     3096    LogFlowThisFunc(("Leaving for '%s'\n", aName.c_str()));
    32363097
    32373098    return rc;
    32383099}
    32393100
    3240 STDMETHODIMP Console::TakeSnapshot(IN_BSTR aName,
    3241                                    IN_BSTR aDescription,
    3242                                    IProgress **aProgress)
     3101HRESULT Console::takeSnapshot(const com::Utf8Str &aName,
     3102                              const com::Utf8Str &aDescription,
     3103                              ComPtr<IProgress> &aProgress)
    32433104{
    32443105    LogFlowThisFuncEnter();
    32453106
    3246     CheckComArgStrNotEmptyOrNull(aName);
    3247     CheckComArgOutPointerValid(aProgress);
    3248 
    3249     AutoCaller autoCaller(this);
    3250     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3251 
    32523107    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    3253     LogFlowThisFunc(("aName='%ls' mMachineState=%d\n", aName, mMachineState));
     3108    LogFlowThisFunc(("aName='%s' mMachineState=%d\n", aName.c_str(), mMachineState));
    32543109
    32553110    if (Global::IsTransient(mMachineState))
    … …  
    33203175
    33213176    VMTakeSnapshotTask *pTask;
    3322     if (!(pTask = new VMTakeSnapshotTask(this, pProgress, aName, aDescription)))
     3177    if (!(pTask = new VMTakeSnapshotTask(this, pProgress, Bstr(aName).raw(), Bstr(aDescription).raw())))
    33233178        return E_OUTOFMEMORY;
    33243179
    … …  
    33453200
    33463201        int vrc = RTThreadCreate(NULL,
    3347                                  Console::fntTakeSnapshotWorker,
     3202                                 Console::i_fntTakeSnapshotWorker,
    33483203                                 (void *)pTask,
    33493204                                 0,
    … …  
    33563211                           vrc);
    33573212
    3358         pTask->mProgress.queryInterfaceTo(aProgress);
     3213        pTask->mProgress.queryInterfaceTo(aProgress.asOutParam());
    33593214    }
    33603215    catch (HRESULT erc)
    … …  
    33703225}
    33713226
    3372 STDMETHODIMP Console::DeleteSnapshot(IN_BSTR aId, IProgress **aProgress)
    3373 {
    3374     CheckComArgExpr(aId, Guid(aId).isValid());
    3375     CheckComArgOutPointerValid(aProgress);
    3376 
    3377     AutoCaller autoCaller(this);
    3378     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3379 
     3227HRESULT Console::deleteSnapshot(const com::Guid &aId, ComPtr<IProgress> &aProgress)
     3228{
    33803229    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    33813230
    … …  
    33843233                        tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
    33853234                        Global::stringifyMachineState(mMachineState));
    3386 
     3235    ComObjPtr<IProgress> iProgress;
    33873236    MachineState_T machineState = MachineState_Null;
    3388     HRESULT rc = mControl->DeleteSnapshot(this, aId, aId, FALSE /* fDeleteAllChildren */, &machineState, aProgress);
     3237    HRESULT rc = mControl->DeleteSnapshot((IConsole *)this, BSTR(aId.toString().c_str()), BSTR(aId.toString().c_str()),
     3238                                          FALSE /* fDeleteAllChildren */, &machineState, iProgress.asOutParam());
    33893239    if (FAILED(rc)) return rc;
    3390 
    3391     setMachineStateLocally(machineState);
     3240    iProgress.queryInterfaceTo(aProgress.asOutParam());
     3241
     3242    i_setMachineStateLocally(machineState);
    33923243    return S_OK;
    33933244}
    33943245
    3395 STDMETHODIMP Console::DeleteSnapshotAndAllChildren(IN_BSTR aId, IProgress **aProgress)
    3396 {
    3397     CheckComArgExpr(aId, Guid(aId).isValid());
    3398     CheckComArgOutPointerValid(aProgress);
    3399 
    3400     AutoCaller autoCaller(this);
    3401     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3402 
     3246HRESULT Console::deleteSnapshotAndAllChildren(const com::Guid &aId, ComPtr<IProgress> &aProgress)
     3247
     3248{
    34033249    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    34043250
    … …  
    34083254                        Global::stringifyMachineState(mMachineState));
    34093255
     3256    ComObjPtr<IProgress> iProgress;
    34103257    MachineState_T machineState = MachineState_Null;
    3411     HRESULT rc = mControl->DeleteSnapshot(this, aId, aId, TRUE /* fDeleteAllChildren */, &machineState, aProgress);
     3258    HRESULT rc = mControl->DeleteSnapshot((IConsole *)this, BSTR(aId.toString().c_str()), BSTR(aId.toString().c_str()),
     3259                                          TRUE /* fDeleteAllChildren */, &machineState, iProgress.asOutParam());
    34123260    if (FAILED(rc)) return rc;
    3413 
    3414     setMachineStateLocally(machineState);
     3261    iProgress.queryInterfaceTo(aProgress.asOutParam());
     3262
     3263    i_setMachineStateLocally(machineState);
    34153264    return S_OK;
    34163265}
    34173266
    3418 STDMETHODIMP Console::DeleteSnapshotRange(IN_BSTR aStartId, IN_BSTR aEndId, IProgress **aProgress)
    3419 {
    3420     CheckComArgExpr(aStartId, Guid(aStartId).isValid());
    3421     CheckComArgExpr(aEndId, Guid(aEndId).isValid());
    3422     CheckComArgOutPointerValid(aProgress);
    3423 
    3424     AutoCaller autoCaller(this);
    3425     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3426 
     3267HRESULT Console::deleteSnapshotRange(const com::Guid &aStartId, const com::Guid &aEndId, ComPtr<IProgress> &aProgress)
     3268{
    34273269    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    34283270
    … …  
    34323274                        Global::stringifyMachineState(mMachineState));
    34333275
     3276    ComObjPtr<IProgress> iProgress;
    34343277    MachineState_T machineState = MachineState_Null;
    3435     HRESULT rc = mControl->DeleteSnapshot(this, aStartId, aEndId, FALSE /* fDeleteAllChildren */, &machineState, aProgress);
     3278    HRESULT rc = mControl->DeleteSnapshot((IConsole *)this, BSTR(aStartId.toString().c_str()), BSTR(aEndId.toString().c_str()), FALSE /* fDeleteAllChildren */, &machineState, iProgress.asOutParam());
    34363279    if (FAILED(rc)) return rc;
    3437 
    3438     setMachineStateLocally(machineState);
     3280    iProgress.queryInterfaceTo(aProgress.asOutParam());
     3281
     3282    i_setMachineStateLocally(machineState);
    34393283    return S_OK;
    34403284}
    34413285
    3442 STDMETHODIMP Console::RestoreSnapshot(ISnapshot *aSnapshot, IProgress **aProgress)
    3443 {
    3444     AutoCaller autoCaller(this);
    3445     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    3446 
     3286HRESULT Console::restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot, ComPtr<IProgress> &aProgress)
     3287{
    34473288    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    34483289
    … …  
    34523293                        Global::stringifyMachineState(mMachineState));
    34533294
     3295    ISnapshot* iSnapshot = aSnapshot;
     3296    ComObjPtr<IProgress> iProgress;
    34543297    MachineState_T machineState = MachineState_Null;
    3455     HRESULT rc = mControl->RestoreSnapshot(this, aSnapshot, &machineState, aProgress);
     3298    HRESULT rc = mControl->RestoreSnapshot((IConsole*)this, iSnapshot, &machineState, iProgress.asOutParam());
    34563299    if (FAILED(rc)) return rc;
    3457 
    3458     setMachineStateLocally(machineState);
     3300    iProgress.queryInterfaceTo(aProgress.asOutParam());
     3301
     3302    i_setMachineStateLocally(machineState);
    34593303    return S_OK;
    34603304}
    … …  
    34643308
    34653309/*static*/
    3466 HRESULT Console::setErrorStatic(HRESULT aResultCode, const char *pcsz, ...)
     3310HRESULT Console::i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...)
    34673311{
    34683312    va_list args;
    … …  
    34783322}
    34793323
    3480 HRESULT Console::setInvalidMachineStateError()
     3324HRESULT Console::i_setInvalidMachineStateError()
    34813325{
    34823326    return setError(VBOX_E_INVALID_VM_STATE,
    … …  
    34873331
    34883332/* static */
    3489 const char *Console::convertControllerTypeToDev(StorageControllerType_T enmCtrlType)
     3333const char *Console::i_convertControllerTypeToDev(StorageControllerType_T enmCtrlType)
    34903334{
    34913335    switch (enmCtrlType)
    … …  
    35123356}
    35133357
    3514 HRESULT Console::convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun)
     3358HRESULT Console::i_convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun)
    35153359{
    35163360    switch (enmBus)
    … …  
    35583402 *                          afterwards.
    35593403 */
    3560 HRESULT Console::suspendBeforeConfigChange(PUVM pUVM, AutoWriteLock *pAlock, bool *pfResume)
     3404HRESULT Console::i_suspendBeforeConfigChange(PUVM pUVM, AutoWriteLock *pAlock, bool *pfResume)
    35613405{
    35623406    *pfResume = false;
    … …  
    36073451 * @param pUVM              Safe VM handle.
    36083452 */
    3609 void Console::resumeAfterConfigChange(PUVM pUVM)
     3453void Console::i_resumeAfterConfigChange(PUVM pUVM)
    36103454{
    36113455    LogFlowFunc(("Resuming the VM...\n"));
    … …  
    36213465        {
    36223466            /* too bad, we failed. try to sync the console state with the VMM state */
    3623             vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, this);
     3467            i_vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, this);
    36243468        }
    36253469    }
    … …  
    36353479 * @note Locks this object for writing.
    36363480 */
    3637 HRESULT Console::doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM)
     3481HRESULT Console::i_doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM)
    36383482{
    36393483    AutoCaller autoCaller(this);
    … …  
    36813525    rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
    36823526    AssertComRC(rc);
    3683     pszDevice = convertControllerTypeToDev(enmCtrlType);
     3527    pszDevice = i_convertControllerTypeToDev(enmCtrlType);
    36843528
    36853529    StorageBus_T enmBus;
    … …  
    36983542     */
    36993543    bool fResume = false;
    3700     rc = suspendBeforeConfigChange(pUVM, &alock, &fResume);
     3544    rc = i_suspendBeforeConfigChange(pUVM, &alock, &fResume);
    37013545    if (FAILED(rc))
    37023546        return rc;
    … …  
    37093553    PVMREQ pReq;
    37103554    int vrc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    3711                            (PFNRT)changeRemovableMedium, 8,
     3555                           (PFNRT)i_changeRemovableMedium, 8,
    37123556                           this, pUVM, pszDevice, uInstance, enmBus, fUseHostIOCache, aMediumAttachment, fForce);
    37133557
    … …  
    37253569
    37263570    if (fResume)
    3727         resumeAfterConfigChange(pUVM);
     3571        i_resumeAfterConfigChange(pUVM);
    37283572
    37293573    if (RT_SUCCESS(vrc))
    … …  
    37643608 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
    37653609 */
    3766 DECLCALLBACK(int) Console::changeRemovableMedium(Console *pThis,
    3767                                                  PUVM pUVM,
    3768                                                  const char *pcszDevice,
    3769                                                  unsigned uInstance,
    3770                                                  StorageBus_T enmBus,
    3771                                                  bool fUseHostIOCache,
    3772                                                  IMediumAttachment *aMediumAtt,
    3773                                                  bool fForce)
     3610DECLCALLBACK(int) Console::i_changeRemovableMedium(Console *pThis,
     3611                                                   PUVM pUVM,
     3612                                                   const char *pcszDevice,
     3613                                                   unsigned uInstance,
     3614                                                   StorageBus_T enmBus,
     3615                                                   bool fUseHostIOCache,
     3616                                                   IMediumAttachment *aMediumAtt,
     3617                                                   bool fForce)
    37743618{
    37753619    LogFlowFunc(("pThis=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, aMediumAtt=%p, fForce=%d\n",
    … …  
    37963640
    37973641    PCFGMNODE pLunL0 = NULL;
    3798     int rc = pThis->configMediumAttachment(pCtlInst,
    3799                                            pcszDevice,
    3800                                            uInstance,
    3801                                            enmBus,
    3802                                            fUseHostIOCache,
    3803                                            false /* fSetupMerge */,
    3804                                            false /* fBuiltinIOCache */,
    3805                                            0 /* uMergeSource */,
    3806                                            0 /* uMergeTarget */,
    3807                                            aMediumAtt,
    3808                                            pThis->mMachineState,
    3809                                            NULL /* phrc */,
    3810                                            true /* fAttachDetach */,
    3811                                            fForce /* fForceUnmount */,
    3812                                            false  /* fHotplug */,
    3813                                            pUVM,
    3814                                            NULL /* paLedDevType */,
    3815                                            &pLunL0);
     3642    int rc = pThis->i_configMediumAttachment(pCtlInst,
     3643                                             pcszDevice,
     3644                                             uInstance,
     3645                                             enmBus,
     3646                                             fUseHostIOCache,
     3647                                             false /* fSetupMerge */,
     3648                                             false /* fBuiltinIOCache */,
     3649                                             0 /* uMergeSource */,
     3650                                             0 /* uMergeTarget */,
     3651                                             aMediumAtt,
     3652                                             pThis->mMachineState,
     3653                                             NULL /* phrc */,
     3654                                             true /* fAttachDetach */,
     3655                                             fForce /* fForceUnmount */,
     3656                                             false  /* fHotplug */,
     3657                                             pUVM,
     3658                                             NULL /* paLedDevType */,
     3659                                             &pLunL0);
    38163660    /* Dump the changed LUN if possible, dump the complete device otherwise */
    38173661    CFGMR3Dump(pLunL0 ? pLunL0 : pCtlInst);
    … …  
    38313675 * @note Locks this object for writing.
    38323676 */
    3833 HRESULT Console::doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
     3677HRESULT Console::i_doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
    38343678{
    38353679    AutoCaller autoCaller(this);
    … …  
    38773721    rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
    38783722    AssertComRC(rc);
    3879     pszDevice = convertControllerTypeToDev(enmCtrlType);
     3723    pszDevice = i_convertControllerTypeToDev(enmCtrlType);
    38803724
    38813725    StorageBus_T enmBus;
    … …  
    38943738     */
    38953739    bool fResume = false;
    3896     rc = suspendBeforeConfigChange(pUVM, &alock, &fResume);
     3740    rc = i_suspendBeforeConfigChange(pUVM, &alock, &fResume);
    38973741    if (FAILED(rc))
    38983742        return rc;
    … …  
    39053749    PVMREQ pReq;
    39063750    int vrc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    3907                            (PFNRT)attachStorageDevice, 8,
     3751                           (PFNRT)i_attachStorageDevice, 8,
    39083752                           this, pUVM, pszDevice, uInstance, enmBus, fUseHostIOCache, aMediumAttachment, fSilent);
    39093753
    … …  
    39213765
    39223766    if (fResume)
    3923         resumeAfterConfigChange(pUVM);
     3767        i_resumeAfterConfigChange(pUVM);
    39243768
    39253769    if (RT_SUCCESS(vrc))
    … …  
    39543798 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
    39553799 */
    3956 DECLCALLBACK(int) Console::attachStorageDevice(Console *pThis,
    3957                                                PUVM pUVM,
    3958                                                const char *pcszDevice,
    3959                                                unsigned uInstance,
    3960                                                StorageBus_T enmBus,
    3961                                                bool fUseHostIOCache,
    3962                                                IMediumAttachment *aMediumAtt,
    3963                                                bool fSilent)
     3800DECLCALLBACK(int) Console::i_attachStorageDevice(Console *pThis,
     3801                                                 PUVM pUVM,
     3802                                                 const char *pcszDevice,
     3803                                                 unsigned uInstance,
     3804                                                 StorageBus_T enmBus,
     3805                                                 bool fUseHostIOCache,
     3806                                                 IMediumAttachment *aMediumAtt,
     3807                                                 bool fSilent)
    39643808{
    39653809    LogFlowFunc(("pThis=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, aMediumAtt=%p\n",
    … …  
    39913835
    39923836    PCFGMNODE pLunL0 = NULL;
    3993     int rc = pThis->configMediumAttachment(pCtlInst,
    3994                                            pcszDevice,
    3995                                            uInstance,
    3996                                            enmBus,
    3997                                            fUseHostIOCache,
    3998                                            false /* fSetupMerge */,
    3999                                            false /* fBuiltinIOCache */,
    4000                                            0 /* uMergeSource */,
    4001                                            0 /* uMergeTarget */,
    4002                                            aMediumAtt,
    4003                                            pThis->mMachineState,
    4004                                            NULL /* phrc */,
    4005                                            true /* fAttachDetach */,
    4006                                            false /* fForceUnmount */,
    4007                                            !fSilent /* fHotplug */,
    4008                                            pUVM,
    4009                                            NULL /* paLedDevType */,
    4010                                            &pLunL0);
     3837    int rc = pThis->i_configMediumAttachment(pCtlInst,
     3838                                             pcszDevice,
     3839                                             uInstance,
     3840                                             enmBus,
     3841                                             fUseHostIOCache,
     3842                                             false /* fSetupMerge */,
     3843                                             false /* fBuiltinIOCache */,
     3844                                             0 /* uMergeSource */,
     3845                                             0 /* uMergeTarget */,
     3846                                             aMediumAtt,
     3847                                             pThis->mMachineState,
     3848                                             NULL /* phrc */,
     3849                                             true /* fAttachDetach */,
     3850                                             false /* fForceUnmount */,
     3851                                             !fSilent /* fHotplug */,
     3852                                             pUVM,
     3853                                             NULL /* paLedDevType */,
     3854                                             &pLunL0);
    40113855    /* Dump the changed LUN if possible, dump the complete device otherwise */
    40123856    if (enmBus != StorageBus_USB)
    … …  
    40263870 * @note Locks this object for writing.
    40273871 */
    4028 HRESULT Console::doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
     3872HRESULT Console::i_doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent)
    40293873{
    40303874    AutoCaller autoCaller(this);
    … …  
    40723916    rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
    40733917    AssertComRC(rc);
    4074     pszDevice = convertControllerTypeToDev(enmCtrlType);
     3918    pszDevice = i_convertControllerTypeToDev(enmCtrlType);
    40753919
    40763920    StorageBus_T enmBus;
    … …  
    40863930     */
    40873931    bool fResume = false;
    4088     rc = suspendBeforeConfigChange(pUVM, &alock, &fResume);
     3932    rc = i_suspendBeforeConfigChange(pUVM, &alock, &fResume);
    40893933    if (FAILED(rc))
    40903934        return rc;
    … …  
    40973941    PVMREQ pReq;
    40983942    int vrc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    4099                            (PFNRT)detachStorageDevice, 7,
     3943                           (PFNRT)i_detachStorageDevice, 7,
    41003944                           this, pUVM, pszDevice, uInstance, enmBus, aMediumAttachment, fSilent);
    41013945
    … …  
    41133957
    41143958    if (fResume)
    4115         resumeAfterConfigChange(pUVM);
     3959        i_resumeAfterConfigChange(pUVM);
    41163960
    41173961    if (RT_SUCCESS(vrc))
    … …  
    41453989 * @note The VM must not be running since it might have pending I/O to the drive which is being changed.
    41463990 */
    4147 DECLCALLBACK(int) Console::detachStorageDevice(Console *pThis,
    4148                                                PUVM pUVM,
    4149                                                const char *pcszDevice,
    4150                                                unsigned uInstance,
    4151                                                StorageBus_T enmBus,
    4152                                                IMediumAttachment *pMediumAtt,
    4153                                                bool fSilent)
     3991DECLCALLBACK(int) Console::i_detachStorageDevice(Console *pThis,
     3992                                                 PUVM pUVM,
     3993                                                 const char *pcszDevice,
     3994                                                 unsigned uInstance,
     3995                                                 StorageBus_T enmBus,
     3996                                                 IMediumAttachment *pMediumAtt,
     3997                                                 bool fSilent)
    41543998{
    41553999    LogFlowFunc(("pThis=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, pMediumAtt=%p\n",
    … …  
    41874031    hrc = pMediumAtt->COMGETTER(Port)(&lPort);                              H();
    41884032    hrc = pMediumAtt->COMGETTER(Type)(&lType);                              H();
    4189     hrc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);    H();
     4033    hrc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);  H();
    41904034
    41914035#undef H
    … …  
    42424086 * @note Locks this object for writing.
    42434087 */
    4244 HRESULT Console::onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter)
     4088HRESULT Console::i_onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter)
    42454089{
    42464090    LogFlowThisFunc(("\n"));
    … …  
    43144158                            }
    43154159
    4316                             rc = doNetworkAdapterChange(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, aNetworkAdapter);
     4160                            rc = i_doNetworkAdapterChange(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, aNetworkAdapter);
    43174161
    43184162                            if (fTraceEnabled && fCableConnected && pINetCfg)
    … …  
    43554199 * @note Locks this object for writing.
    43564200 */
    4357 HRESULT Console::onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
    4358                                          NATProtocol_T aProto, IN_BSTR aHostIP, LONG aHostPort, IN_BSTR aGuestIP, LONG aGuestPort)
     4201HRESULT Console::i_onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
     4202                                           NATProtocol_T aProto, IN_BSTR aHostIP,
     4203                                           LONG aHostPort, IN_BSTR aGuestIP,
     4204                                           LONG aGuestPort)
    43594205{
    43604206    LogFlowThisFunc(("\n"));
    … …  
    43744220        {
    43754221            ComPtr<INetworkAdapter> pNetworkAdapter;
    4376             rc = machine()->GetNetworkAdapter(ulInstance, pNetworkAdapter.asOutParam());
     4222            rc = i_machine()->GetNetworkAdapter(ulInstance, pNetworkAdapter.asOutParam());
    43774223            if (   FAILED(rc)
    43784224                || pNetworkAdapter.isNull())
    … …  
    44394285}
    44404286
    4441 VMMDevMouseInterface *Console::getVMMDevMouseInterface()
     4287VMMDevMouseInterface *Console::i_getVMMDevMouseInterface()
    44424288{
    44434289    return m_pVMMDev;
    44444290}
    44454291
    4446 DisplayMouseInterface *Console::getDisplayMouseInterface()
     4292DisplayMouseInterface *Console::i_getDisplayMouseInterface()
    44474293{
    44484294    return mDisplay;
    … …  
    44584304 * @param   ppszVal Where to store the value on success.
    44594305 */
    4460 int Console::consoleParseKeyValue(const char *psz, const char **ppszEnd,
    4461                                   char **ppszKey, char **ppszVal)
     4306int Console::i_consoleParseKeyValue(const char *psz, const char **ppszEnd,
     4307                                    char **ppszKey, char **ppszVal)
    44624308{
    44634309    int rc = VINF_SUCCESS;
    … …  
    45204366 * @param   cbKey     Size of the key in bytes.
    45214367 */
    4522 HRESULT Console::configureEncryptionForDisk(const char *pszUuid, const uint8_t *pbKey, size_t cbKey)
     4368HRESULT Console::i_configureEncryptionForDisk(const char *pszUuid, const uint8_t *pbKey, size_t cbKey)
    45234369{
    45244370    HRESULT hrc = S_OK;
    … …  
    45984444            hrc = pStorageCtrl->COMGETTER(ControllerType)(&enmCtrlType);
    45994445            AssertComRC(hrc);
    4600             const char *pcszDevice = convertControllerTypeToDev(enmCtrlType);
     4446            const char *pcszDevice = i_convertControllerTypeToDev(enmCtrlType);
    46014447
    46024448            StorageBus_T enmBus;
    … …  
    46054451
    46064452            unsigned uLUN;
    4607             hrc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
     4453            hrc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
    46084454            AssertComRCReturnRC(hrc);
    46094455
    … …  
    46384484 * @param   psz    Pointer to the configuration for the encryption of one disk.
    46394485 */
    4640 HRESULT Console::consoleParseDiskEncryption(const char *psz, const char **ppszEnd)
     4486HRESULT Console::i_consoleParseDiskEncryption(const char *psz, const char **ppszEnd)
    46414487{
    46424488    char *pszUuid = NULL;
    … …  
    46524498        const char *pszEnd = NULL;
    46534499
    4654         rc = consoleParseKeyValue(psz, &pszEnd, &pszKey, &pszVal);
     4500        rc = i_consoleParseKeyValue(psz, &pszEnd, &pszKey, &pszVal);
    46554501        if (RT_SUCCESS(rc))
    46564502        {
    … …  
    46984544                rc = RTBase64Decode(pszKeyEnc, pbKey, cbKey, NULL, NULL);
    46994545                if (RT_SUCCESS(rc))
    4700                     hrc = configureEncryptionForDisk(pszUuid, pbKey, cbKey);
     4546                    hrc = i_configureEncryptionForDisk(pszUuid, pbKey, cbKey);
    47014547                else
    47024548                    hrc = setError(E_FAIL,
    … …  
    47334579}
    47344580
    4735 HRESULT Console::setDiskEncryptionKeys(const Utf8Str &strCfg)
     4581HRESULT Console::i_setDiskEncryptionKeys(const Utf8Str &strCfg)
    47364582{
    47374583    HRESULT hrc = S_OK;
    … …  
    47424588    {
    47434589        const char *pszNext = NULL;
    4744         hrc = consoleParseDiskEncryption(pszCfg, &pszNext);
     4590        hrc = i_consoleParseDiskEncryption(pszCfg, &pszNext);
    47454591        pszCfg = pszNext;
    47464592    }
    … …  
    47604606 * @param   aNetworkAdapter     The network adapter whose attachment needs to be changed
    47614607 */
    4762 HRESULT Console::doNetworkAdapterChange(PUVM pUVM,
    4763                                         const char *pszDevice,
    4764                                         unsigned uInstance,
    4765                                         unsigned uLun,
    4766                                         INetworkAdapter *aNetworkAdapter)
     4608HRESULT Console::i_doNetworkAdapterChange(PUVM pUVM,
     4609                                          const char *pszDevice,
     4610                                          unsigned uInstance,
     4611                                          unsigned uLun,
     4612                                          INetworkAdapter *aNetworkAdapter)
    47674613{
    47684614    LogFlowThisFunc(("pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
    … …  
    47764622     */
    47774623    bool fResume = false;
    4778     int rc = suspendBeforeConfigChange(pUVM, NULL, &fResume);
     4624    int rc = i_suspendBeforeConfigChange(pUVM, NULL, &fResume);
    47794625    if (FAILED(rc))
    47804626        return rc;
    … …  
    47874633    PVMREQ pReq;
    47884634    int vrc = VMR3ReqCallU(pUVM, 0 /*idDstCpu*/, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
    4789                            (PFNRT)changeNetworkAttachment, 6,
     4635                           (PFNRT)i_changeNetworkAttachment, 6,
    47904636                           this, pUVM, pszDevice, uInstance, uLun, aNetworkAdapter);
    47914637
    … …  
    48004646
    48014647    if (fResume)
    4802         resumeAfterConfigChange(pUVM);
     4648        i_resumeAfterConfigChange(pUVM);
    48034649
    48044650    if (RT_SUCCESS(vrc))
    … …  
    48304676 * @note The VM must not be running.
    48314677 */
    4832 DECLCALLBACK(int) Console::changeNetworkAttachment(Console *pThis,
    4833                                                    PUVM pUVM,
    4834                                                    const char *pszDevice,
    4835                                                    unsigned uInstance,
    4836                                                    unsigned uLun,
    4837                                                    INetworkAdapter *aNetworkAdapter)
     4678DECLCALLBACK(int) Console::i_changeNetworkAttachment(Console *pThis,
     4679                                                     PUVM pUVM,
     4680                                                     const char *pszDevice,
     4681                                                     unsigned uInstance,
     4682                                                     unsigned uLun,
     4683                                                     INetworkAdapter *aNetworkAdapter)
    48384684{
    48394685    LogFlowFunc(("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
    … …  
    48744720    AssertRelease(pInst);
    48754721
    4876     int rc = pThis->configNetwork(pszDevice, uInstance, uLun, aNetworkAdapter, pCfg, pLunL0, pInst,
     4722    int rc = pThis->i_configNetwork(pszDevice, uInstance, uLun, aNetworkAdapter, pCfg, pLunL0, pInst,
    48774723                                  true /*fAttachDetach*/, false /*fIgnoreConnectFailure*/);
    48784724
    … …  
    48854731 * Called by IInternalSessionControl::OnSerialPortChange().
    48864732 */
    4887 HRESULT Console::onSerialPortChange(ISerialPort *aSerialPort)
     4733HRESULT Console::i_onSerialPortChange(ISerialPort *aSerialPort)
    48884734{
    48894735    LogFlowThisFunc(("\n"));
    … …  
    49014747 * Called by IInternalSessionControl::OnParallelPortChange().
    49024748 */
    4903 HRESULT Console::onParallelPortChange(IParallelPort *aParallelPort)
     4749HRESULT Console::i_onParallelPortChange(IParallelPort *aParallelPort)
    49044750{
    49054751    LogFlowThisFunc(("\n"));
    … …  
    49174763 * Called by IInternalSessionControl::OnStorageControllerChange().
    49184764 */
    4919 HRESULT Console::onStorageControllerChange()
     4765HRESULT Console::i_onStorageControllerChange()
    49204766{
    49214767    LogFlowThisFunc(("\n"));
    … …  
    49334779 * Called by IInternalSessionControl::OnMediumChange().
    49344780 */
    4935 HRESULT Console::onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce)
     4781HRESULT Console::i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce)
    49364782{
    49374783    LogFlowThisFunc(("\n"));
    … …  
    49464792    if (ptrVM.isOk())
    49474793    {
    4948         rc = doMediumChange(aMediumAttachment, !!aForce, ptrVM.rawUVM());
     4794        rc = i_doMediumChange(aMediumAttachment, !!aForce, ptrVM.rawUVM());
    49494795        ptrVM.release();
    49504796    }
    … …  
    49634809 * @note Locks this object for writing.
    49644810 */
    4965 HRESULT Console::onCPUChange(ULONG aCPU, BOOL aRemove)
     4811HRESULT Console::i_onCPUChange(ULONG aCPU, BOOL aRemove)
    49664812{
    49674813    LogFlowThisFunc(("\n"));
    … …  
    49774823    {
    49784824        if (aRemove)
    4979             rc = doCPURemove(aCPU, ptrVM.rawUVM());
     4825            rc = i_doCPURemove(aCPU, ptrVM.rawUVM());
    49804826        else
    4981             rc = doCPUAdd(aCPU, ptrVM.rawUVM());
     4827            rc = i_doCPUAdd(aCPU, ptrVM.rawUVM());
    49824828        ptrVM.release();
    49834829    }
    … …  
    49964842 * @note Locks this object for writing.
    49974843 */
    4998 HRESULT Console::onCPUExecutionCapChange(ULONG aExecutionCap)
     4844HRESULT Console::i_onCPUExecutionCapChange(ULONG aExecutionCap)
    49994845{
    50004846    LogFlowThisFunc(("\n"));
    … …  
    50204866        }
    50214867        else
    5022             rc = setInvalidMachineStateError();
     4868            rc = i_setInvalidMachineStateError();
    50234869        ptrVM.release();
    50244870    }
    … …  
    50404886 * @note Locks this object for writing.
    50414887 */
    5042 HRESULT Console::onClipboardModeChange(ClipboardMode_T aClipboardMode)
     4888HRESULT Console::i_onClipboardModeChange(ClipboardMode_T aClipboardMode)
    50434889{
    50444890    LogFlowThisFunc(("\n"));
    … …  
    50584904            || mMachineState == MachineState_Teleporting
    50594905            || mMachineState == MachineState_LiveSnapshotting)
    5060             changeClipboardMode(aClipboardMode);
     4906            i_changeClipboardMode(aClipboardMode);
    50614907        else
    5062             rc = setInvalidMachineStateError();
     4908            rc = i_setInvalidMachineStateError();
    50634909        ptrVM.release();
    50644910    }
    … …  
    50804926 * @note Locks this object for writing.
    50814927 */
    5082 HRESULT Console::onDnDModeChange(DnDMode_T aDnDMode)
     4928HRESULT Console::i_onDnDModeChange(DnDMode_T aDnDMode)
    50834929{
    50844930    LogFlowThisFunc(("\n"));
    … …  
    50984944            || mMachineState == MachineState_Teleporting
    50994945            || mMachineState == MachineState_LiveSnapshotting)
    5100             changeDnDMode(aDnDMode);
     4946            i_changeDnDMode(aDnDMode);
    51014947        else
    5102             rc = setInvalidMachineStateError();
     4948            rc = i_setInvalidMachineStateError();
    51034949        ptrVM.release();
    51044950    }
    … …  
    51204966 * @note Locks this object for writing.
    51214967 */
    5122 HRESULT Console::onVRDEServerChange(BOOL aRestart)
     4968HRESULT Console::i_onVRDEServerChange(BOOL aRestart)
    51234969{
    51244970    AutoCaller autoCaller(this);
    … …  
    51795025                }
    51805026                else
    5181                     rc = setInvalidMachineStateError();
     5027                    rc = i_setInvalidMachineStateError();
    51825028
    51835029                mfVRDEChangeInProcess = false;
    … …  
    51985044}
    51995045
    5200 void Console::onVRDEServerInfoChange()
     5046void Console::i_onVRDEServerInfoChange()
    52015047{
    52025048    AutoCaller autoCaller(this);
    … …  
    52065052}
    52075053
    5208 HRESULT Console::onVideoCaptureChange()
     5054HRESULT Console::i_onVideoCaptureChange()
    52095055{
    52105056    AutoCaller autoCaller(this);
    … …  
    52595105 * Called by IInternalSessionControl::OnUSBControllerChange().
    52605106 */
    5261 HRESULT Console::onUSBControllerChange()
     5107HRESULT Console::i_onUSBControllerChange()
    52625108{
    52635109    LogFlowThisFunc(("\n"));
    … …  
    52765122 * @note Locks this object for writing.
    52775123 */
    5278 HRESULT Console::onSharedFolderChange(BOOL aGlobal)
     5124HRESULT Console::i_onSharedFolderChange(BOOL aGlobal)
    52795125{
    52805126    LogFlowThisFunc(("aGlobal=%RTbool\n", aGlobal));
    … …  
    52855131    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    52865132
    5287     HRESULT rc = fetchSharedFolders(aGlobal);
     5133    HRESULT rc = i_fetchSharedFolders(aGlobal);
    52885134
    52895135    /* notify console callbacks on success */
    … …  
    53125158 * @note Locks this object for writing.
    53135159 */
    5314 HRESULT Console::onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs)
     5160HRESULT Console::i_onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs)
    53155161{
    53165162#ifdef VBOX_WITH_USB
    … …  
    53385184        /* notify callbacks about the error */
    53395185        alock.release();
    5340         onUSBDeviceStateChange(aDevice, true /* aAttached */, aError);
     5186        i_onUSBDeviceStateChange(aDevice, true /* aAttached */, aError);
    53415187        return S_OK;
    53425188    }
    … …  
    53505196
    53515197    alock.release();
    5352     HRESULT rc = attachUSBDevice(aDevice, aMaskedIfs);
     5198    HRESULT rc = i_attachUSBDevice(aDevice, aMaskedIfs);
    53535199    if (FAILED(rc))
    53545200    {
    … …  
    53615207        {
    53625208            /* notify callbacks about the error */
    5363             onUSBDeviceStateChange(aDevice, true /* aAttached */, pError);
     5209            i_onUSBDeviceStateChange(aDevice, true /* aAttached */, pError);
    53645210        }
    53655211    }
    … …  
    53785224 * @note Locks this object for writing.
    53795225 */
    5380 HRESULT Console::onUSBDeviceDetach(IN_BSTR aId,
     5226HRESULT Console::i_onUSBDeviceDetach(IN_BSTR aId,
    53815227                                   IVirtualBoxErrorInfo *aError)
    53825228{
    … …  
    54305276        /* notify callback about an error */
    54315277        alock.release();
    5432         onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, aError);
     5278        i_onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, aError);
    54335279        return S_OK;
    54345280    }
    … …  
    54385284
    54395285    alock.release();
    5440     HRESULT rc = detachUSBDevice(pUSBDevice);
     5286    HRESULT rc = i_detachUSBDevice(pUSBDevice);
    54415287    if (FAILED(rc))
    54425288    {
    … …  
    54535299        {
    54545300            /* notify callbacks about the error */
    5455             onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, pError);
     5301            i_onUSBDeviceStateChange(pUSBDevice, false /* aAttached */, pError);
    54565302        }
    54575303    }
    … …  
    54695315 * @note Locks this object for writing.
    54705316 */
    5471 HRESULT Console::onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
     5317HRESULT Console::i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
    54725318{
    54735319    LogFlowThisFunc(("\n"));
    … …  
    55145360        }
    55155361        else
    5516             rc = setInvalidMachineStateError();
     5362            rc = i_setInvalidMachineStateError();
    55175363        ptrVM.release();
    55185364    }
    … …  
    55345380 * @note Locks this object for writing.
    55355381 */
    5536 HRESULT Console::onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent)
     5382HRESULT Console::i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent)
    55375383{
    55385384    LogFlowThisFunc(("\n"));
    … …  
    55485394    {
    55495395        if (aRemove)
    5550             rc = doStorageDeviceDetach(aMediumAttachment, ptrVM.rawUVM(), RT_BOOL(aSilent));
     5396            rc = i_doStorageDeviceDetach(aMediumAttachment, ptrVM.rawUVM(), RT_BOOL(aSilent));
    55515397        else
    5552             rc = doStorageDeviceAttach(aMediumAttachment, ptrVM.rawUVM(), RT_BOOL(aSilent));
     5398            rc = i_doStorageDeviceAttach(aMediumAttachment, ptrVM.rawUVM(), RT_BOOL(aSilent));
    55535399        ptrVM.release();
    55545400    }
    … …  
    55625408}
    55635409
    5564 HRESULT Console::onExtraDataChange(IN_BSTR aMachineId, IN_BSTR aKey, IN_BSTR aVal)
     5410HRESULT Console::i_onExtraDataChange(IN_BSTR aMachineId, IN_BSTR aKey, IN_BSTR aVal)
    55655411{
    55665412    LogFlowThisFunc(("\n"));
    … …  
    56085454 * @note Temporarily locks this object for writing.
    56095455 */
    5610 HRESULT Console::getGuestProperty(IN_BSTR aName, BSTR *aValue,
    5611                                   LONG64 *aTimestamp, BSTR *aFlags)
     5456HRESULT Console::i_getGuestProperty(IN_BSTR aName, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags)
    56125457{
    56135458#ifndef VBOX_WITH_GUEST_PROPS
    … …  
    56915536 * @note Temporarily locks this object for writing.
    56925537 */
    5693 HRESULT Console::setGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
     5538HRESULT Console::i_setGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
    56945539{
    56955540#ifndef VBOX_WITH_GUEST_PROPS
    … …  
    57675612 * @note Temporarily locks this object for writing.
    57685613 */
    5769 HRESULT Console::enumerateGuestProperties(IN_BSTR aPatterns,
    5770                                           ComSafeArrayOut(BSTR, aNames),
    5771                                           ComSafeArrayOut(BSTR, aValues),
    5772                                           ComSafeArrayOut(LONG64, aTimestamps),
    5773                                           ComSafeArrayOut(BSTR, aFlags))
     5614HRESULT Console::i_enumerateGuestProperties(IN_BSTR aPatterns,
     5615                                            ComSafeArrayOut(BSTR, aNames),
     5616                                            ComSafeArrayOut(BSTR, aValues),
     5617                                            ComSafeArrayOut(LONG64, aTimestamps),
     5618                                            ComSafeArrayOut(BSTR, aFlags))
    57745619{
    57755620#ifndef VBOX_WITH_GUEST_PROPS
    … …  
    57985643     * autoVMCaller, so there is no need to hold a lock of this */
    57995644
    5800     return doEnumerateGuestProperties(aPatterns, ComSafeArrayOutArg(aNames),
    5801                                       ComSafeArrayOutArg(aValues),
    5802                                       ComSafeArrayOutArg(aTimestamps),
    5803                                       ComSafeArrayOutArg(aFlags));
     5645    return i_doEnumerateGuestProperties(aPatterns, ComSafeArrayOutArg(aNames),
     5646                                        ComSafeArrayOutArg(aValues),
     5647                                        ComSafeArrayOutArg(aTimestamps),
     5648                                        ComSafeArrayOutArg(aFlags));
    58045649#endif /* VBOX_WITH_GUEST_PROPS */
    58055650}
    … …  
    58215666 * @note Temporarily locks this object for writing. bird: And/or reading?
    58225667 */
    5823 HRESULT Console::onlineMergeMedium(IMediumAttachment *aMediumAttachment,
     5668HRESULT Console::i_onlineMergeMedium(IMediumAttachment *aMediumAttachment,
    58245669                                   ULONG aSourceIdx, ULONG aTargetIdx,
    58255670                                   IProgress *aProgress)
    … …  
    58475692
    58485693        default:
    5849             return setInvalidMachineStateError();
     5694            return i_setInvalidMachineStateError();
    58505695    }
    58515696
    … …  
    58975742    rc = pStorageController->COMGETTER(ControllerType)(&enmCtrlType);
    58985743    AssertComRC(rc);
    5899     const char *pcszDevice = convertControllerTypeToDev(enmCtrlType);
     5744    const char *pcszDevice = i_convertControllerTypeToDev(enmCtrlType);
    59005745
    59015746    StorageBus_T enmBus;
    … …  
    59105755
    59115756    unsigned uLUN;
    5912     rc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
     5757    rc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);
    59135758    AssertComRCReturnRC(rc);
    59145759
    … …  
    59285773
    59295774    vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY,
    5930                            (PFNRT)reconfigureMediumAttachment, 13,
     5775                           (PFNRT)i_reconfigureMediumAttachment, 13,
    59315776                           this, ptrVM.rawUVM(), pcszDevice, uInstance, enmBus, fUseHostIOCache,
    59325777                           fBuiltinIOCache, true /* fSetupMerge */, aSourceIdx, aTargetIdx,
    … …  
    59455790            /* too bad, we failed. try to sync the console state with the VMM state */
    59465791            AssertLogRelRC(vrc2);
    5947             vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
     5792            i_vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
    59485793        }
    59495794    }
    … …  
    59905835
    59915836    vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY,
    5992                            (PFNRT)reconfigureMediumAttachment, 13,
     5837                           (PFNRT)i_reconfigureMediumAttachment, 13,
    59935838                           this, ptrVM.rawUVM(), pcszDevice, uInstance, enmBus, fUseHostIOCache,
    59945839                           fBuiltinIOCache, false /* fSetupMerge */, 0 /* uMergeSource */,
    … …  
    60075852        {
    60085853            /* too bad, we failed. try to sync the console state with the VMM state */
    6009             vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
     5854            i_vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
    60105855        }
    60115856    }
    … …  
    60295874 * handling this.
    60305875 */
    6031 int Console::hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName)
     5876int Console::i_hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName)
    60325877{
    60335878    /* Everyone seems to delegate all HGCM calls to VMMDev, so stick to this
    … …  
    60405885 * Merely passes the call to Guest::enableVMMStatistics().
    60415886 */
    6042 void Console::enableVMMStatistics(BOOL aEnable)
     5887void Console::i_enableVMMStatistics(BOOL aEnable)
    60435888{
    60445889    if (mGuest)
    … …  
    60505895 * a specific reason.
    60515896 */
    6052 HRESULT Console::pause(Reason_T aReason)
     5897HRESULT Console::i_pause(Reason_T aReason)
    60535898{
    60545899    LogFlowThisFuncEnter();
    … …  
    60725917
    60735918        default:
    6074             return setInvalidMachineStateError();
     5919            return i_setInvalidMachineStateError();
    60755920    }
    60765921
    … …  
    61085953 * a specific reason.
    61095954 */
    6110 HRESULT Console::resume(Reason_T aReason)
     5955HRESULT Console::i_resume(Reason_T aReason)
    61115956{
    61125957    LogFlowThisFuncEnter();
    … …  
    61676012 * a VM for a specific reason.
    61686013 */
    6169 HRESULT Console::saveState(Reason_T aReason, IProgress **aProgress)
     6014HRESULT Console::i_saveState(Reason_T aReason, IProgress **aProgress)
    61706015{
    61716016    LogFlowThisFuncEnter();
    … …  
    62396084
    62406085        /* sync the state with the server */
    6241         setMachineStateLocally(MachineState_Saving);
     6086        i_setMachineStateLocally(MachineState_Saving);
    62426087
    62436088        /* ensure the directory for the saved state file exists */
    … …  
    62776122
    62786123        /* create a thread to wait until the VM state is saved */
    6279         int vrc = RTThreadCreate(NULL, Console::saveStateThread, (void *)task.get(),
     6124        int vrc = RTThreadCreate(NULL, Console::i_saveStateThread, (void *)task.get(),
    62806125                                 0, RTTHREADTYPE_MAIN_WORKER, 0, "VMSave");
    62816126        if (RT_FAILURE(vrc))
    … …  
    63106155        {
    63116156            /* restore the paused state if appropriate */
    6312             setMachineStateLocally(MachineState_Paused);
     6157            i_setMachineStateLocally(MachineState_Paused);
    63136158            /* restore the running state if appropriate */
    63146159            SafeVMPtr ptrVM(this);
    … …  
    63216166        }
    63226167        else
    6323             setMachineStateLocally(lastMachineState);
     6168            i_setMachineStateLocally(lastMachineState);
    63246169    }
    63256170
    … …  
    63376182 * @note Locks this object for writing.
    63386183 */
    6339 HRESULT Console::updateMachineState(MachineState_T aMachineState)
     6184HRESULT Console::i_updateMachineState(MachineState_T aMachineState)
    63406185{
    63416186    AutoCaller autoCaller(this);
    … …  
    63526197                 , E_FAIL);
    63536198
    6354     return setMachineStateLocally(aMachineState);
     6199    return i_setMachineStateLocally(aMachineState);
    63556200}
    63566201
    … …  
    63606205 */
    63616206#endif
    6362 void Console::onMousePointerShapeChange(bool fVisible, bool fAlpha,
    6363                                         uint32_t xHot, uint32_t yHot,
     6207void Console::i_onMousePointerShapeChange(bool fVisible, bool fAlpha,
     6208                                          uint32_t xHot, uint32_t yHot,
    63646209                                        uint32_t width, uint32_t height,
    63656210                                        ComSafeArrayIn(BYTE,pShape))
    … …  
    64126257 */
    64136258#endif
    6414 void Console::onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
    6415                                       BOOL supportsMT, BOOL needsHostCursor)
     6259void Console::i_onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
     6260                                        BOOL supportsMT, BOOL needsHostCursor)
    64166261{
    64176262    LogFlowThisFunc(("supportsAbsolute=%d supportsRelative=%d needsHostCursor=%d\n",
    … …  
    64376282}
    64386283
    6439 void Console::onStateChange(MachineState_T machineState)
     6284void Console::i_onStateChange(MachineState_T machineState)
    64406285{
    64416286    AutoCaller autoCaller(this);
    … …  
    64446289}
    64456290
    6446 void Console::onAdditionsStateChange()
     6291void Console::i_onAdditionsStateChange()
    64476292{
    64486293    AutoCaller autoCaller(this);
    … …  
    64596304 *          Additions are available (via VBoxTray/VBoxClient).
    64606305 */
    6461 void Console::onAdditionsOutdated()
     6306void Console::i_onAdditionsOutdated()
    64626307{
    64636308    AutoCaller autoCaller(this);
    … …  
    64726317 */
    64736318#endif
    6474 void Console::onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
     6319void Console::i_onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock)
    64756320{
    64766321    AutoCaller autoCaller(this);
    … …  
    64936338}
    64946339
    6495 void Console::onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
    6496                                      IVirtualBoxErrorInfo *aError)
     6340void Console::i_onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
     6341                                       IVirtualBoxErrorInfo *aError)
    64976342{
    64986343    AutoCaller autoCaller(this);
    … …  
    65026347}
    65036348
    6504 void Console::onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage)
     6349void Console::i_onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage)
    65056350{
    65066351    AutoCaller autoCaller(this);
    … …  
    65106355}
    65116356
    6512 HRESULT Console::onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId)
     6357HRESULT Console::i_onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId)
    65136358{
    65146359    AssertReturn(aCanShow, E_POINTER);
    … …  
    66016446 * @note Locks this object for writing.
    66026447 */
    6603 HRESULT Console::addVMCaller(bool aQuiet /* = false */,
    6604                              bool aAllowNullVM /* = false */)
     6448HRESULT Console::i_addVMCaller(bool aQuiet /* = false */,
     6449                               bool aAllowNullVM /* = false */)
    66056450{
    66066451    AutoCaller autoCaller(this);
    … …  
    66416486 * @note Locks this object for writing.
    66426487 */
    6643 void Console::releaseVMCaller()
     6488void Console::i_releaseVMCaller()
    66446489{
    66456490    AutoCaller autoCaller(this);
    … …  
    66616506
    66626507
    6663 HRESULT Console::safeVMPtrRetainer(PUVM *a_ppUVM, bool a_Quiet)
     6508HRESULT Console::i_safeVMPtrRetainer(PUVM *a_ppUVM, bool a_Quiet)
    66646509{
    66656510    *a_ppUVM = NULL;
    … …  
    66966541}
    66976542
    6698 void Console::safeVMPtrReleaser(PUVM *a_ppUVM)
     6543void Console::i_safeVMPtrReleaser(PUVM *a_ppUVM)
    66996544{
    67006545    if (*a_ppUVM)
    … …  
    67106555 * Note that the logic must be in sync with Machine::DeleteSettings().
    67116556 */
    6712 HRESULT Console::consoleInitReleaseLog(const ComPtr<IMachine> aMachine)
     6557HRESULT Console::i_consoleInitReleaseLog(const ComPtr<IMachine> aMachine)
    67136558{
    67146559    HRESULT hrc = S_OK;
    … …  
    67976642 * @param   aPaused         true if PowerUpPaused called.
    67986643 */
    6799 HRESULT Console::powerUp(IProgress **aProgress, bool aPaused)
     6644HRESULT Console::i_powerUp(IProgress **aProgress, bool aPaused)
    68006645{
    68016646
    … …  
    68276672        /* Set up release logging as early as possible after the check if
    68286673         * there is already a running VM which we shouldn't disturb. */
    6829         rc = consoleInitReleaseLog(mMachine);
     6674        rc = i_consoleInitReleaseLog(mMachine);
    68306675        if (FAILED(rc))
    68316676            throw rc;
    … …  
    68936738         * saved state file (if not yet done).
    68946739         */
    6895         rc = loadDataFromSavedState();
     6740        rc = i_loadDataFromSavedState();
    68966741        if (FAILED(rc))
    68976742            throw rc;
    … …  
    69376782        ComAssertComRCRetRC(task->rc());
    69386783
    6939         task->mConfigConstructor = configConstructor;
     6784        task->mConfigConstructor = i_configConstructor;
    69406785        task->mSharedFolders = sharedFolders;
    69416786        task->mStartPaused = aPaused;
    … …  
    72037048        }
    72047049
    7205         int vrc = RTThreadCreate(NULL, Console::powerUpThread,
     7050        int vrc = RTThreadCreate(NULL, Console::i_powerUpThread,
    72067051                                 (void *)task.get(), 0,
    72077052                                 RTTHREADTYPE_MAIN_WORKER, 0, "VMPwrUp");
    … …  
    72167061         * any error reporting and appropriate state change! */
    72177062        if (mMachineState == MachineState_Saved)
    7218             setMachineState(MachineState_Restoring);
     7063            i_setMachineState(MachineState_Restoring);
    72197064        else if (fTeleporterEnabled)
    7220            setMachineState(MachineState_TeleportingIn);
     7065            i_setMachineState(MachineState_TeleportingIn);
    72217066        else if (enmFaultToleranceState == FaultToleranceState_Standby)
    7222             setMachineState(MachineState_FaultTolerantSyncing);
     7067            i_setMachineState(MachineState_FaultTolerantSyncing);
    72237068        else
    7224             setMachineState(MachineState_Starting);
     7069            i_setMachineState(MachineState_Starting);
    72257070    }
    72267071    catch (HRESULT aRC) { rc = aRC; }
    … …  
    72767121 *       release(). Otherwise it will deadlock.
    72777122 */
    7278 HRESULT Console::powerDown(IProgress *aProgress /*= NULL*/)
     7123HRESULT Console::i_powerDown(IProgress *aProgress /*= NULL*/)
    72797124{
    72807125    LogFlowThisFuncEnter();
    … …  
    73447189        && mMachineState != MachineState_FaultTolerantSyncing
    73457190       )
    7346         setMachineState(MachineState_Stopping);
     7191        i_setMachineState(MachineState_Stopping);
    73477192
    73487193    /* ----------------------------------------------------------------------
    … …  
    74637308        {
    74647309            alock.release();
    7465             detachAllUSBDevices(false /* aDone */);
     7310            i_detachAllUSBDevices(false /* aDone */);
    74667311            alock.acquire();
    74677312        }
    … …  
    75187363        {
    75197364            alock.release();
    7520             detachAllUSBDevices(true /* aDone */);
     7365            i_detachAllUSBDevices(true /* aDone */);
    75217366            alock.acquire();
    75227367        }
    … …  
    75587403 * @note Locks this object for writing.
    75597404 */
    7560 HRESULT Console::setMachineState(MachineState_T aMachineState,
     7405HRESULT Console::i_setMachineState(MachineState_T aMachineState,
    75617406                                 bool aUpdateServer /* = true */)
    75627407{
    … …  
    75827427        //      necessary??)
    75837428        LogFlowThisFunc(("Doing onStateChange()...\n"));
    7584         onStateChange(aMachineState);
     7429        i_onStateChange(aMachineState);
    75857430        LogFlowThisFunc(("Done onStateChange()\n"));
    75867431
    … …  
    76227467 * @note The caller must lock this object for writing.
    76237468 */
    7624 HRESULT Console::findSharedFolder(const Utf8Str &strName,
    7625                                   ComObjPtr<SharedFolder> &aSharedFolder,
    7626                                   bool aSetError /* = false */)
     7469HRESULT Console::i_findSharedFolder(const Utf8Str &strName,
     7470                                    ComObjPtr<SharedFolder> &aSharedFolder,
     7471                                    bool aSetError /* = false */)
    76277472{
    76287473    /* sanity check */
    … …  
    76517496 * @note The caller must lock this object for writing.
    76527497 */
    7653 HRESULT Console::fetchSharedFolders(BOOL aGlobal)
     7498HRESULT Console::i_fetchSharedFolders(BOOL aGlobal)
    76547499{
    76557500    /* sanity check */
    … …  
    77367581
    77377582                            /* create the new machine folder */
    7738                             rc = createSharedFolder(strName,
    7739                                                     SharedFolderData(strHostPath, !!writable, !!autoMount));
     7583                            rc = i_createSharedFolder(strName,
     7584                                                      SharedFolderData(strHostPath, !!writable, !!autoMount));
    77407585                            if (FAILED(rc)) throw rc;
    77417586                        }
    … …  
    77667611                        if (git != m_mapGlobalSharedFolders.end())
    77677612                        {
    7768                             rc = createSharedFolder(git->first, git->second);
     7613                            rc = i_createSharedFolder(git->first, git->second);
    77697614                            if (FAILED(rc)) throw rc;
    77707615                        }
    … …  
    77787623        rc = rc2;
    77797624        if (online)
    7780             setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
    7781                                        N_("Broken shared folder!"));
     7625            i_setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
     7626                                         N_("Broken shared folder!"));
    77827627    }
    77837628
    … …  
    77977642 * @note The caller must lock this object for reading.
    77987643 */
    7799 bool Console::findOtherSharedFolder(const Utf8Str &strName,
     7644bool Console::i_findOtherSharedFolder(const Utf8Str &strName,
    78007645                                    SharedFolderDataMap::const_iterator &aIt)
    78017646{
    … …  
    78257670 * @note Doesn't lock anything.
    78267671 */
    7827 HRESULT Console::createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData)
     7672HRESULT Console::i_createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData)
    78287673{
    78297674    ComAssertRet(strName.isNotEmpty(), E_FAIL);
    … …  
    79377782 * @note Doesn't lock anything.
    79387783 */
    7939 HRESULT Console::removeSharedFolder(const Utf8Str &strName)
     7784HRESULT Console::i_removeSharedFolder(const Utf8Str &strName)
    79407785{
    79417786    ComAssertRet(strName.isNotEmpty(), E_FAIL);
    … …  
    79847829 *          calls after the VM was destroyed.
    79857830 */
    7986 DECLCALLBACK(void) Console::vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
     7831DECLCALLBACK(void) Console::i_vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
    79877832{
    79887833    LogFlowFunc(("Changing state from %s to %s (pUVM=%p)\n",
    … …  
    80097854        {
    80107855#ifdef VBOX_WITH_GUEST_PROPS
    8011             if (that->isResetTurnedIntoPowerOff())
     7856            if (that->i_isResetTurnedIntoPowerOff())
    80127857            {
    80137858                Bstr strPowerOffReason;
    … …  
    80627907
    80637908                /* sync the state with the server */
    8064                 that->setMachineStateLocally(MachineState_Stopping);
     7909                that->i_setMachineStateLocally(MachineState_Stopping);
    80657910
    80667911                /* Setup task object and thread to carry out the operation
    … …  
    80837928                }
    80847929
    8085                 int vrc = RTThreadCreate(NULL, Console::powerDownThread,
     7930                int vrc = RTThreadCreate(NULL, Console::i_powerDownThread,
    80867931                                         (void *)task.get(), 0,
    80877932                                         RTTHREADTYPE_MAIN_WORKER, 0,
    … …  
    81157960             */
    81167961            if (pUVM)
    8117                 that->powerDownHostInterfaces();
     7962                that->i_powerDownHostInterfaces();
    81187963
    81197964            /* From now on the machine is officially powered down or remains in
    … …  
    81277972                case MachineState_Stopping:
    81287973                    /* successfully powered down */
    8129                     that->setMachineState(MachineState_PoweredOff);
     7974                    that->i_setMachineState(MachineState_PoweredOff);
    81307975                    break;
    81317976                case MachineState_Saving:
    81327977                    /* successfully saved */
    8133                     that->setMachineState(MachineState_Saved);
     7978                    that->i_setMachineState(MachineState_Saved);
    81347979                    break;
    81357980                case MachineState_Starting:
    81367981                    /* failed to start, but be patient: set back to PoweredOff
    81377982                     * (for similarity with the below) */
    8138                     that->setMachineState(MachineState_PoweredOff);
     7983                    that->i_setMachineState(MachineState_PoweredOff);
    81397984                    break;
    81407985                case MachineState_Restoring:
    81417986                    /* failed to load the saved state file, but be patient: set
    81427987                     * back to Saved (to preserve the saved state file) */
    8143                     that->setMachineState(MachineState_Saved);
     7988                    that->i_setMachineState(MachineState_Saved);
    81447989                    break;
    81457990                case MachineState_TeleportingIn:
    81467991                    /* Teleportation failed or was canceled.  Back to powered off. */
    8147                     that->setMachineState(MachineState_PoweredOff);
     7992                    that->i_setMachineState(MachineState_PoweredOff);
    81487993                    break;
    81497994                case MachineState_TeleportingPausedVM:
    81507995                    /* Successfully teleported the VM. */
    8151                     that->setMachineState(MachineState_Teleported);
     7996                    that->i_setMachineState(MachineState_Teleported);
    81527997                    break;
    81537998                case MachineState_FaultTolerantSyncing:
    81547999                    /* Fault tolerant sync failed or was canceled.  Back to powered off. */
    8155                     that->setMachineState(MachineState_PoweredOff);
     8000                    that->i_setMachineState(MachineState_PoweredOff);
    81568001                    break;
    81578002            }
    … …  
    81638008#ifdef VBOX_WITH_GUEST_PROPS
    81648009            /* Do not take any read/write locks here! */
    8165             that->guestPropertiesHandleVMReset();
     8010            that->i_guestPropertiesHandleVMReset();
    81668011#endif
    81678012            break;
    … …  
    81788023            {
    81798024                case MachineState_Teleporting:
    8180                     that->setMachineState(MachineState_TeleportingPausedVM);
     8025                    that->i_setMachineState(MachineState_TeleportingPausedVM);
    81818026                    break;
    81828027
    81838028                case MachineState_LiveSnapshotting:
    8184                     that->setMachineState(MachineState_Saving);
     8029                    that->i_setMachineState(MachineState_Saving);
    81858030                    break;
    81868031
    … …  
    81978042                    AssertMsgFailed(("%s\n", Global::stringifyMachineState(that->mMachineState)));
    81988043                case MachineState_Running:
    8199                     that->setMachineState(MachineState_Paused);
     8044                    that->i_setMachineState(MachineState_Paused);
    82008045                    break;
    82018046
    … …  
    82168061            {
    82178062                case MachineState_Teleporting:
    8218                     that->setMachineState(MachineState_TeleportingPausedVM);
     8063                    that->i_setMachineState(MachineState_TeleportingPausedVM);
    82198064                    break;
    82208065
    82218066                case MachineState_LiveSnapshotting:
    8222                     that->setMachineState(MachineState_Saving);
     8067                    that->i_setMachineState(MachineState_Saving);
    82238068                    break;
    82248069
    … …  
    82318076                    AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState),
    82328077                                    VMR3GetStateName(enmOldState), VMR3GetStateName(enmState) ));
    8233                     that->setMachineState(MachineState_Paused);
     8078                    that->i_setMachineState(MachineState_Paused);
    82348079                    break;
    82358080            }
    … …  
    82608105                           && enmOldState == VMSTATE_RUNNING_FT));
    82618106
    8262                 that->setMachineState(MachineState_Running);
     8107                that->i_setMachineState(MachineState_Running);
    82638108            }
    82648109
    … …  
    82938138             *       raised, so it is not worth adding a new externally
    82948139             *       visible state for this yet.  */
    8295             that->setMachineState(MachineState_Paused);
     8140            that->i_setMachineState(MachineState_Paused);
    82968141            break;
    82978142        }
    … …  
    83078152            Assert(Global::IsOnline(that->mMachineState));
    83088153
    8309             that->setMachineState(MachineState_Stuck);
     8154            that->i_setMachineState(MachineState_Stuck);
    83108155            break;
    83118156        }
    … …  
    83218166 * @param aClipboardMode  new clipboard mode.
    83228167 */
    8323 void Console::changeClipboardMode(ClipboardMode_T aClipboardMode)
     8168void Console::i_changeClipboardMode(ClipboardMode_T aClipboardMode)
    83248169{
    83258170    VMMDev *pVMMDev = m_pVMMDev;
    … …  
    83588203 * @param aDnDMode  new drag'n'drop mode.
    83598204 */
    8360 int Console::changeDnDMode(DnDMode_T aDnDMode)
     8205int Console::i_changeDnDMode(DnDMode_T aDnDMode)
    83618206{
    83628207    VMMDev *pVMMDev = m_pVMMDev;
    … …  
    84048249 * @note Synchronously calls EMT.
    84058250 */
    8406 HRESULT Console::attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs)
     8251HRESULT Console::i_attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs)
    84078252{
    84088253    AssertReturn(aHostDevice, E_FAIL);
    … …  
    84428287    {
    84438288        RemoteUSBDevice *pRemoteUSBDevice = static_cast<RemoteUSBDevice *>(aHostDevice);
    8444         pvRemoteBackend = consoleVRDPServer()->USBBackendRequestPointer(pRemoteUSBDevice->clientId(), &uuid);
     8289        pvRemoteBackend = i_consoleVRDPServer()->USBBackendRequestPointer(pRemoteUSBDevice->clientId(), &uuid);
    84458290        if (!pvRemoteBackend)
    84468291            return E_INVALIDARG; /* The clientId is invalid then. */
    … …  
    84538298
    84548299    int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
    8455                                (PFNRT)usbAttachCallback, 9,
     8300                               (PFNRT)i_usbAttachCallback, 9,
    84568301                               this, ptrVM.rawUVM(), aHostDevice, uuid.raw(), fRemote,
    84578302                               Address.c_str(), pvRemoteBackend, portVersion, aMaskedIfs);
    … …  
    84708315        /* notify callbacks */
    84718316        alock.release();
    8472         onUSBDeviceStateChange(pUSBDevice, true /* aAttached */, NULL);
     8317        i_onUSBDeviceStateChange(pUSBDevice, true /* aAttached */, NULL);
    84738318    }
    84748319    else
    … …  
    85058350//static
    85068351DECLCALLBACK(int)
    8507 Console::usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid, bool aRemote,
    8508                            const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
     8352Console::i_usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid, bool aRemote,
     8353                             const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
    85098354{
    85108355    LogFlowFuncEnter();
    … …  
    85308375 * @note Synchronously calls EMT.
    85318376 */
    8532 HRESULT Console::detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice)
     8377HRESULT Console::i_detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice)
    85338378{
    85348379    AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
    … …  
    85548399    HRESULT hrc2 = aHostDevice->COMGETTER(Remote)(&fRemote);
    85558400    if (FAILED(hrc2))
    8556         setErrorStatic(hrc2, "GetRemote() failed");
     8401        i_setErrorStatic(hrc2, "GetRemote() failed");
    85578402
    85588403    PCRTUUID pUuid = aHostDevice->i_id().raw();
    … …  
    85608405    {
    85618406        Guid guid(*pUuid);
    8562         consoleVRDPServer()->USBBackendReleasePointer(&guid);
     8407        i_consoleVRDPServer()->USBBackendReleasePointer(&guid);
    85638408    }
    85648409
    85658410    alock.release();
    85668411    int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
    8567                                (PFNRT)usbDetachCallback, 5,
     8412                               (PFNRT)i_usbDetachCallback, 5,
    85688413                               this, ptrVM.rawUVM(), pUuid);
    85698414    if (RT_SUCCESS(vrc))
    … …  
    85728417
    85738418        /* notify callbacks */
    8574         onUSBDeviceStateChange(aHostDevice, false /* aAttached */, NULL);
     8419        i_onUSBDeviceStateChange(aHostDevice, false /* aAttached */, NULL);
    85758420    }
    85768421
    … …  
    85918436//static
    85928437DECLCALLBACK(int)
    8593 Console::usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid)
     8438Console::i_usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid)
    85948439{
    85958440    LogFlowFuncEnter();
    … …  
    88478692 * @note The caller must lock this object for writing.
    88488693 */
    8849 HRESULT Console::powerDownHostInterfaces()
     8694HRESULT Console::i_powerDownHostInterfaces()
    88508695{
    88518696    LogFlowThisFunc(("\n"));
    … …  
    89068751 */
    89078752/*static*/
    8908 DECLCALLBACK(int) Console::stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
     8753DECLCALLBACK(int) Console::i_stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
    89098754{
    89108755    IProgress *pProgress = static_cast<IProgress *>(pvUser);
    … …  
    89258770 */
    89268771/*static*/ DECLCALLBACK(void)
    8927 Console::genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
    8928                                    const char *pszErrorFmt, va_list va)
     8772Console::i_genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
     8773                                     const char *pszErrorFmt, va_list va)
    89298774{
    89308775    Utf8Str *pErrorText = (Utf8Str *)pvUser;
    … …  
    89618806 */
    89628807/* static */ DECLCALLBACK(void)
    8963 Console::setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFlags,
    8964                                    const char *pszErrorId,
    8965                                    const char *pszFormat, va_list va)
     8808Console::i_setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFlags,
     8809                                     const char *pszErrorId,
     8810                                     const char *pszFormat, va_list va)
    89668811{
    89678812    bool const fFatal = !!(fFlags & VMSETRTERR_FLAGS_FATAL);
    … …  
    89868831
    89878832
    8988     that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(), Bstr(message).raw());
     8833    that->i_onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(), Bstr(message).raw());
    89898834
    89908835    LogFlowFuncLeave(); NOREF(pUVM);
    … …  
    89978842 * @param   pUVM    The VM handle.
    89988843 */
    8999 HRESULT Console::captureUSBDevices(PUVM pUVM)
     8844HRESULT Console::i_captureUSBDevices(PUVM pUVM)
    90008845{
    90018846    LogFlowThisFunc(("\n"));
    … …  
    90268871 * purpose of clean up and such like.
    90278872 */
    9028 void Console::detachAllUSBDevices(bool aDone)
     8873void Console::i_detachAllUSBDevices(bool aDone)
    90298874{
    90308875    LogFlowThisFunc(("aDone=%RTbool\n", aDone));
    … …  
    90478892 * @note Locks this object for writing.
    90488893 */
    9049 void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt)
     8894void Console::i_processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt)
    90508895{
    90518896    LogFlowThisFuncEnter();
    … …  
    91398984            {
    91408985                alock.release();
    9141                 hrc = onUSBDeviceAttach(pUSBDevice, NULL, fMaskedIfs);
     8986                hrc = i_onUSBDeviceAttach(pUSBDevice, NULL, fMaskedIfs);
    91428987                alock.acquire();
    91438988
    … …  
    92069051            pUSBDevice->COMGETTER(Id)(uuid.asOutParam());
    92079052            alock.release();
    9208             onUSBDeviceDetach(uuid.raw(), NULL);
     9053            i_onUSBDeviceDetach(uuid.raw(), NULL);
    92099054            alock.acquire();
    92109055        }
    … …  
    92399084 */
    92409085/*static*/
    9241 DECLCALLBACK(int) Console::powerUpThread(RTTHREAD Thread, void *pvUser)
     9086DECLCALLBACK(int) Console::i_powerUpThread(RTTHREAD Thread, void *pvUser)
    92429087{
    92439088    LogFlowFuncEnter();
    … …  
    93029147         *
    93039148         * Note! The media will be unlocked automatically by
    9304          *       SessionMachine::setMachineState() when the VM is powered down.
     9149         *       SessionMachine::i_setMachineState() when the VM is powered down.
    93059150         */
    93069151        if (    !task->mTeleporterEnabled
    … …  
    93149159         * also create the framebuffer, required at VM creation.
    93159160         */
    9316         ConsoleVRDPServer *server = pConsole->consoleVRDPServer();
     9161        ConsoleVRDPServer *server = pConsole->i_consoleVRDPServer();
    93179162        Assert(server);
    93189163
    … …  
    93589203            LogRel(("VRDE: Failed: (%Rrc), error message: '%s'\n",
    93599204                     vrc, errMsg.c_str()));
    9360             throw setErrorStatic(E_FAIL, errMsg.c_str());
    9361         }
    9362 
    9363         ComPtr<IMachine> pMachine = pConsole->machine();
     9205            throw i_setErrorStatic(E_FAIL, errMsg.c_str());
     9206        }
     9207
     9208        ComPtr<IMachine> pMachine = pConsole->i_machine();
    93649209        ULONG cCpus = 1;
    93659210        pMachine->COMGETTER(CPUCount)(&cCpus);
    … …  
    93769221        vrc = VMR3Create(cCpus,
    93779222                         pConsole->mpVmm2UserMethods,
    9378                          Console::genericVMSetErrorCallback,
     9223                         Console::i_genericVMSetErrorCallback,
    93799224                         &task->mErrorMsg,
    93809225                         task->mConfigConstructor,
    … …  
    93859230
    93869231        /* Enable client connections to the server. */
    9387         pConsole->consoleVRDPServer()->EnableConnections();
     9232        pConsole->i_consoleVRDPServer()->EnableConnections();
    93889233
    93899234        if (RT_SUCCESS(vrc))
    … …  
    93969241                vrc = SSMR3RegisterExternal(pConsole->mpUVM, sSSMConsoleUnit, 0 /*iInstance*/, sSSMConsoleVer, 0 /* cbGuess */,
    93979242                                            NULL, NULL, NULL,
    9398                                             NULL, saveStateFileExec, NULL,
    9399                                             NULL, loadStateFileExec, NULL,
     9243                                            NULL, i_saveStateFileExec, NULL,
     9244                                            NULL, i_loadStateFileExec, NULL,
    94009245                                            static_cast<Console *>(pConsole));
    94019246                AssertRCBreak(vrc);
    94029247
    9403                 vrc = static_cast<Console *>(pConsole)->getDisplay()->registerSSM(pConsole->mpUVM);
     9248                vrc = static_cast<Console *>(pConsole)->i_getDisplay()->registerSSM(pConsole->mpUVM);
    94049249                AssertRC(vrc);
    94059250                if (RT_FAILURE(vrc))
    … …  
    94099254                 * Synchronize debugger settings
    94109255                 */
    9411                 MachineDebugger *machineDebugger = pConsole->getMachineDebugger();
     9256                MachineDebugger *machineDebugger = pConsole->i_getMachineDebugger();
    94129257                if (machineDebugger)
    94139258                    machineDebugger->i_flushQueuedSettings();
    … …  
    94279272                    {
    94289273                        const SharedFolderData &d = it->second;
    9429                         rc = pConsole->createSharedFolder(it->first, d);
     9274                        rc = pConsole->i_createSharedFolder(it->first, d);
    94309275                        if (FAILED(rc))
    94319276                        {
    94329277                            ErrorInfoKeeper eik;
    9433                             pConsole->setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
     9278                            pConsole->i_setVMRuntimeErrorCallbackF(0, "BrokenSharedFolder",
    94349279                                   N_("The shared folder '%s' could not be set up: %ls.\n"
    94359280                                      "The shared folder setup will not be complete. It is recommended to power down the virtual "
    94369281                                      "machine and fix the shared folder settings while the machine is not running"),
    9437                                     it->first.c_str(), eik.getText().raw());
     9282                                      it->first.c_str(), eik.getText().raw());
    94389283                        }
    94399284                    }
    … …  
    94519296                 * Capture USB devices.
    94529297                 */
    9453                 rc = pConsole->captureUSBDevices(pConsole->mpUVM);
     9298                rc = pConsole->i_captureUSBDevices(pConsole->mpUVM);
    94549299                if (FAILED(rc))
    94559300                    break;
    … …  
    94639308                    vrc = VMR3LoadFromFile(pConsole->mpUVM,
    94649309                                           task->mSavedStateFile.c_str(),
    9465                                            Console::stateProgressCallback,
     9310                                           Console::i_stateProgressCallback,
    94669311                                           static_cast<IProgress *>(task->mProgress));
    94679312
    … …  
    94709315                        if (task->mStartPaused)
    94719316                            /* done */
    9472                             pConsole->setMachineState(MachineState_Paused);
     9317                            pConsole->i_setMachineState(MachineState_Paused);
    94739318                        else
    94749319                        {
    … …  
    94969341                    /* -> ConsoleImplTeleporter.cpp */
    94979342                    bool fPowerOffOnFailure;
    9498                     rc = pConsole->teleporterTrg(pConsole->mpUVM, pMachine, &task->mErrorMsg, task->mStartPaused,
    9499                                                  task->mProgress, &fPowerOffOnFailure);
     9343                    rc = pConsole->i_teleporterTrg(pConsole->mpUVM, pMachine, &task->mErrorMsg, task->mStartPaused,
     9344                                                   task->mProgress, &fPowerOffOnFailure);
    95009345                    if (FAILED(rc) && fPowerOffOnFailure)
    95019346                    {
    … …  
    95549399                else if (task->mStartPaused)
    95559400                    /* done */
    9556                     pConsole->setMachineState(MachineState_Paused);
     9401                    pConsole->i_setMachineState(MachineState_Paused);
    95579402                else
    95589403                {
    … …  
    95809425                 * cleanup (VRDP, USB devices) */
    95819426                alock.release();
    9582                 HRESULT rc2 = pConsole->powerDown();
     9427                HRESULT rc2 = pConsole->i_powerDown();
    95839428                alock.acquire();
    95849429                AssertComRC(rc2);
    … …  
    95929437                 */
    95939438                alock.release();
    9594                 VMR3AtErrorDeregister(pConsole->mpUVM, Console::genericVMSetErrorCallback, &task->mErrorMsg);
     9439                VMR3AtErrorDeregister(pConsole->mpUVM, Console::i_genericVMSetErrorCallback, &task->mErrorMsg);
    95959440                /** @todo register another VMSetError callback? */
    95969441                alock.acquire();
    … …  
    96279472            /* Set the error message as the COM error.
    96289473             * Progress::notifyComplete() will pick it up later. */
    9629             throw setErrorStatic(E_FAIL, task->mErrorMsg.c_str());
     9474            throw i_setErrorStatic(E_FAIL, task->mErrorMsg.c_str());
    96309475        }
    96319476    }
    … …  
    96519496
    96529497        Assert(pConsole->mpUVM == NULL);
    9653         vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING, pConsole);
     9498        i_vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING, pConsole);
    96549499    }
    96559500
    … …  
    97059550 */
    97069551/* static */
    9707 DECLCALLBACK(int) Console::reconfigureMediumAttachment(Console *pThis,
    9708                                                        PUVM pUVM,
    9709                                                        const char *pcszDevice,
    9710                                                        unsigned uInstance,
    9711                                                        StorageBus_T enmBus,
    9712                                                        bool fUseHostIOCache,
    9713                                                        bool fBuiltinIOCache,
    9714                                                        bool fSetupMerge,
    9715                                                        unsigned uMergeSource,
    9716                                                        unsigned uMergeTarget,
    9717                                                        IMediumAttachment *aMediumAtt,
    9718                                                        MachineState_T aMachineState,
    9719                                                        HRESULT *phrc)
     9552DECLCALLBACK(int) Console::i_reconfigureMediumAttachment(Console *pThis,
     9553                                                         PUVM pUVM,
     9554                                                         const char *pcszDevice,
     9555                                                         unsigned uInstance,
     9556                                                         StorageBus_T enmBus,
     9557                                                         bool fUseHostIOCache,
     9558                                                         bool fBuiltinIOCache,
     9559                                                         bool fSetupMerge,
     9560                                                         unsigned uMergeSource,
     9561                                                         unsigned uMergeTarget,
     9562                                                         IMediumAttachment *aMediumAtt,
     9563                                                         MachineState_T aMachineState,
     9564                                                         HRESULT *phrc)
    97209565{
    97219566    LogFlowFunc(("pUVM=%p aMediumAtt=%p phrc=%p\n", pUVM, aMediumAtt, phrc));
    … …  
    97459590    /* Update the device instance configuration. */
    97469591    PCFGMNODE pLunL0 = NULL;
    9747     int rc = pThis->configMediumAttachment(pCtlInst,
    9748                                            pcszDevice,
    9749                                            uInstance,
    9750                                            enmBus,
    9751                                            fUseHostIOCache,
    9752                                            fBuiltinIOCache,
    9753                                            fSetupMerge,
    9754                                            uMergeSource,
    9755                                            uMergeTarget,
    9756                                            aMediumAtt,
    9757                                            aMachineState,
    9758                                            phrc,
    9759                                            true /* fAttachDetach */,
    9760                                            false /* fForceUnmount */,
    9761                                            false /* fHotplug */,
    9762                                            pUVM,
    9763                                            NULL /* paLedDevType */,
    9764                                            &pLunL0);
     9592    int rc = pThis->i_configMediumAttachment(pCtlInst,
     9593                                             pcszDevice,
     9594                                             uInstance,
     9595                                             enmBus,
     9596                                             fUseHostIOCache,
     9597                                             fBuiltinIOCache,
     9598                                             fSetupMerge,
     9599                                             uMergeSource,
     9600                                             uMergeTarget,
     9601                                             aMediumAtt,
     9602                                             aMachineState,
     9603                                             phrc,
     9604                                             true /* fAttachDetach */,
     9605                                             false /* fForceUnmount */,
     9606                                             false /* fHotplug */,
     9607                                             pUVM,
     9608                                             NULL /* paLedDevType */,
     9609                                             &pLunL0);
    97659610    /* Dump the changed LUN if possible, dump the complete device otherwise */
    97669611    CFGMR3Dump(pLunL0 ? pLunL0 : pCtlInst);
    … …  
    97939638 */
    97949639/*static*/
    9795 DECLCALLBACK(int) Console::fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser)
     9640DECLCALLBACK(int) Console::i_fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser)
    97969641{
    97979642    VMTakeSnapshotTask *pTask = (VMTakeSnapshotTask*)pvUser;
    … …  
    98459690        if (   !pTask->fTakingSnapshotOnline
    98469691            && !pTask->bstrSavedStateFile.isEmpty())
    9847             throw setErrorStatic(E_FAIL, "Invalid state of saved state file");
     9692            throw i_setErrorStatic(E_FAIL, "Invalid state of saved state file");
    98489693
    98499694        /* sync the state with the server */
    98509695        if (pTask->lastMachineState == MachineState_Running)
    9851             that->setMachineStateLocally(MachineState_LiveSnapshotting);
     9696            that->i_setMachineStateLocally(MachineState_LiveSnapshotting);
    98529697        else
    9853             that->setMachineStateLocally(MachineState_Saving);
     9698            that->i_setMachineStateLocally(MachineState_Saving);
    98549699
    98559700        // STEP 3: save the VM state (if online)
    … …  
    98759720                               strSavedStateFile.c_str(),
    98769721                               true /*fContinueAfterwards*/,
    9877                                Console::stateProgressCallback,
     9722                               Console::i_stateProgressCallback,
    98789723                               static_cast<IProgress *>(pTask->mProgress),
    98799724                               &fSuspenededBySave);
    98809725                alock.acquire();
    98819726                if (RT_FAILURE(vrc))
    9882                     throw setErrorStatic(E_FAIL,
     9727                    throw i_setErrorStatic(E_FAIL,
    98839728                                         tr("Failed to save the machine state to '%s' (%Rrc)"),
    98849729                                         strSavedStateFile.c_str(), vrc);
    … …  
    98909735
    98919736            if (!pTask->mProgress->i_notifyPointOfNoReturn())
    9892                 throw setErrorStatic(E_FAIL, tr("Canceled"));
     9737                throw i_setErrorStatic(E_FAIL, tr("Canceled"));
    98939738            that->mptrCancelableProgress.setNull();
    98949739
    … …  
    99429787                    throw rc;
    99439788
    9944                 const char *pcszDevice = Console::convertControllerTypeToDev(enmController);
     9789                const char *pcszDevice = Console::i_convertControllerTypeToDev(enmController);
    99459790
    99469791                BOOL fBuiltinIOCache;
    … …  
    99549799                 */
    99559800                vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY,
    9956                                        (PFNRT)reconfigureMediumAttachment, 13,
     9801                                       (PFNRT)i_reconfigureMediumAttachment, 13,
    99579802                                       that, ptrVM.rawUVM(), pcszDevice, lInstance, enmBus, fUseHostIOCache,
    99589803                                       fBuiltinIOCache, false /* fSetupMerge */, 0 /* uMergeSource */,
    99599804                                       0 /* uMergeTarget */, atts[i], that->mMachineState, &rc);
    99609805                if (RT_FAILURE(vrc))
    9961                     throw setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
     9806                    throw i_setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
    99629807                if (FAILED(rc))
    99639808                    throw rc;
    … …  
    100039848
    100049849        if (!pTask->fTakingSnapshotOnline)
    10005             that->setMachineStateLocally(pTask->lastMachineState);
     9850            that->i_setMachineStateLocally(pTask->lastMachineState);
    100069851        else if (SUCCEEDED(rc))
    100079852        {
    … …  
    100189863                if (RT_FAILURE(vrc))
    100199864                {
    10020                     rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
     9865                    rc = i_setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
    100219866                    pTask->mProgress->i_notifyComplete(rc);
    100229867                    if (that->mMachineState == MachineState_Saving)
    10023                         that->setMachineStateLocally(MachineState_Paused);
     9868                        that->i_setMachineStateLocally(MachineState_Paused);
    100249869                }
    100259870            }
    100269871            else
    10027                 that->setMachineStateLocally(MachineState_Paused);
     9872                that->i_setMachineStateLocally(MachineState_Paused);
    100289873        }
    100299874        else
    … …  
    100439888                case VMSTATE_RESETTING_LS:
    100449889                    Assert(!fSuspenededBySave);
    10045                     that->setMachineState(MachineState_Running);
     9890                    that->i_setMachineState(MachineState_Running);
    100469891                    break;
    100479892
    100489893                case VMSTATE_GURU_MEDITATION:
    100499894                case VMSTATE_GURU_MEDITATION_LS:
    10050                     that->setMachineState(MachineState_Stuck);
     9895                    that->i_setMachineState(MachineState_Stuck);
    100519896                    break;
    100529897
    … …  
    100549899                case VMSTATE_FATAL_ERROR_LS:
    100559900                    if (pTask->lastMachineState == MachineState_Paused)
    10056                         that->setMachineStateLocally(pTask->lastMachineState);
     9901                        that->i_setMachineStateLocally(pTask->lastMachineState);
    100579902                    else
    10058                         that->setMachineState(MachineState_Paused);
     9903                        that->i_setMachineState(MachineState_Paused);
    100599904                    break;
    100609905
    … …  
    100759920                        alock.acquire();
    100769921                        if (RT_FAILURE(vrc))
    10077                             that->setMachineState(MachineState_Paused);
     9922                            that->i_setMachineState(MachineState_Paused);
    100789923                    }
    100799924                    else if (pTask->lastMachineState == MachineState_Paused)
    10080                         that->setMachineStateLocally(pTask->lastMachineState);
     9925                        that->i_setMachineStateLocally(pTask->lastMachineState);
    100819926                    else
    10082                         that->setMachineState(MachineState_Paused);
     9927                        that->i_setMachineState(MachineState_Paused);
    100839928                    break;
    100849929            }
    … …  
    101149959 */
    101159960/*static*/
    10116 DECLCALLBACK(int) Console::saveStateThread(RTTHREAD Thread, void *pvUser)
     9961DECLCALLBACK(int) Console::i_saveStateThread(RTTHREAD Thread, void *pvUser)
    101179962{
    101189963    LogFlowFuncEnter();
    … …  
    101359980                       task->mSavedStateFile.c_str(),
    101369981                       false, /*fContinueAfterwards*/
    10137                        Console::stateProgressCallback,
     9982                       Console::i_stateProgressCallback,
    101389983                       static_cast<IProgress *>(task->mServerProgress),
    101399984                       &fSuspenededBySave);
    … …  
    1016010005        task->releaseVMCaller();
    1016110006        thatLock.release();
    10162         rc = that->powerDown();
     10007        rc = that->i_powerDown();
    1016310008        thatLock.acquire();
    1016410009    }
    … …  
    1016810013     */
    1016910014    if (FAILED(rc))
    10170         that->setMachineStateLocally(task->mMachineStateBefore);
     10015        that->i_setMachineStateLocally(task->mMachineStateBefore);
    1017110016
    1017210017    /*
    … …  
    1019310038 */
    1019410039/*static*/
    10195 DECLCALLBACK(int) Console::powerDownThread(RTTHREAD Thread, void *pvUser)
     10040DECLCALLBACK(int) Console::i_powerDownThread(RTTHREAD Thread, void *pvUser)
    1019610041{
    1019710042    LogFlowFuncEnter();
    … …  
    1021710062    thatLock.release();
    1021810063
    10219     that->powerDown(task->mServerProgress);
     10064    that->i_powerDown(task->mServerProgress);
    1022010065
    1022110066    /* complete the operation */
    … …  
    1023110076 */
    1023210077/*static*/ DECLCALLBACK(int)
    10233 Console::vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM)
     10078Console::i_vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM)
    1023410079{
    1023510080    Console *pConsole = ((MYVMM2USERMETHODS *)pThis)->pConsole;
    … …  
    1024810093 */
    1024910094/*static*/ DECLCALLBACK(void)
    10250 Console::vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
     10095Console::i_vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
    1025110096{
    1025210097    NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
    … …  
    1025810103 */
    1025910104/*static*/ DECLCALLBACK(void)
    10260 Console::vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
     10105Console::i_vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu)
    1026110106{
    1026210107    NOREF(pThis); NOREF(pUVM); NOREF(pUVCpu);
    … …  
    1026810113 */
    1026910114/*static*/ DECLCALLBACK(void)
    10270 Console::vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM)
     10115Console::i_vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM)
    1027110116{
    1027210117    NOREF(pThis); NOREF(pUVM);
    … …  
    1027810123 */
    1027910124/*static*/ DECLCALLBACK(void)
    10280 Console::vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM)
     10125Console::i_vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM)
    1028110126{
    1028210127    NOREF(pThis); NOREF(pUVM);
    … …  
    1028810133 */
    1028910134/*static*/ DECLCALLBACK(void)
    10290 Console::vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM)
     10135Console::i_vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM)
    1029110136{
    1029210137    Console *pConsole = ((MYVMM2USERMETHODS *)pThis)->pConsole;
    … …  
    1033810183 * @param   iLUN            The unit number.
    1033910184 */
    10340 DECLCALLBACK(void) Console::drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
     10185DECLCALLBACK(void) Console::i_drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN)
    1034110186{
    1034210187    PDRVMAINSTATUS pThis = RT_FROM_MEMBER(pInterface, DRVMAINSTATUS, ILedConnectors);
    … …  
    1036010205 * @param   uLUN            The unit number.
    1036110206 */
    10362 DECLCALLBACK(int) Console::drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned uLUN)
     10207DECLCALLBACK(int) Console::i_drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned uLUN)
    1036310208{
    1036410209    PDRVMAINSTATUS pThis = RT_FROM_MEMBER(pInterface, DRVMAINSTATUS, IMediaNotify);
    … …  
    1041210257 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
    1041310258 */
    10414 DECLCALLBACK(void *)  Console::drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
     10259DECLCALLBACK(void *)  Console::i_drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
    1041510260{
    1041610261    PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
    … …  
    1042910274 * @param   pDrvIns     The driver instance data.
    1043010275 */
    10431 DECLCALLBACK(void) Console::drvStatus_Destruct(PPDMDRVINS pDrvIns)
     10276DECLCALLBACK(void) Console::i_drvStatus_Destruct(PPDMDRVINS pDrvIns)
    1043210277{
    1043310278    PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
    … …  
    1044910294 * @copydoc FNPDMDRVCONSTRUCT
    1045010295 */
    10451 DECLCALLBACK(int) Console::drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
     10296DECLCALLBACK(int) Console::i_drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
    1045210297{
    1045310298    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
    … …  
    1046710312     * Data.
    1046810313     */
    10469     pDrvIns->IBase.pfnQueryInterface        = Console::drvStatus_QueryInterface;
    10470     pThis->ILedConnectors.pfnUnitChanged    = Console::drvStatus_UnitChanged;
    10471     pThis->IMediaNotify.pfnEjected          = Console::drvStatus_MediumEjected;
     10314    pDrvIns->IBase.pfnQueryInterface        = Console::i_drvStatus_QueryInterface;
     10315    pThis->ILedConnectors.pfnUnitChanged    = Console::i_drvStatus_UnitChanged;
     10316    pThis->IMediaNotify.pfnEjected          = Console::i_drvStatus_MediumEjected;
    1047210317    pThis->pDrvIns                          = pDrvIns;
    1047310318    pThis->pszDeviceInstance                = NULL;
    … …  
    1053710382
    1053810383    for (unsigned i = pThis->iFirstLUN; i <= pThis->iLastLUN; ++i)
    10539         Console::drvStatus_UnitChanged(&pThis->ILedConnectors, i);
     10384        Console::i_drvStatus_UnitChanged(&pThis->ILedConnectors, i);
    1054010385
    1054110386    return VINF_SUCCESS;
    … …  
    1056710412    sizeof(DRVMAINSTATUS),
    1056810413    /* pfnConstruct */
    10569     Console::drvStatus_Construct,
     10414    Console::i_drvStatus_Construct,
    1057010415    /* pfnDestruct */
    10571     Console::drvStatus_Destruct,
     10416    Console::i_drvStatus_Destruct,
    1057210417    /* pfnRelocate */
    1057310418    NULL,
    … …  
    1059410439};
    1059510440
     10441
     10442
    1059610443/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

    r51560 r51612  
    605605
    606606#ifdef VBOX_WITH_PCI_PASSTHROUGH
    607 HRESULT Console::attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices)
     607HRESULT Console::i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *pBusMgr, PCFGMNODE pDevices)
    608608{
    609609    HRESULT hrc = S_OK;
    … …  
    611611
    612612    SafeIfaceArray<IPCIDeviceAttachment> assignments;
    613     ComPtr<IMachine> aMachine = machine();
     613    ComPtr<IMachine> aMachine = i_machine();
    614614
    615615    hrc = aMachine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
    … …  
    744744
    745745
    746 void Console::attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
    747                                  uint64_t uFirst, uint64_t uLast,
    748                                  Console::MediumAttachmentMap *pmapMediumAttachments,
    749                                  const char *pcszDevice, unsigned uInstance)
     746void Console::i_attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
     747                                   uint64_t uFirst, uint64_t uLast,
     748                                   Console::MediumAttachmentMap *pmapMediumAttachments,
     749                                   const char *pcszDevice, unsigned uInstance)
    750750{
    751751    PCFGMNODE pLunL0, pCfg;
    … …  
    781781 *  @note Locks the Console object for writing.
    782782 */
    783 DECLCALLBACK(int) Console::configConstructor(PUVM pUVM, PVM pVM, void *pvConsole)
     783DECLCALLBACK(int) Console::i_configConstructor(PUVM pUVM, PVM pVM, void *pvConsole)
    784784{
    785785    LogFlowFuncEnter();
    … …  
    803803    try
    804804    {
    805         vrc = pConsole->configConstructorInner(pUVM, pVM, &alock);
     805        vrc = pConsole->i_configConstructorInner(pUVM, pVM, &alock);
    806806    }
    807807    catch (...)
    … …  
    829829 *                      more).
    830830 */
    831 int Console::configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock)
     831int Console::i_configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock)
    832832{
    833833    VMMDev         *pVMMDev   = m_pVMMDev; Assert(pVMMDev);
    834     ComPtr<IMachine> pMachine = machine();
     834    ComPtr<IMachine> pMachine = i_machine();
    835835
    836836    int             rc;
    … …  
    11851185
    11861186        /* Reset overwrite. */
    1187         if (isResetTurnedIntoPowerOff())
     1187        if (i_isResetTurnedIntoPowerOff())
    11881188            InsertConfigInteger(pRoot, "PowerOffInsteadOfReset", 1);
    11891189
    … …  
    14231423#ifdef VBOX_WITH_PCI_PASSTHROUGH
    14241424            /* Add PCI passthrough devices */
    1425             hrc = attachRawPCIDevices(pUVM, pBusMgr, pDevices);                             H();
     1425            hrc = i_attachRawPCIDevices(pUVM, pBusMgr, pDevices);                             H();
    14261426#endif
    14271427        }
    … …  
    15851585            case GraphicsControllerType_VMSVGA:
    15861586#endif
    1587                 rc = configGraphicsController(pDevices, graphicsController, pBusMgr, pMachine, biosSettings,
    1588                                               RT_BOOL(fHMEnabled));
     1587                rc = i_configGraphicsController(pDevices, graphicsController, pBusMgr, pMachine, biosSettings,
     1588                                                RT_BOOL(fHMEnabled));
    15891589                if (FAILED(rc))
    15901590                    return rc;
    … …  
    17991799                     * Attach the status driver.
    18001800                     */
    1801                     attachStatusDriver(pInst, &mapUSBLed[0], 0, 0, NULL, NULL, 0);
     1801                    i_attachStatusDriver(pInst, &mapUSBLed[0], 0, 0, NULL, NULL, 0);
    18021802                }
    18031803#ifdef VBOX_WITH_EHCI
    … …  
    18301830                         * Attach the status driver.
    18311831                         */
    1832                         attachStatusDriver(pInst, &mapUSBLed[1], 0, 0, NULL, NULL, 0);
     1832                        i_attachStatusDriver(pInst, &mapUSBLed[1], 0, 0, NULL, NULL, 0);
    18331833                    }
    18341834# ifdef VBOX_WITH_EXTPACK
    … …  
    18761876                         * Attach the status driver.
    18771877                         */
    1878                         attachStatusDriver(pInst, &mapUSBLed[1], 0, 0, NULL, NULL, 0);
     1878                        i_attachStatusDriver(pInst, &mapUSBLed[1], 0, 0, NULL, NULL, 0);
    18791879                    }
    18801880# ifdef VBOX_WITH_EXTPACK
    … …  
    20332033
    20342034            PCFGMNODE pCtlInst = NULL;
    2035             const char *pszCtrlDev = convertControllerTypeToDev(enmCtrlType);
     2035            const char *pszCtrlDev = i_convertControllerTypeToDev(enmCtrlType);
    20362036            if (enmCtrlType != StorageControllerType_USB)
    20372037            {
    … …  
    20782078                    /* Attach the status driver */
    20792079                    Assert(cLedScsi >= 16);
    2080                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
     2080                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
    20812081                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    20822082                    paLedDevType = &maStorageDevType[iLedScsi];
    … …  
    21022102                    /* Attach the status driver */
    21032103                    Assert(cLedScsi >= 16);
    2104                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
     2104                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedScsi], 0, 15,
    21052105                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    21062106                    paLedDevType = &maStorageDevType[iLedScsi];
    … …  
    21272127                    /* Attach the status driver */
    21282128                    AssertRelease(cPorts <= cLedSata);
    2129                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSata], 0, cPorts - 1,
     2129                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSata], 0, cPorts - 1,
    21302130                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    21312131                    paLedDevType = &maStorageDevType[iLedSata];
    … …  
    21442144                    /* Attach the status driver */
    21452145                    Assert(cLedIde >= 4);
    2146                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedIde], 0, 3,
     2146                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedIde], 0, 3,
    21472147                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    21482148                    paLedDevType = &maStorageDevType[iLedIde];
    … …  
    21682168                    /* Attach the status driver */
    21692169                    Assert(cLedFloppy >= 2);
    2170                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedFloppy], 0, 1,
     2170                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedFloppy], 0, 1,
    21712171                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    21722172                    paLedDevType = &maStorageDevType[iLedFloppy];
    … …  
    21972197                    /* Attach the status driver */
    21982198                    Assert(cLedSas >= 8);
    2199                     attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSas], 0, 7,
     2199                    i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedSas], 0, 7,
    22002200                                       &mapMediumAttachments, pszCtrlDev, ulInstance);
    22012201                    paLedDevType = &maStorageDevType[iLedSas];
    … …  
    22402240            {
    22412241                IMediumAttachment *pMediumAtt = atts[j];
    2242                 rc = configMediumAttachment(pCtlInst,
    2243                                             pszCtrlDev,
    2244                                             ulInstance,
    2245                                             enmBus,
    2246                                             !!fUseHostIOCache,
    2247                                             !!fBuiltinIOCache,
    2248                                             false /* fSetupMerge */,
    2249                                             0 /* uMergeSource */,
    2250                                             0 /* uMergeTarget */,
    2251                                             pMediumAtt,
    2252                                             mMachineState,
    2253                                             NULL /* phrc */,
    2254                                             false /* fAttachDetach */,
    2255                                             false /* fForceUnmount */,
    2256                                             false /* fHotplug */,
    2257                                             pUVM,
    2258                                             paLedDevType,
    2259                                             NULL /* ppLunL0 */);
     2242                rc = i_configMediumAttachment(pCtlInst,
     2243                                              pszCtrlDev,
     2244                                              ulInstance,
     2245                                              enmBus,
     2246                                              !!fUseHostIOCache,
     2247                                              !!fBuiltinIOCache,
     2248                                              false /* fSetupMerge */,
     2249                                              0 /* uMergeSource */,
     2250                                              0 /* uMergeTarget */,
     2251                                              pMediumAtt,
     2252                                              mMachineState,
     2253                                              NULL /* phrc */,
     2254                                              false /* fAttachDetach */,
     2255                                              false /* fForceUnmount */,
     2256                                              false /* fHotplug */,
     2257                                              pUVM,
     2258                                              paLedDevType,
     2259                                              NULL /* ppLunL0 */);
    22602260                if (RT_FAILURE(rc))
    22612261                    return rc;
    … …  
    24452445             * Attach the status driver.
    24462446             */
    2447             attachStatusDriver(pInst, &mapNetworkLeds[ulInstance], 0, 0, NULL, NULL, 0);
     2447            i_attachStatusDriver(pInst, &mapNetworkLeds[ulInstance], 0, 0, NULL, NULL, 0);
    24482448
    24492449            /*
    … …  
    24512451             */
    24522452            bool fIgnoreConnectFailure = mMachineState == MachineState_Restoring;
    2453             rc = configNetwork(pszAdapterName,
    2454                                ulInstance,
    2455                                0,
    2456                                networkAdapter,
    2457                                pCfg,
    2458                                pLunL0,
    2459                                pInst,
    2460                                false /*fAttachDetach*/,
    2461                                fIgnoreConnectFailure);
     2453            rc = i_configNetwork(pszAdapterName,
     2454                                 ulInstance,
     2455                                 0,
     2456                                 networkAdapter,
     2457                                 pCfg,
     2458                                 pLunL0,
     2459                                 pInst,
     2460                                 false /*fAttachDetach*/,
     2461                                 fIgnoreConnectFailure);
    24622462            if (RT_FAILURE(rc))
    24632463                return rc;
    … …  
    26132613         * Attach the status driver.
    26142614         */
    2615         attachStatusDriver(pInst, &mapSharedFolderLed, 0, 0, NULL, NULL, 0);
     2615        i_attachStatusDriver(pInst, &mapSharedFolderLed, 0, 0, NULL, NULL, 0);
    26162616
    26172617#ifndef VBOX_WITH_PDM_AUDIO_DRIVER
    … …  
    28172817                    LogRel(("Shared clipboard service loaded.\n"));
    28182818
    2819                     changeClipboardMode(mode);
     2819                    i_changeClipboardMode(mode);
    28202820
    28212821                    /* Setup the service. */
    28222822                    VBOXHGCMSVCPARM parm;
    28232823                    parm.type = VBOX_HGCM_SVC_PARM_32BIT;
    2824                     parm.setUInt32(!useHostClipboard());
     2824                    parm.setUInt32(!i_useHostClipboard());
    28252825                    pVMMDev->hgcmHostCall("VBoxSharedClipboard",
    28262826                                          VBOX_SHARED_CLIPBOARD_HOST_FN_SET_HEADLESS, 1, &parm);
    … …  
    28772877                {
    28782878                    LogRel(("Drag'n drop service loaded.\n"));
    2879                     rc = changeDnDMode(enmMode);
     2879                    rc = i_changeDnDMode(enmMode);
    28802880                }
    28812881            }
    … …  
    29412941         * Guest property service.
    29422942         */
    2943         rc = configGuestProperties(this, pUVM);
     2943        rc = i_configGuestProperties(this, pUVM);
    29442944#endif /* VBOX_WITH_GUEST_PROPS defined */
    29452945
    … …  
    29482948         * Guest control service.
    29492949         */
    2950         rc = configGuestControl(this);
     2950        rc = i_configGuestControl(this);
    29512951#endif /* VBOX_WITH_GUEST_CONTROL defined */
    29522952
    … …  
    31053105     */
    31063106    if (RT_SUCCESS(rc))
    3107         rc = configCfgmOverlay(pRoot, virtualBox, pMachine);
     3107        rc = i_configCfgmOverlay(pRoot, virtualBox, pMachine);
    31083108
    31093109    /*
    … …  
    31113111     */
    31123112    if (RT_SUCCESS(rc))
    3113         rc = configDumpAPISettingsTweaks(virtualBox, pMachine);
     3113        rc = i_configDumpAPISettingsTweaks(virtualBox, pMachine);
    31143114
    31153115#undef H
    … …  
    31203120     * Register VM state change handler.
    31213121     */
    3122     int rc2 = VMR3AtStateRegister(pUVM, Console::vmstateChangeCallback, this);
     3122    int rc2 = VMR3AtStateRegister(pUVM, Console::i_vmstateChangeCallback, this);
    31233123    AssertRC(rc2);
    31243124    if (RT_SUCCESS(rc))
    … …  
    31283128     * Register VM runtime error handler.
    31293129     */
    3130     rc2 = VMR3AtRuntimeErrorRegister(pUVM, Console::setVMRuntimeErrorCallback, this);
     3130    rc2 = VMR3AtRuntimeErrorRegister(pUVM, Console::i_setVMRuntimeErrorCallback, this);
    31313131    AssertRC(rc2);
    31323132    if (RT_SUCCESS(rc))
    … …  
    31513151 */
    31523152/* static */
    3153 int Console::configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine)
     3153int Console::i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine)
    31543154{
    31553155    /*
    … …  
    33273327 */
    33283328/* static */
    3329 int Console::configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine)
     3329int Console::i_configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine)
    33303330{
    33313331    {
    … …  
    33783378}
    33793379
    3380 int Console::configGraphicsController(PCFGMNODE pDevices,
    3381                                       const GraphicsControllerType_T graphicsController,
    3382                                       BusAssignmentManager *pBusMgr,
    3383                                       const ComPtr<IMachine> &pMachine,
    3384                                       const ComPtr<IBIOSSettings> &biosSettings,
    3385                                       bool fHMEnabled)
     3380int Console::i_configGraphicsController(PCFGMNODE pDevices,
     3381                                        const GraphicsControllerType_T graphicsController,
     3382                                        BusAssignmentManager *pBusMgr,
     3383                                        const ComPtr<IMachine> &pMachine,
     3384                                        const ComPtr<IBIOSSettings> &biosSettings,
     3385                                        bool fHMEnabled)
    33863386{
    33873387    // InsertConfig* throws
    … …  
    34123412#endif
    34133413
    3414         attachStatusDriver(pInst, &mapCrOglLed, 0, 0, NULL, NULL, 0);
     3414        i_attachStatusDriver(pInst, &mapCrOglLed, 0, 0, NULL, NULL, 0);
    34153415
    34163416#ifdef VBOX_WITH_VMSVGA
    … …  
    34543454        ULONG ulHeightReduction;
    34553455        IFramebuffer *pFramebuffer = NULL;
    3456         hrc = getDisplay()->QueryFramebuffer(0, &pFramebuffer);
     3456        hrc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
    34573457        if (SUCCEEDED(hrc) && pFramebuffer)
    34583458        {
    … …  
    35203520 * Ellipsis to va_list wrapper for calling setVMRuntimeErrorCallback.
    35213521 */
    3522 void Console::setVMRuntimeErrorCallbackF(uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
     3522void Console::i_setVMRuntimeErrorCallbackF(uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
    35233523{
    35243524    va_list va;
    35253525    va_start(va, pszFormat);
    3526     setVMRuntimeErrorCallback(NULL, this, fFlags, pszErrorId, pszFormat, va);
     3526    i_setVMRuntimeErrorCallback(NULL, this, fFlags, pszErrorId, pszFormat, va);
    35273527    va_end(va);
    35283528}
    … …  
    35483548}
    35493549
    3550 int Console::configMediumAttachment(PCFGMNODE pCtlInst,
    3551                                     const char *pcszDevice,
    3552                                     unsigned uInstance,
    3553                                     StorageBus_T enmBus,
    3554                                     bool fUseHostIOCache,
    3555                                     bool fBuiltinIOCache,
    3556                                     bool fSetupMerge,
    3557                                     unsigned uMergeSource,
    3558                                     unsigned uMergeTarget,
    3559                                     IMediumAttachment *pMediumAtt,
    3560                                     MachineState_T aMachineState,
    3561                                     HRESULT *phrc,
    3562                                     bool fAttachDetach,
    3563                                     bool fForceUnmount,
    3564                                     bool fHotplug,
    3565                                     PUVM pUVM,
    3566                                     DeviceType_T *paLedDevType,
    3567                                     PCFGMNODE *ppLunL0)
     3550int Console::i_configMediumAttachment(PCFGMNODE pCtlInst,
     3551                                      const char *pcszDevice,
     3552                                      unsigned uInstance,
     3553                                      StorageBus_T enmBus,
     3554                                      bool fUseHostIOCache,
     3555                                      bool fBuiltinIOCache,
     3556                                      bool fSetupMerge,
     3557                                      unsigned uMergeSource,
     3558                                      unsigned uMergeTarget,
     3559                                      IMediumAttachment *pMediumAtt,
     3560                                      MachineState_T aMachineState,
     3561                                      HRESULT *phrc,
     3562                                      bool fAttachDetach,
     3563                                      bool fForceUnmount,
     3564                                      bool fHotplug,
     3565                                      PUVM pUVM,
     3566                                      DeviceType_T *paLedDevType,
     3567                                      PCFGMNODE *ppLunL0)
    35683568{
    35693569    // InsertConfig* throws
    … …  
    35903590        unsigned uLUN;
    35913591        PCFGMNODE pLunL0 = NULL;
    3592         hrc = Console::convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);                H();
     3592        hrc = Console::i_convertBusPortDeviceToLun(enmBus, lPort, lDev, uLUN);                H();
    35933593
    35943594        if (enmBus == StorageBus_USB)
    … …  
    36263626                /* Attach the status driver */
    36273627                Assert(cLedUsb >= 8);
    3628                 attachStatusDriver(pCtlInst, &mapStorageLeds[iLedUsb], 0, 7,
     3628                i_attachStatusDriver(pCtlInst, &mapStorageLeds[iLedUsb], 0, 7,
    36293629                                   &mapMediumAttachments, pcszDevice, 0);
    36303630                paLedDevType = &maStorageDevType[iLedUsb];
    … …  
    37563756                Utf8Str utfFile = Utf8Str(strFile);
    37573757                Bstr strSnap;
    3758                 ComPtr<IMachine> pMachine = machine();
     3758                ComPtr<IMachine> pMachine = i_machine();
    37593759                hrc = pMachine->COMGETTER(SnapshotFolder)(strSnap.asOutParam());            H();
    37603760                Utf8Str utfSnap = Utf8Str(strSnap);
    … …  
    37823782                    const char *pszUnit;
    37833783                    uint64_t u64Print = formatDiskSize((uint64_t)i64Size, &pszUnit);
    3784                     setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
     3784                    i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
    37853785                            N_("The medium '%ls' has a logical size of %RU64%s "
    37863786                            "but the file system the medium is located on seems "
    … …  
    38133813                            uint64_t u64PrintSiz = formatDiskSize((LONG64)i64Size, &pszUnitSiz);
    38143814                            uint64_t u64PrintMax = formatDiskSize(maxSize, &pszUnitMax);
    3815                             setVMRuntimeErrorCallbackF(0, "FatPartitionDetected", /* <= not exact but ... */
     3815                            i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected", /* <= not exact but ... */
    38163816                                    N_("The medium '%ls' has a logical size of %RU64%s "
    38173817                                    "but the file system the medium is located on can "
    … …  
    38363836                    const char *pszUnit;
    38373837                    uint64_t u64Print = formatDiskSize(i64Size, &pszUnit);
    3838                     setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
     3838                    i_setVMRuntimeErrorCallbackF(0, "FatPartitionDetected",
    38393839#ifdef RT_OS_WINDOWS
    38403840                            N_("The snapshot folder of this VM '%ls' seems to be located on "
    … …  
    38773877                        || enmFsTypeFile == RTFSTYPE_XFS)
    38783878                    {
    3879                         setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
     3879                        i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
    38803880                                N_("The host I/O cache for at least one controller is disabled "
    38813881                                   "and the medium '%ls' for this VM "
    … …  
    38943894                             && !mfSnapshotFolderExt4WarningShown)
    38953895                    {
    3896                         setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
     3896                        i_setVMRuntimeErrorCallbackF(0, "Ext4PartitionDetected",
    38973897                                N_("The host I/O cache for at least one controller is disabled "
    38983898                                   "and the snapshot folder for this VM "
    … …  
    39473947        }
    39483948
    3949         rc = configMedium(pLunL0,
    3950                           !!fPassthrough,
    3951                           lType,
    3952                           fUseHostIOCache,
    3953                           fBuiltinIOCache,
    3954                           fSetupMerge,
    3955                           uMergeSource,
    3956                           uMergeTarget,
    3957                           strBwGroup.isEmpty() ? NULL : Utf8Str(strBwGroup).c_str(),
    3958                           !!fDiscard,
    3959                           pMedium,
    3960                           aMachineState,
    3961                           phrc);
     3949        rc = i_configMedium(pLunL0,
     3950                            !!fPassthrough,
     3951                            lType,
     3952                            fUseHostIOCache,
     3953                            fBuiltinIOCache,
     3954                            fSetupMerge,
     3955                            uMergeSource,
     3956                            uMergeTarget,
     3957                            strBwGroup.isEmpty() ? NULL : Utf8Str(strBwGroup).c_str(),
     3958                            !!fDiscard,
     3959                            pMedium,
     3960                            aMachineState,
     3961                            phrc);
    39623962        if (RT_FAILURE(rc))
    39633963            return rc;
    … …  
    40054005}
    40064006
    4007 int Console::configMedium(PCFGMNODE pLunL0,
    4008                           bool fPassthrough,
    4009                           DeviceType_T enmType,
    4010                           bool fUseHostIOCache,
    4011                           bool fBuiltinIOCache,
    4012                           bool fSetupMerge,
    4013                           unsigned uMergeSource,
    4014                           unsigned uMergeTarget,
    4015                           const char *pcszBwGroup,
    4016                           bool fDiscard,
    4017                           IMedium *pMedium,
    4018                           MachineState_T aMachineState,
    4019                           HRESULT *phrc)
     4007int Console::i_configMedium(PCFGMNODE pLunL0,
     4008                            bool fPassthrough,
     4009                            DeviceType_T enmType,
     4010                            bool fUseHostIOCache,
     4011                            bool fBuiltinIOCache,
     4012                            bool fSetupMerge,
     4013                            unsigned uMergeSource,
     4014                            unsigned uMergeTarget,
     4015                            const char *pcszBwGroup,
     4016                            bool fDiscard,
     4017                            IMedium *pMedium,
     4018                            MachineState_T aMachineState,
     4019                            HRESULT *phrc)
    40204020{
    40214021    // InsertConfig* throws
    … …  
    40994099                    Bstr loc;
    41004100                    hrc = pMedium->COMGETTER(Location)(loc.asOutParam());                   H();
    4101                     setVMRuntimeErrorCallbackF(0, "DvdOrFloppyImageInaccessible",
    4102                                                "The image file '%ls' is inaccessible and is being ignored. "
    4103                                                "Please select a different image file for the virtual %s drive.",
    4104                                                loc.raw(),
    4105                                                enmType == DeviceType_DVD ? "DVD" : "floppy");
     4101                    i_setVMRuntimeErrorCallbackF(0, "DvdOrFloppyImageInaccessible",
     4102                                                 "The image file '%ls' is inaccessible and is being ignored. "
     4103                                                 "Please select a different image file for the virtual %s drive.",
     4104                                                 loc.raw(),
     4105                                                 enmType == DeviceType_DVD ? "DVD" : "floppy");
    41064106                    pMedium = NULL;
    41074107                }
    … …  
    43254325 *  @thread EMT
    43264326 */
    4327 int Console::configNetwork(const char *pszDevice,
    4328                            unsigned uInstance,
    4329                            unsigned uLun,
    4330                            INetworkAdapter *aNetworkAdapter,
    4331                            PCFGMNODE pCfg,
    4332                            PCFGMNODE pLunL0,
    4333                            PCFGMNODE pInst,
    4334                            bool fAttachDetach,
    4335                            bool fIgnoreConnectFailure)
     4327int Console::i_configNetwork(const char *pszDevice,
     4328                             unsigned uInstance,
     4329                             unsigned uLun,
     4330                             INetworkAdapter *aNetworkAdapter,
     4331                             PCFGMNODE pCfg,
     4332                             PCFGMNODE pLunL0,
     4333                             PCFGMNODE pInst,
     4334                             bool fAttachDetach,
     4335                             bool fIgnoreConnectFailure)
    43364336{
    43374337    AutoCaller autoCaller(this);
    … …  
    43544354        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    43554355
    4356         ComPtr<IMachine> pMachine = machine();
     4356        ComPtr<IMachine> pMachine = i_machine();
    43574357
    43584358        ComPtr<IVirtualBox> virtualBox;
    … …  
    48274827                        if (ioctl(iSock, SIOCGIFFLAGS, &Req) >= 0)
    48284828                            if ((Req.ifr_flags & IFF_UP) == 0)
    4829                                 setVMRuntimeErrorCallbackF(0, "BridgedInterfaceDown",
    4830                                     N_("Bridged interface %s is down. Guest will not be able to use this interface"),
    4831                                     pszBridgedIfName);
     4829                                i_setVMRuntimeErrorCallbackF(0, "BridgedInterfaceDown",
     4830                                     N_("Bridged interface %s is down. Guest will not be able to use this interface"),
     4831                                     pszBridgedIfName);
    48324832
    48334833                        close(iSock);
    … …  
    54525452 * the machine XML and set a couple of initial properties.
    54535453 */
    5454 /* static */ int Console::configGuestProperties(void *pvConsole, PUVM pUVM)
     5454/* static */ int Console::i_configGuestProperties(void *pvConsole, PUVM pUVM)
    54555455{
    54565456#ifdef VBOX_WITH_GUEST_PROPS
    … …  
    55895589        HGCMSVCEXTHANDLE hDummy;
    55905590        HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestPropSvc",
    5591                                          Console::doGuestPropNotification,
     5591                                         Console::i_doGuestPropNotification,
    55925592                                         pvConsole);
    55935593
    … …  
    56095609 * Set up the Guest Control service.
    56105610 */
    5611 /* static */ int Console::configGuestControl(void *pvConsole)
     5611/* static */ int Console::i_configGuestControl(void *pvConsole)
    56125612{
    56135613#ifdef VBOX_WITH_GUEST_CONTROL
    … …  
    56295629        rc = HGCMHostRegisterServiceExtension(&hDummy, "VBoxGuestControlSvc",
    56305630                                              &Guest::notifyCtrlDispatcher,
    5631                                               pConsole->getGuest());
     5631                                              pConsole->i_getGuest());
    56325632        if (RT_FAILURE(rc))
    56335633            Log(("Cannot register VBoxGuestControlSvc extension!\n"));

  • trunk/src/VBox/Main/src-client/ConsoleImplTeleporter.cpp

    r51441 r51612  
    55
    66/*
    7  * Copyright (C) 2010-2013 Oracle Corporation
     7 * Copyright (C) 2010-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    229229 */
    230230HRESULT
    231 Console::teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich,
    232                               const char *pszNAckMsg /*= NULL*/)
     231Console::i_teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich,
     232                                const char *pszNAckMsg /*= NULL*/)
    233233{
    234234    char szMsg[256];
    … …  
    293293 * @remarks the setError laziness forces this to be a Console member.
    294294 */
    295 HRESULT
    296 Console::teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck /*= true*/)
     295HRESULT Console::i_teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck /*= true*/)
    297296{
    298297    int vrc = RTTcpSgWriteL(pState->mhSocket, 2, pszCommand, strlen(pszCommand), "\n", sizeof("\n") - 1);
    … …  
    301300    if (!fWaitForAck)
    302301        return S_OK;
    303     return teleporterSrcReadACK(pState, pszCommand);
     302    return i_teleporterSrcReadACK(pState, pszCommand);
    304303}
    305304
    … …  
    625624 * @param   pState              The teleporter state.
    626625 */
    627 HRESULT
    628 Console::teleporterSrc(TeleporterStateSrc *pState)
     626HRESULT Console::i_teleporterSrc(TeleporterStateSrc *pState)
    629627{
    630628    AutoCaller autoCaller(this);
    … …  
    670668
    671669    /* ACK */
    672     hrc = teleporterSrcReadACK(pState, "password", tr("Invalid password"));
     670    hrc = i_teleporterSrcReadACK(pState, "password", tr("Invalid password"));
    673671    if (FAILED(hrc))
    674672        return hrc;
    … …  
    681679     *       in the first pass, so we should fail pretty promptly on misconfig.
    682680     */
    683     hrc = teleporterSrcSubmitCommand(pState, "load");
     681    hrc = i_teleporterSrcSubmitCommand(pState, "load");
    684682    if (FAILED(hrc))
    685683        return hrc;
    … …  
    698696            && RT_SUCCESS(RTTcpSelectOne(pState->mhSocket, 1)))
    699697        {
    700             hrc = teleporterSrcReadACK(pState, "load-complete");
     698            hrc = i_teleporterSrcReadACK(pState, "load-complete");
    701699            if (FAILED(hrc))
    702700                return hrc;
    … …  
    705703    }
    706704
    707     hrc = teleporterSrcReadACK(pState, "load-complete");
     705    hrc = i_teleporterSrcReadACK(pState, "load-complete");
    708706    if (FAILED(hrc))
    709707        return hrc;
    … …  
    714712    if (!pState->mptrProgress->i_notifyPointOfNoReturn())
    715713    {
    716         teleporterSrcSubmitCommand(pState, "cancel", false /*fWaitForAck*/);
     714        i_teleporterSrcSubmitCommand(pState, "cancel", false /*fWaitForAck*/);
    717715        return E_FAIL;
    718716    }
    … …  
    729727    pState->mfUnlockedMedia = true;
    730728
    731     hrc = teleporterSrcSubmitCommand(pState, "lock-media");
     729    hrc = i_teleporterSrcSubmitCommand(pState, "lock-media");
    732730    if (FAILED(hrc))
    733731        return hrc;
    … …  
    738736    if (    vrc == VINF_SSM_LIVE_SUSPENDED
    739737        ||  pState->menmOldMachineState == MachineState_Paused)
    740         hrc = teleporterSrcSubmitCommand(pState, "hand-over-paused");
     738        hrc = i_teleporterSrcSubmitCommand(pState, "hand-over-paused");
    741739    else
    742         hrc = teleporterSrcSubmitCommand(pState, "hand-over-resume");
     740        hrc = i_teleporterSrcSubmitCommand(pState, "hand-over-resume");
    743741    if (FAILED(hrc))
    744742        return hrc;
    … …  
    760758 */
    761759/*static*/ DECLCALLBACK(int)
    762 Console::teleporterSrcThreadWrapper(RTTHREAD hThread, void *pvUser)
     760Console::i_teleporterSrcThreadWrapper(RTTHREAD hThread, void *pvUser)
    763761{
    764762    TeleporterStateSrc *pState = (TeleporterStateSrc *)pvUser;
    … …  
    772770
    773771    if (SUCCEEDED(hrc))
    774         hrc = pState->mptrConsole->teleporterSrc(pState);
     772        hrc = pState->mptrConsole->i_teleporterSrc(pState);
    775773
    776774    /* Close the connection ASAP on so that the other side can complete. */
    … …  
    815813        autoLock.release();
    816814
    817         hrc = pState->mptrConsole->powerDown();
     815        hrc = pState->mptrConsole->i_powerDown();
    818816
    819817        autoLock.acquire();
    … …  
    867865                    Assert(!pState->mfSuspendedByUs);
    868866                    Assert(!pState->mfUnlockedMedia);
    869                     pState->mptrConsole->setMachineState(MachineState_Running);
     867                    pState->mptrConsole->i_setMachineState(MachineState_Running);
    870868                    break;
    871869
    872870                case VMSTATE_GURU_MEDITATION:
    873871                case VMSTATE_GURU_MEDITATION_LS:
    874                     pState->mptrConsole->setMachineState(MachineState_Stuck);
     872                    pState->mptrConsole->i_setMachineState(MachineState_Stuck);
    875873                    break;
    876874
    877875                case VMSTATE_FATAL_ERROR:
    878876                case VMSTATE_FATAL_ERROR_LS:
    879                     pState->mptrConsole->setMachineState(MachineState_Paused);
     877                    pState->mptrConsole->i_setMachineState(MachineState_Paused);
    880878                    break;
    881879
    … …  
    889887                    if (!pState->mfUnlockedMedia)
    890888                    {
    891                         pState->mptrConsole->setMachineState(MachineState_Paused);
     889                        pState->mptrConsole->i_setMachineState(MachineState_Paused);
    892890                        if (pState->mfSuspendedByUs)
    893891                        {
    … …  
    901899                    {
    902900                        /* Faking a guru meditation is the best I can think of doing here... */
    903                         pState->mptrConsole->setMachineState(MachineState_Stuck);
     901                        pState->mptrConsole->i_setMachineState(MachineState_Stuck);
    904902                    }
    905903                    break;
    … …  
    930928 * @param   aProgress       Where to return the progress object.
    931929 */
    932 STDMETHODIMP
    933 Console::Teleport(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress)
     930HRESULT Console::teleport(const com::Utf8Str &aHostname, ULONG aTcpport, const com::Utf8Str &aPassword,
     931                          ULONG aMaxDowntime, ComPtr<IProgress> &aProgress)
    934932{
    935933    /*
    … …  
    937935     * and validate the state.
    938936     */
    939     CheckComArgOutPointerValid(aProgress);
    940     CheckComArgStrNotEmptyOrNull(aHostname);
    941     CheckComArgNotNull(aPassword);
    942     CheckComArgExprMsg(aPort, aPort > 0 && aPort <= 65535, ("is %u", aPort));
    943     CheckComArgExprMsg(aMaxDowntime, aMaxDowntime > 0, ("is %u", aMaxDowntime));
    944 
    945937    Utf8Str strPassword(aPassword);
    946938    if (!strPassword.isEmpty())
    … …  
    988980    pState->mstrPassword    = strPassword;
    989981    pState->mstrHostname    = aHostname;
    990     pState->muPort          = aPort;
     982    pState->muPort          = aTcpport;
    991983    pState->mcMsMaxDowntime = aMaxDowntime;
    992984
    … …  
    994986    ptrProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser);
    995987
    996     int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
     988    int vrc = RTThreadCreate(NULL, Console::i_teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
    997989                             RTTHREADTYPE_EMULATION, 0 /*fFlags*/, "Teleport");
    998990    if (RT_SUCCESS(vrc))
    999991    {
    1000992        if (mMachineState == MachineState_Running)
    1001             hrc = setMachineState(MachineState_Teleporting);
     993            hrc = i_setMachineState(MachineState_Teleporting);
    1002994        else
    1003             hrc = setMachineState(MachineState_TeleportingPausedVM);
     995            hrc = i_setMachineState(MachineState_TeleportingPausedVM);
    1004996        if (SUCCEEDED(hrc))
    1005997        {
    1006             ptrProgress.queryInterfaceTo(aProgress);
     998            ptrProgress.queryInterfaceTo(aProgress.asOutParam());
    1007999            mptrCancelableProgress = ptrProgress;
    10081000        }
    … …  
    10381030 * @todo    Check that all the possible failure paths sets error info...
    10391031 */
    1040 HRESULT
    1041 Console::teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused,
    1042                        Progress *pProgress, bool *pfPowerOffOnFailure)
     1032HRESULT Console::i_teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused,
     1033                                 Progress *pProgress, bool *pfPowerOffOnFailure)
    10431034{
    10441035    LogThisFunc(("pUVM=%p pMachine=%p fStartPaused=%RTbool pProgress=%p\n", pUVM, pMachine, fStartPaused, pProgress));
    … …  
    11221113                if (SUCCEEDED(hrc))
    11231114                {
    1124                     vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
     1115                    vrc = RTTcpServerListen(hServer, Console::i_teleporterTrgServeConnection, &theState);
    11251116                    pProgress->i_setCancelCallback(NULL, NULL);
    11261117
    … …  
    12571248 */
    12581249/*static*/ DECLCALLBACK(int)
    1259 Console::teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser)
     1250Console::i_teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser)
    12601251{
    12611252    TeleporterStateTrg *pState = (TeleporterStateTrg *)pvUser;
    … …  
    13451336
    13461337            int vrc2 = VMR3AtErrorRegister(pState->mpUVM,
    1347                                            Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
     1338                                           Console::i_genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
    13481339            RTSocketRetain(pState->mhSocket); /* For concurrent access by I/O thread and EMT. */
    13491340            pState->moffStream = 0;
    … …  
    13551346
    13561347            RTSocketRelease(pState->mhSocket);
    1357             vrc2 = VMR3AtErrorDeregister(pState->mpUVM, Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
     1348            vrc2 = VMR3AtErrorDeregister(pState->mpUVM, Console::i_genericVMSetErrorCallback, &pState->mErrorText);
     1349            AssertRC(vrc2);
    13581350
    13591351            if (RT_FAILURE(vrc))
    … …  
    14201412                        vrc = VMR3Resume(pState->mpUVM, VMRESUMEREASON_TELEPORTED);
    14211413                    else
    1422                         pState->mptrConsole->setMachineState(MachineState_Paused);
     1414                        pState->mptrConsole->i_setMachineState(MachineState_Paused);
    14231415                    fDone = true;
    14241416                    break;

  • trunk/src/VBox/Main/src-client/ConsoleVRDPServer.cpp

    r51436 r51612  
    589589        {
    590590            com::Bstr bstr;
    591             server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("TCP/Address").raw(), bstr.asOutParam());
     591            server->mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr("TCP/Address").raw(), bstr.asOutParam());
    592592
    593593            /* The server expects UTF8. */
    … …  
    620620            ULONG cMonitors = 1;
    621621
    622             server->mConsole->machine()->COMGETTER(MonitorCount)(&cMonitors);
     622            server->mConsole->i_machine()->COMGETTER(MonitorCount)(&cMonitors);
    623623
    624624            if (cbBuffer >= sizeof(uint32_t))
    … …  
    638638        {
    639639            com::Bstr bstr;
    640             HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.asOutParam());
     640            HRESULT hrc = server->mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.asOutParam());
    641641
    642642            if (hrc != S_OK)
    … …  
    678678        {
    679679            com::Bstr bstr;
    680             HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
     680            HRESULT hrc = server->mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
    681681                                                                             bstr.asOutParam());
    682682
    … …  
    707707        {
    708708            com::Bstr bstr;
    709             HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
     709            HRESULT hrc = server->mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
    710710                                                                             bstr.asOutParam());
    711711
    … …  
    737737
    738738            com::Bstr bstr;
    739             HRESULT hrc = server->mConsole->machine()->GetExtraData(Bstr("VRDP/SunFlsh").raw(),
     739            HRESULT hrc = server->mConsole->i_machine()->GetExtraData(Bstr("VRDP/SunFlsh").raw(),
    740740                                                                    bstr.asOutParam());
    741741            if (hrc == S_OK && !bstr.isEmpty())
    … …  
    800800                extraData += pFeature->achInfo;
    801801
    802                 HRESULT hrc = server->mConsole->machine()->GetExtraData(com::Bstr(extraData).raw(),
     802                HRESULT hrc = server->mConsole->i_machine()->GetExtraData(com::Bstr(extraData).raw(),
    803803                                                                        bstrValue.asOutParam());
    804804                if (FAILED(hrc) || bstrValue.isEmpty())
    … …  
    808808                    extraData += pFeature->achInfo;
    809809
    810                     hrc = server->mConsole->machine()->GetExtraData(com::Bstr(extraData).raw(),
     810                    hrc = server->mConsole->i_machine()->GetExtraData(com::Bstr(extraData).raw(),
    811811                                                                    bstrValue.asOutParam());
    812812                    if (FAILED(hrc))
    … …  
    820820                /* Generic properties. */
    821821                const char *pszPropertyName = &pFeature->achInfo[9];
    822                 HRESULT hrc = server->mConsole->getVRDEServer()->GetVRDEProperty(Bstr(pszPropertyName).raw(),
     822                HRESULT hrc = server->mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr(pszPropertyName).raw(),
    823823                                                                                 bstrValue.asOutParam());
    824824                if (FAILED(hrc))
    … …  
    871871            }
    872872
    873             server->mConsole->onVRDEServerInfoChange();
     873            server->mConsole->i_onVRDEServerInfoChange();
    874874        } break;
    875875
    … …  
    903903            Log(("VRDE_SP_CLIENT_STATUS [%s]\n", pStatus->achStatus));
    904904
    905             server->mConsole->VRDPClientStatusChange(pStatus->u32ClientId, pStatus->achStatus);
     905            server->mConsole->i_VRDPClientStatusChange(pStatus->u32ClientId, pStatus->achStatus);
    906906
    907907            rc = VINF_SUCCESS;
    … …  
    912912            }
    913913
    914             server->mConsole->onVRDEServerInfoChange();
     914            server->mConsole->i_onVRDEServerInfoChange();
    915915        } break;
    916916
    … …  
    927927    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    928928
    929     return server->mConsole->VRDPClientLogon(u32ClientId, pszUser, pszPassword, pszDomain);
     929    return server->mConsole->i_VRDPClientLogon(u32ClientId, pszUser, pszPassword, pszDomain);
    930930}
    931931
    … …  
    934934    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    935935
    936     server->mConsole->VRDPClientConnect(u32ClientId);
     936    server->mConsole->i_VRDPClientConnect(u32ClientId);
    937937
    938938    /* Should the server report usage of an interface for each client?
    … …  
    952952    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    953953
    954     server->mConsole->VRDPClientDisconnect(u32ClientId, fu32Intercepted);
     954    server->mConsole->i_VRDPClientDisconnect(u32ClientId, fu32Intercepted);
    955955
    956956    if (ASMAtomicReadU32(&server->mu32AudioInputClientId) == u32ClientId)
    … …  
    962962        server->mConsole->getAudioVRDE()->handleVRDESvrCmdAudioInputIntercept(false);
    963963#else
    964         PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->getAudioSniffer()->getAudioSnifferPort();
     964        PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->i_getAudioSniffer()->getAudioSnifferPort();
    965965        if (pPort)
    966966        {
    … …  
    995995        case VRDE_CLIENT_INTERCEPT_AUDIO:
    996996        {
    997             server->mConsole->VRDPInterceptAudio(u32ClientId);
     997            server->mConsole->i_VRDPInterceptAudio(u32ClientId);
    998998            if (ppvIntercept)
    999999            {
    … …  
    10051005        case VRDE_CLIENT_INTERCEPT_USB:
    10061006        {
    1007             server->mConsole->VRDPInterceptUSB(u32ClientId, ppvIntercept);
     1007            server->mConsole->i_VRDPInterceptUSB(u32ClientId, ppvIntercept);
    10081008            rc = VINF_SUCCESS;
    10091009        } break;
    … …  
    10111011        case VRDE_CLIENT_INTERCEPT_CLIPBOARD:
    10121012        {
    1013             server->mConsole->VRDPInterceptClipboard(u32ClientId);
     1013            server->mConsole->i_VRDPInterceptClipboard(u32ClientId);
    10141014            if (ppvIntercept)
    10151015            {
    … …  
    10301030                server->mConsole->getAudioVRDE()->handleVRDESvrCmdAudioInputIntercept(true);
    10311031#else
    1032                 PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->getAudioSniffer()->getAudioSnifferPort();
     1032                PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->i_getAudioSniffer()->getAudioSnifferPort();
    10331033                if (pPort)
    10341034                {
    … …  
    10861086
    10871087    /* Obtain the new screen bitmap. */
    1088     HRESULT hr = server->mConsole->getDisplay()->QuerySourceBitmap(uScreenId, server->maSourceBitmaps[uScreenId].asOutParam());
     1088    HRESULT hr = server->mConsole->i_getDisplay()->QuerySourceBitmap(uScreenId, server->maSourceBitmaps[uScreenId].asOutParam());
    10891089    if (SUCCEEDED(hr))
    10901090    {
    … …  
    11071107        if (SUCCEEDED(hr))
    11081108        {
    1109             hr = server->mConsole->getDisplay()->GetScreenResolution(uScreenId, NULL, NULL, NULL,
     1109            hr = server->mConsole->i_getDisplay()->GetScreenResolution(uScreenId, NULL, NULL, NULL,
    11101110                                                                     &xOrigin, &yOrigin);
    11111111
    … …  
    11721172            if (cbInput == sizeof(VRDEINPUTSCANCODE))
    11731173            {
    1174                 IKeyboard *pKeyboard = pConsole->getKeyboard();
     1174                IKeyboard *pKeyboard = pConsole->i_getKeyboard();
    11751175
    11761176                const VRDEINPUTSCANCODE *pInputScancode = (VRDEINPUTSCANCODE *)pvInput;
    … …  
    12331233                if (server->m_fGuestWantsAbsolute)
    12341234                {
    1235                     pConsole->getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel,
    1236                                                                 0 /* Horizontal wheel */, mouseButtons);
     1235                    pConsole->i_getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel,
     1236                                                                  0 /* Horizontal wheel */, mouseButtons);
    12371237                } else
    12381238                {
    1239                     pConsole->getMouse()->PutMouseEvent(pInputPoint->x - server->m_mousex,
    1240                                                          pInputPoint->y - server->m_mousey,
    1241                                                          iWheel, 0 /* Horizontal wheel */, mouseButtons);
     1239                    pConsole->i_getMouse()->PutMouseEvent(pInputPoint->x - server->m_mousex,
     1240                                                          pInputPoint->y - server->m_mousey,
     1241                                                          iWheel, 0 /* Horizontal wheel */, mouseButtons);
    12421242                    server->m_mousex = pInputPoint->x;
    12431243                    server->m_mousey = pInputPoint->y;
    … …  
    12481248        case VRDE_INPUT_CAD:
    12491249        {
    1250             pConsole->getKeyboard()->PutCAD();
     1250            pConsole->i_getKeyboard()->PutCAD();
    12511251        } break;
    12521252
    … …  
    12601260            if (cbInput == sizeof(VRDEINPUTSYNCH))
    12611261            {
    1262                 IKeyboard *pKeyboard = pConsole->getKeyboard();
     1262                IKeyboard *pKeyboard = pConsole->i_getKeyboard();
    12631263
    12641264                const VRDEINPUTSYNCH *pInputSynch = (VRDEINPUTSYNCH *)pvInput;
    … …  
    12961296    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    12971297
    1298     server->mConsole->getDisplay()->SetVideoModeHint(uScreenId, TRUE /*=enabled*/,
    1299                                                      FALSE /*=changeOrigin*/, 0/*=OriginX*/, 0/*=OriginY*/,
    1300                                                      cWidth, cHeight, cBitsPerPixel);
     1298    server->mConsole->i_getDisplay()->SetVideoModeHint(uScreenId, TRUE /*=enabled*/,
     1299                                                       FALSE /*=changeOrigin*/, 0/*=OriginX*/, 0/*=OriginY*/,
     1300                                                       cWidth, cHeight, cBitsPerPixel);
    13011301}
    13021302
    … …  
    13101310    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    13111311#ifndef VBOX_WITH_PDM_AUDIO_DRIVER
    1312     PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->getAudioSniffer()->getAudioSnifferPort();
     1312    PPDMIAUDIOSNIFFERPORT pPort = server->mConsole->i_getAudioSniffer()->getAudioSnifferPort();
    13131313#endif
    13141314
    … …  
    14821482    LogFlowThisFunc(("\n"));
    14831483
    1484     IVRDEServer *server = mConsole->getVRDEServer();
     1484    IVRDEServer *server = mConsole->i_getVRDEServer();
    14851485    AssertReturn(server, VERR_INTERNAL_ERROR_2);
    14861486
    … …  
    15131513    {
    15141514#ifdef VBOX_WITH_EXTPACK
    1515         ExtPackManager *pExtPackMgr = mConsole->getExtPackManager();
     1515        ExtPackManager *pExtPackMgr = mConsole->i_getExtPackManager();
    15161516        vrc = pExtPackMgr->i_getVrdeLibraryPathForExtPack(&strExtPack, &strVrdeLibrary);
    15171517#else
    … …  
    20982098    /* Check if 3D redirection has been enabled. It is enabled by default. */
    20992099    com::Bstr bstr;
    2100     HRESULT hrc = mConsole->getVRDEServer()->GetVRDEProperty(Bstr("H3DRedirect/Enabled").raw(), bstr.asOutParam());
     2100    HRESULT hrc = mConsole->i_getVRDEServer()->GetVRDEProperty(Bstr("H3DRedirect/Enabled").raw(), bstr.asOutParam());
    21012101
    21022102    com::Utf8Str value = hrc == S_OK? bstr: "";
    … …  
    21382138    data.aParms[0].u.pointer.size = sizeof(outputRedirect);
    21392139
    2140     int rc = mConsole->getDisplay()->crCtlSubmitSync(&data.Hdr, sizeof (data));
     2140    int rc = mConsole->i_getDisplay()->crCtlSubmitSync(&data.Hdr, sizeof (data));
    21412141    if (!RT_SUCCESS(rc))
    21422142    {
    … …  
    22042204#ifdef VBOX_WITH_USB_CARDREADER
    22052205    ConsoleVRDPServer *pThis = static_cast<ConsoleVRDPServer*>(pvContext);
    2206     UsbCardReader *pReader = pThis->mConsole->getUsbCardReader();
     2206    UsbCardReader *pReader = pThis->mConsole->i_getUsbCardReader();
    22072207    return pReader->VRDENotify(u32Id, pvData, cbData);
    22082208#else
    … …  
    22242224#ifdef VBOX_WITH_USB_CARDREADER
    22252225    ConsoleVRDPServer *pThis = static_cast<ConsoleVRDPServer*>(pvContext);
    2226     UsbCardReader *pReader = pThis->mConsole->getUsbCardReader();
     2226    UsbCardReader *pReader = pThis->mConsole->i_getUsbCardReader();
    22272227    return pReader->VRDEResponse(rcRequest, pvUser, u32Function, pvData, cbData);
    22282228#else
    … …  
    25242524    parms.iface.u.pointer.size = sizeof(hostChannelInterface);
    25252525
    2526     VMMDev *pVMMDev = mConsole->getVMMDev();
     2526    VMMDev *pVMMDev = mConsole->i_getVMMDev();
    25272527
    25282528    if (!pVMMDev)
    … …  
    28342834            if (pHeader->u16EventId == VRDEINPUT_EVENTID_TOUCH)
    28352835            {
    2836                 IMouse *pMouse = pThis->mConsole->getMouse();
     2836                IMouse *pMouse = pThis->mConsole->i_getMouse();
    28372837
    28382838                VRDEINPUT_TOUCH_EVENT_PDU *p = (VRDEINPUT_TOUCH_EVENT_PDU *)pHeader;
    … …  
    32453245        /* Load the external authentication library. */
    32463246        Bstr authLibrary;
    3247         mConsole->getVRDEServer()->COMGETTER(AuthLibrary)(authLibrary.asOutParam());
     3247        mConsole->i_getVRDEServer()->COMGETTER(AuthLibrary)(authLibrary.asOutParam());
    32483248
    32493249        Utf8Str filename = authLibrary;
    … …  
    40954095        uint32_t cbOut = 0;                                               \
    40964096                                                                          \
    4097         mParent->consoleVRDPServer()->QueryInfo                           \
     4097        mParent->i_consoleVRDPServer()->QueryInfo                           \
    40984098            (_aIndex, &value, sizeof(value), &cbOut);                     \
    40994099                                                                          \
    … …  
    41194119        uint32_t cbOut = 0;                                               \
    41204120                                                                          \
    4121         mParent->consoleVRDPServer()->QueryInfo                           \
     4121        mParent->i_consoleVRDPServer()->QueryInfo                           \
    41224122            (_aIndex, &value, sizeof(value), &cbOut);                     \
    41234123                                                                          \
    … …  
    41434143        uint32_t cbOut = 0;                                               \
    41444144                                                                          \
    4145         mParent->consoleVRDPServer()->QueryInfo                           \
     4145        mParent->i_consoleVRDPServer()->QueryInfo                           \
    41464146            (_aIndex, NULL, 0, &cbOut);                                   \
    41474147                                                                          \
    … …  
    41634163        }                                                                 \
    41644164                                                                          \
    4165         mParent->consoleVRDPServer()->QueryInfo                           \
     4165        mParent->i_consoleVRDPServer()->QueryInfo                           \
    41664166            (_aIndex, pchBuffer, cbOut, &cbOut);                          \
    41674167                                                                          \

  • trunk/src/VBox/Main/src-client/DisplayImpl.cpp

    r51610 r51612  
    316316        BOOL f3DSnapshot = FALSE;
    317317        BOOL is3denabled;
    318         that->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     318        that->mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    319319        if (is3denabled && that->mCrOglCallbacks.pfnHasData())
    320320        {
    321             VMMDev *pVMMDev = that->mParent->getVMMDev();
     321            VMMDev *pVMMDev = that->mParent->i_getVMMDev();
    322322            if (pVMMDev)
    323323            {
    … …  
    587587
    588588    ULONG ul;
    589     mParent->machine()->COMGETTER(MonitorCount)(&ul);
     589    mParent->i_machine()->COMGETTER(MonitorCount)(&ul);
    590590    mcMonitors = ul;
    591591
    … …  
    740740#ifdef DEBUG
    741741        BOOL is3denabled;
    742         mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     742        mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    743743        Assert(!is3denabled);
    744744#endif
    … …  
    746746    }
    747747
    748     VMMDev *pVMMDev = mParent->getVMMDev();
     748    VMMDev *pVMMDev = mParent->i_getVMMDev();
    749749    if (!pVMMDev)
    750750    {
    … …  
    835835
    836836    BOOL is3denabled;
    837     mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     837    mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    838838
    839839    if (is3denabled)
    … …  
    842842        if (mhCrOglSvc)
    843843        {
    844             VMMDev *pVMMDev = mParent->getVMMDev();
     844            VMMDev *pVMMDev = mParent->i_getVMMDev();
    845845            if (pVMMDev)
    846846            {
    … …  
    958958         */
    959959        LogRelFlowFunc(("Calling VRDP\n"));
    960         mParent->consoleVRDPServer()->SendResize();
     960        mParent->i_consoleVRDPServer()->SendResize();
    961961
    962962        /* @todo Merge these two 'if's within one 'if (!pFBInfo->pFramebuffer.isNull())' */
    … …  
    995995        {
    996996            BOOL is3denabled;
    997             mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     997            mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    998998
    999999            if (is3denabled)
    … …  
    11371137         * Inform the server here only if VBVA is disabled.
    11381138         */
    1139         mParent->consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
     1139        mParent->i_consoleVRDPServer()->SendUpdateBitmap(uScreenId, x, y, w, h);
    11401140    }
    11411141}
    … …  
    12841284    BOOL is3denabled = FALSE;
    12851285
    1286     mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    1287 
    1288     VMMDev *vmmDev = mParent->getVMMDev();
     1286    mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     1287
     1288    VMMDev *vmmDev = mParent->i_getVMMDev();
    12891289    if (is3denabled && vmmDev)
    12901290    {
    … …  
    16151615     * and needs to know current status.
    16161616     */
    1617     VMMDev *pVMMDev = mParent->getVMMDev();
     1617    VMMDev *pVMMDev = mParent->i_getVMMDev();
    16181618    if (pVMMDev)
    16191619    {
    … …  
    20892089
    20902090            /* Forward the command to VRDP server. */
    2091             mParent->consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
     2091            mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
    20922092
    20932093            *phdr = hdrSaved;
    … …  
    22842284#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    22852285        BOOL fIs3DEnabled = FALSE;
    2286         mParent->machine()->COMGETTER(Accelerate3DEnabled)(&fIs3DEnabled);
     2286        mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&fIs3DEnabled);
    22872287
    22882288        if (fIs3DEnabled)
    … …  
    23852385    }
    23862386    ULONG cMonitors;
    2387     mParent->machine()->COMGETTER(MonitorCount)(&cMonitors);
     2387    mParent->i_machine()->COMGETTER(MonitorCount)(&cMonitors);
    23882388    if (cMonitors == 0 && aDisplay > 0)
    23892389        return E_INVALIDARG;
    … …  
    24002400    alock.release();
    24012401
    2402     VMMDev *pVMMDev = mParent->getVMMDev();
     2402    VMMDev *pVMMDev = mParent->i_getVMMDev();
    24032403    if (pVMMDev)
    24042404    {
    … …  
    24222422    alock.release();
    24232423
    2424     VMMDev *pVMMDev = mParent->getVMMDev();
     2424    VMMDev *pVMMDev = mParent->i_getVMMDev();
    24252425    if (pVMMDev)
    24262426    {
    … …  
    24352435        BOOL is3denabled = FALSE;
    24362436
    2437         mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    2438 
    2439         VMMDev *vmmDev = mParent->getVMMDev();
     2437        mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     2438
     2439        VMMDev *vmmDev = mParent->i_getVMMDev();
    24402440        if (is3denabled && vmmDev)
    24412441        {
    … …  
    24712471{
    24722472    BOOL is3denabled;
    2473     pDisplay->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     2473    pDisplay->mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    24742474    if (is3denabled && pDisplay->mCrOglCallbacks.pfnHasData())
    24752475    {
    2476         VMMDev *pVMMDev = pDisplay->mParent->getVMMDev();
     2476        VMMDev *pVMMDev = pDisplay->mParent->i_getVMMDev();
    24772477        if (pVMMDev)
    24782478        {
    … …  
    29332933        return rc;
    29342934    }
    2935     ComPtr<IMachine> pMachine = mParent->machine();
     2935    ComPtr<IMachine> pMachine = mParent->i_machine();
    29362936    com::SafeArray<BOOL> screens;
    29372937    HRESULT hrc = pMachine->COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens));
    … …  
    31363136
    31373137    if (RT_SUCCESS(rc))
    3138         pDisplay->mParent->consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
     3138        pDisplay->mParent->i_consoleVRDPServer()->SendUpdateBitmap(aScreenId, x, y, width, height);
    31393139
    31403140    pDisplay->vbvaUnlock();
    … …  
    33523352
    33533353    BOOL is3denabled;
    3354     mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     3354    mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    33553355
    33563356    if (is3denabled)
    … …  
    34813481int Display::crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
    34823482{
    3483     VMMDev *pVMMDev = mParent->getVMMDev();
     3483    VMMDev *pVMMDev = mParent->i_getVMMDev();
    34843484    if (!pVMMDev)
    34853485        return VERR_INVALID_STATE;
    … …  
    35133513void Display::setupCrHgsmiData(void)
    35143514{
    3515     VMMDev *pVMMDev = mParent->getVMMDev();
     3515    VMMDev *pVMMDev = mParent->i_getVMMDev();
    35163516    Assert(pVMMDev);
    35173517    int rc = RTCritSectRwEnterExcl(&mCrOglLock);
    … …  
    36633663            DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
    36643664
    3665             Assert (pDisplay->mParent && pDisplay->mParent->consoleVRDPServer());
    3666             pDisplay->mParent->consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
     3665            Assert (pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
     3666            pDisplay->mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
    36673667        }
    36683668    }
    … …  
    36743674# if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
    36753675            BOOL is3denabled;
    3676             pDisplay->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     3676            pDisplay->mParent->i_machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
    36773677            if (is3denabled)
    36783678            {
    … …  
    39663966                {
    39673967                    pFBInfo->fDisabled = false;
    3968                     fireGuestMonitorChangedEvent(pDrv->pDisplay->mParent->getEventSource(),
     3968                    fireGuestMonitorChangedEvent(pDrv->pDisplay->mParent->i_getEventSource(),
    39693969                                                 GuestMonitorChangedEventType_Enabled,
    39703970                                                 uScreenId,
    … …  
    40894089    if (mhCrOglSvc)
    40904090    {
    4091         VMMDev *pVMMDev = mParent->getVMMDev();
     4091        VMMDev *pVMMDev = mParent->i_getVMMDev();
    40924092        if (pVMMDev)
    40934093        {
    … …  
    41174117    if (mhCrOglSvc)
    41184118    {
    4119         VMMDev *pVMMDev = mParent->getVMMDev();
     4119        VMMDev *pVMMDev = mParent->i_getVMMDev();
    41204120        if (pVMMDev)
    41214121        {
    … …  
    42034203                                    void *pvCompletion)
    42044204{
    4205     VMMDev *pVMMDev = mParent ? mParent->getVMMDev() : NULL;
     4205    VMMDev *pVMMDev = mParent ? mParent->i_getVMMDev() : NULL;
    42064206    if (!pVMMDev)
    42074207    {
    … …  
    44184418        {
    44194419            pFBInfo->fDisabled = false;
    4420             fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
     4420            fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
    44214421                                         GuestMonitorChangedEventType_Enabled,
    44224422                                         uScreenId,
    … …  
    45344534
    45354535    /* @todo new SendUpdate entry which can get a separate cmd header or coords. */
    4536     pThis->mParent->consoleVRDPServer()->SendUpdate (uScreenId, pCmd, (uint32_t)cbCmd);
     4536    pThis->mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, pCmd, (uint32_t)cbCmd);
    45374537
    45384538    *pHdrUnconst = hdrSaved;
    … …  
    46524652                                   u32Width, u32Height, pScreen->u16Flags);
    46534653
    4654         fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
     4654        fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
    46554655                                     GuestMonitorChangedEventType_Disabled,
    46564656                                     pScreen->u32ViewIndex,
    … …  
    46904690    {
    46914691        pFBInfo->fDisabled = false;
    4692         fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
     4692        fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
    46934693                                     GuestMonitorChangedEventType_Enabled,
    46944694                                     pScreen->u32ViewIndex,
    … …  
    47164716    if (fNewOrigin)
    47174717    {
    4718         fireGuestMonitorChangedEvent(pThis->mParent->getEventSource(),
     4718        fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
    47194719                                     GuestMonitorChangedEventType_NewOrigin,
    47204720                                     pScreen->u32ViewIndex,
    … …  
    47304730            /* VRDP server still need this notification. */
    47314731            LogRelFlowFunc(("Calling VRDP\n"));
    4732             pThis->mParent->consoleVRDPServer()->SendResize();
     4732            pThis->mParent->i_consoleVRDPServer()->SendResize();
    47334733        }
    47344734        return VINF_SUCCESS;
    … …  
    47644764
    47654765    /* Tell the console about it */
    4766     pDrv->pDisplay->mParent->onMousePointerShapeChange(fVisible, fAlpha,
    4767                                                        xHot, yHot, cx, cy, ComSafeArrayAsInParam(shapeData));
     4766    pDrv->pDisplay->mParent->i_onMousePointerShapeChange(fVisible, fAlpha,
     4767                                                         xHot, yHot, cx, cy, ComSafeArrayAsInParam(shapeData));
    47684768
    47694769    return VINF_SUCCESS;
    … …  
    49164916
    49174917#ifdef VBOX_WITH_VPX
    4918     ComPtr<IMachine> pMachine = pDisplay->mParent->machine();
     4918    ComPtr<IMachine> pMachine = pDisplay->mParent->i_machine();
    49194919    BOOL fEnabled = false;
    49204920    HRESULT hrc = pMachine->COMGETTER(VideoCaptureEnabled)(&fEnabled);
    … …  
    49234923    {
    49244924        rc = pDisplay->VideoCaptureStart();
    4925         fireVideoCaptureChangedEvent(pDisplay->mParent->getEventSource());
     4925        fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
    49264926    }
    49274927#endif

  • trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

    r50727 r51612  
    66
    77/*
    8  * Copyright (C) 2011-2013 Oracle Corporation
     8 * Copyright (C) 2011-2014 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    12391239
    12401240    /* Forward the information to the VMM device. */
    1241     VMMDev *pVMMDev = pConsole->getVMMDev();
     1241    VMMDev *pVMMDev = pConsole->i_getVMMDev();
    12421242    if (pVMMDev)
    12431243    {

  • trunk/src/VBox/Main/src-client/GuestDnDPrivate.cpp

    r51556 r51612  
    501501    /* Forward the information to the VMM device. */
    502502    Assert(!pConsole.isNull());
    503     VMMDev *pVMMDev = pConsole->getVMMDev();
     503    VMMDev *pVMMDev = pConsole->i_getVMMDev();
    504504    if (!pVMMDev)
    505505        return VERR_COM_OBJECT_NOT_FOUND;

  • trunk/src/VBox/Main/src-client/GuestImpl.cpp

    r51476 r51612  
    8181
    8282    ULONG aMemoryBalloonSize;
    83     HRESULT hr = mParent->machine()->COMGETTER(MemoryBalloonSize)(&aMemoryBalloonSize);
     83    HRESULT hr = mParent->i_machine()->COMGETTER(MemoryBalloonSize)(&aMemoryBalloonSize);
    8484    if (hr == S_OK) /** @todo r=andy SUCCEEDED? */
    8585        mMemoryBalloonSize = aMemoryBalloonSize;
    … …  
    8888
    8989    BOOL fPageFusionEnabled;
    90     hr = mParent->machine()->COMGETTER(PageFusionEnabled)(&fPageFusionEnabled);
     90    hr = mParent->i_machine()->COMGETTER(PageFusionEnabled)(&fPageFusionEnabled);
    9191    if (hr == S_OK) /** @todo r=andy SUCCEEDED? */
    9292        mfPageFusionEnabled = fPageFusionEnabled;
    … …  
    337337    }
    338338
    339     mParent->reportVmStatistics(validStats,
    340                                 aGuestStats[GUESTSTATTYPE_CPUUSER],
    341                                 aGuestStats[GUESTSTATTYPE_CPUKERNEL],
    342                                 aGuestStats[GUESTSTATTYPE_CPUIDLE],
    343                                 /* Convert the units for RAM usage stats: page (4K) -> 1KB units */
    344                                 mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K),
    345                                 mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K),
    346                                 mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K),
    347                                 (ULONG)(cbSharedMem / _1K), /* bytes -> KB */
    348                                 mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K),
    349                                 mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K),
    350                                 (ULONG)(cbAllocTotal / _1K), /* bytes -> KB */
    351                                 (ULONG)(cbFreeTotal / _1K),
    352                                 (ULONG)(cbBalloonedTotal / _1K),
    353                                 (ULONG)(cbSharedTotal / _1K),
    354                                 uNetStatRx,
    355                                 uNetStatTx);
     339    mParent->i_reportVmStatistics(validStats,
     340                                  aGuestStats[GUESTSTATTYPE_CPUUSER],
     341                                  aGuestStats[GUESTSTATTYPE_CPUKERNEL],
     342                                  aGuestStats[GUESTSTATTYPE_CPUIDLE],
     343                                  /* Convert the units for RAM usage stats: page (4K) -> 1KB units */
     344                                  mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K),
     345                                  mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K),
     346                                  mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K),
     347                                  (ULONG)(cbSharedMem / _1K), /* bytes -> KB */
     348                                  mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K),
     349                                  mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K),
     350                                  (ULONG)(cbAllocTotal / _1K), /* bytes -> KB */
     351                                  (ULONG)(cbFreeTotal / _1K),
     352                                  (ULONG)(cbBalloonedTotal / _1K),
     353                                  (ULONG)(cbSharedTotal / _1K),
     354                                  uNetStatRx,
     355                                  uNetStatTx);
    356356}
    357357
    … …  
    373373        {
    374374            /* Redirect the call to IMachine if no additions are installed. */
    375             ComPtr<IMachine> ptrMachine(mParent->machine());
     375            ComPtr<IMachine> ptrMachine(mParent->i_machine());
    376376            alock.release();
    377377            hrc = ptrMachine->COMGETTER(OSTypeId)(a_pbstrOSTypeId);
    … …  
    416416             * Revision in early 3.1.x releases (see r57115).
    417417             */
    418             ComPtr<IMachine> ptrMachine = mParent->machine();
     418            ComPtr<IMachine> ptrMachine = mParent->i_machine();
    419419            alock.release(); /* No need to hold this during the IPC fun. */
    420420
    … …  
    469469             * Revision in early 3.1.x releases (see r57115).
    470470             */
    471             ComPtr<IMachine> ptrMachine = mParent->machine();
     471            ComPtr<IMachine> ptrMachine = mParent->i_machine();
    472472            alock.release(); /* No need to hold this during the IPC fun. */
    473473
    … …  
    627627    /* We must be 100% sure that IMachine::COMSETTER(MemoryBalloonSize)
    628628     * does not call us back in any way! */
    629     HRESULT ret = mParent->machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
     629    HRESULT ret = mParent->i_machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
    630630    if (ret == S_OK)
    631631    {
    632632        mMemoryBalloonSize = aMemoryBalloonSize;
    633633        /* forward the information to the VMM device */
    634         VMMDev *pVMMDev = mParent->getVMMDev();
     634        VMMDev *pVMMDev = mParent->i_getVMMDev();
    635635        /* MUST release all locks before calling VMM device as its critsect
    636636         * has higher lock order than anything in Main. */
    … …  
    680680    mStatUpdateInterval = aUpdateInterval;
    681681    /* forward the information to the VMM device */
    682     VMMDev *pVMMDev = mParent->getVMMDev();
     682    VMMDev *pVMMDev = mParent->i_getVMMDev();
    683683    /* MUST release all locks before calling VMM device as its critsect
    684684     * has higher lock order than anything in Main. */
    … …  
    866866    /* Check for magic domain names which are used to pass encryption keys to the disk. */
    867867    if (Utf8Str(aDomain) == "@@disk")
    868         return mParent->setDiskEncryptionKeys(Utf8Str(aPassword));
     868        return mParent->i_setDiskEncryptionKeys(Utf8Str(aPassword));
    869869    else if (Utf8Str(aDomain) == "@@mem")
    870870    {
    … …  
    875875    {
    876876        /* forward the information to the VMM device */
    877         VMMDev *pVMMDev = mParent->getVMMDev();
     877        VMMDev *pVMMDev = mParent->i_getVMMDev();
    878878        if (pVMMDev)
    879879        {

  • trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

    r50899 r51612  
    55
    66/*
    7  * Copyright (C) 2012-2013 Oracle Corporation
     7 * Copyright (C) 2012-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    20072007
    20082008    /* Forward the information to the VMM device. */
    2009     VMMDev *pVMMDev = pConsole->getVMMDev();
     2009    VMMDev *pVMMDev = pConsole->i_getVMMDev();
    20102010    AssertPtr(pVMMDev);
    20112011

  • trunk/src/VBox/Main/src-client/GuestSessionImplTasks.cpp

    r51441 r51612  
    55
    66/*
    7  * Copyright (C) 2012-2013 Oracle Corporation
     7 * Copyright (C) 2012-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    7777{
    7878    ComObjPtr<Console> pConsole = pGuest->getConsole();
    79     const ComPtr<IMachine> pMachine = pConsole->machine();
     79    const ComPtr<IMachine> pMachine = pConsole->i_machine();
    8080
    8181    Assert(!pMachine.isNull());
    … …  
    338338            default:
    339339                setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    340                                     Utf8StrFmt(GuestSession::tr("Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
     340                                    Utf8StrFmt(GuestSession::tr(
     341                                    "Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
    341342                                               mSource.c_str(), rc));
    342343                break;
    … …  
    506507                    if (RT_FAILURE(rc))
    507508                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    508                                             Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed: %Rrc"),
     509                                            Utf8StrFmt(
     510                                            GuestSession::tr("Waiting on termination for copying file \"%s\" failed: %Rrc"),
    509511                                                       mSource.c_str(), rc));
    510512                    else
    511513                    {
    512514                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    513                                             Utf8StrFmt(GuestSession::tr("Waiting on termination for copying file \"%s\" failed with wait result %ld"),
     515                                            Utf8StrFmt(GuestSession::tr(
     516                                            "Waiting on termination for copying file \"%s\" failed with wait result %ld"),
    514517                                                       mSource.c_str(), waitRes));
    515518                        rc = VERR_GENERAL_FAILURE; /* Fudge. */
    … …  
    528531                    {
    529532                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    530                                             Utf8StrFmt(GuestSession::tr("Copying file \"%s\" failed with status %ld, exit code %ld"),
     533                                            Utf8StrFmt(GuestSession::tr(
     534                                            "Copying file \"%s\" failed with status %ld, exit code %ld"),
    531535                                                       mSource.c_str(), procStatus, exitCode)); /**@todo Add stringify methods! */
    532536                        rc = VERR_GENERAL_FAILURE; /* Fudge. */
    … …  
    657661                    default:
    658662                        setProgressErrorMsg(VBOX_E_IPRT_ERROR,
    659                                             Utf8StrFmt(GuestSession::tr("Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
     663                                            Utf8StrFmt(GuestSession::tr(
     664                                           "Error while creating guest process for copying file \"%s\" from guest to host: %Rrc"),
    660665                                                       mSource.c_str(), rc));
    661666                        break;

  • trunk/src/VBox/Main/src-client/KeyboardImpl.cpp

    r51096 r51612  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    285285{
    286286    PDRVMAINKEYBOARD pDrv = RT_FROM_MEMBER(pInterface, DRVMAINKEYBOARD, IConnector);
    287     pDrv->pKeyboard->getParent()->onKeyboardLedsChange(RT_BOOL(enmLeds & PDMKEYBLEDS_NUMLOCK),
    288                                                        RT_BOOL(enmLeds & PDMKEYBLEDS_CAPSLOCK),
    289                                                        RT_BOOL(enmLeds & PDMKEYBLEDS_SCROLLLOCK));
     287    pDrv->pKeyboard->getParent()->i_onKeyboardLedsChange(RT_BOOL(enmLeds & PDMKEYBLEDS_NUMLOCK),
     288                                                         RT_BOOL(enmLeds & PDMKEYBLEDS_CAPSLOCK),
     289                                                         RT_BOOL(enmLeds & PDMKEYBLEDS_SCROLLLOCK));
    290290}
    291291

  • trunk/src/VBox/Main/src-client/MouseImpl.cpp

    r50613 r51612  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    159159                                       uint32_t fCapsRemoved)
    160160{
    161     VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
     161    VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
    162162    if (!pVMMDev)
    163163        return E_FAIL;  /* No assertion, as the front-ends can send events
    … …  
    382382HRESULT Mouse::i_reportAbsEventToVMMDev(int32_t x, int32_t y)
    383383{
    384     VMMDevMouseInterface *pVMMDev = mParent->getVMMDevMouseInterface();
     384    VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
    385385    ComAssertRet(pVMMDev, E_FAIL);
    386386    PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
    … …  
    542542    AssertPtrReturn(pyAdj, E_POINTER);
    543543    AssertPtrNullReturn(pfValid, E_POINTER);
    544     DisplayMouseInterface *pDisplay = mParent->getDisplayMouseInterface();
     544    DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
    545545    ComAssertRet(pDisplay, E_FAIL);
    546546    /** The amount to add to the result (multiplied by the screen width/height)
    … …  
    700700    }
    701701
    702     DisplayMouseInterface *pDisplay = mParent->getDisplayMouseInterface();
     702    DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
    703703    ComAssertRet(pDisplay, E_FAIL);
    704704
    … …  
    905905     * callback data atomically.  However I can't see any sign that the cached
    906906     * data is ever used again. */
    907     mParent->onMouseCapabilityChange(fCanAbs, fRelDev, fMTDev, fNeedsHostCursor);
     907    mParent->i_onMouseCapabilityChange(fCanAbs, fRelDev, fMTDev, fNeedsHostCursor);
    908908}
    909909

  • trunk/src/VBox/Main/src-client/Nvram.cpp

    r45927 r51612  
    55
    66/*
    7  * Copyright (C) 2012-2013 Oracle Corporation
     7 * Copyright (C) 2012-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    174174                try
    175175                {
    176                     HRESULT hrc = pThis->pNvram->getParent()->machine()->SetExtraData(Bstr(szExtraName).raw(),
     176                    HRESULT hrc = pThis->pNvram->getParent()->i_machine()->SetExtraData(Bstr(szExtraName).raw(),
    177177                                                                                      Bstr(apszTodo[i + 1]).raw());
    178178                    if (FAILED(hrc))
    … …  
    216216        try
    217217        {
    218             HRESULT hrc = pThis->pNvram->getParent()->machine()->SetExtraData(Bstr(szExtraName).raw(), Bstr().raw());
     218            HRESULT hrc = pThis->pNvram->getParent()->i_machine()->SetExtraData(Bstr(szExtraName).raw(), Bstr().raw());
    219219            if (FAILED(hrc))
    220220                LogRel(("drvNvram_deleteVar: SetExtraData(%s,) returned %Rhrc\n", szExtraName, hrc));

  • trunk/src/VBox/Main/src-client/PCIRawDevImpl.cpp

    r49644 r51612  
    55
    66/*
    7  * Copyright (C) 2010-2013 Oracle Corporation
     7 * Copyright (C) 2010-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    7676    PDRVMAINPCIRAWDEV pThis = RT_FROM_CPP_MEMBER(pInterface, DRVMAINPCIRAWDEV, IConnector);
    7777    Console *pConsole = pThis->pPCIRawDev->getParent();
    78     const ComPtr<IMachine>& machine = pConsole->machine();
     78    const ComPtr<IMachine>& machine = pConsole->i_machine();
    7979    ComPtr<IVirtualBox> vbox;
    8080

  • trunk/src/VBox/Main/src-client/RemoteUSBBackend.cpp

    r51092 r51612  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    820820    {
    821821        /* Unmount all remote USB devices. */
    822         mConsole->processRemoteUSBDevices(mu32ClientId, NULL, 0, false);
     822        mConsole->i_processRemoteUSBDevices(mu32ClientId, NULL, 0, false);
    823823
    824824        menmPollRemoteDevicesStatus = PollRemoteDevicesStatus_Dereferenced;
    … …  
    880880            if (mfHasDeviceList)
    881881            {
    882                 mConsole->processRemoteUSBDevices(mu32ClientId, (VRDEUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList, mfDescExt);
     882                mConsole->i_processRemoteUSBDevices(mu32ClientId, (VRDEUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList, mfDescExt);
    883883                LogFlow(("USB::PollRemoteDevices: WaitResponse after process\n"));
    884884

  • trunk/src/VBox/Main/src-client/SessionImpl.cpp

    r51476 r51612  
    167167#ifndef VBOX_COM_INPROC_API_CLIENT
    168168    if (mConsole)
    169        rc = mConsole->machine().queryInterfaceTo(aMachine);
     169       rc = mConsole->i_machine().queryInterfaceTo(aMachine);
    170170    else
    171171#endif
    … …  
    500500    AssertReturn(!mConsole.isNull(), E_FAIL);
    501501
    502     return mConsole->updateMachineState(aMachineState);
     502    return mConsole->i_updateMachineState(aMachineState);
    503503#else
    504504    return S_OK;
    … …  
    569569    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    570570
    571     return mConsole->onNetworkAdapterChange(networkAdapter, changeAdapter);
     571    return mConsole->i_onNetworkAdapterChange(networkAdapter, changeAdapter);
    572572#else
    573573    return S_OK;
    … …  
    588588    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    589589
    590     return mConsole->onSerialPortChange(serialPort);
     590    return mConsole->i_onSerialPortChange(serialPort);
    591591#else
    592592    return S_OK;
    … …  
    607607    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    608608
    609     return mConsole->onParallelPortChange(parallelPort);
     609    return mConsole->i_onParallelPortChange(parallelPort);
    610610#else
    611611    return S_OK;
    … …  
    626626    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    627627
    628     return mConsole->onStorageControllerChange();
     628    return mConsole->i_onStorageControllerChange();
    629629#else
    630630    return S_OK;
    … …  
    645645    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    646646
    647     return mConsole->onMediumChange(aMediumAttachment, aForce);
     647    return mConsole->i_onMediumChange(aMediumAttachment, aForce);
    648648#else
    649649    return S_OK;
    … …  
    664664    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    665665
    666     return mConsole->onCPUChange(aCPU, aRemove);
     666    return mConsole->i_onCPUChange(aCPU, aRemove);
    667667#else
    668668    return S_OK;
    … …  
    683683    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    684684
    685     return mConsole->onCPUExecutionCapChange(aExecutionCap);
     685    return mConsole->i_onCPUExecutionCapChange(aExecutionCap);
    686686#else
    687687    return S_OK;
    … …  
    702702    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    703703
    704     return mConsole->onVRDEServerChange(aRestart);
     704    return mConsole->i_onVRDEServerChange(aRestart);
    705705#else
    706706    return S_OK;
    … …  
    721721    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    722722
    723     return mConsole->onVideoCaptureChange();
     723    return mConsole->i_onVideoCaptureChange();
    724724#else
    725725    return S_OK;
    … …  
    740740    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    741741
    742     return mConsole->onUSBControllerChange();
     742    return mConsole->i_onUSBControllerChange();
    743743#else
    744744    return S_OK;
    … …  
    759759    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    760760
    761     return mConsole->onSharedFolderChange(aGlobal);
     761    return mConsole->i_onSharedFolderChange(aGlobal);
    762762#else
    763763    return S_OK;
    … …  
    778778    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    779779
    780     return mConsole->onClipboardModeChange(aClipboardMode);
     780    return mConsole->i_onClipboardModeChange(aClipboardMode);
    781781#else
    782782    return S_OK;
    … …  
    796796    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
    797797
    798     return mConsole->onDnDModeChange(aDragAndDropMode);
     798    return mConsole->i_onDnDModeChange(aDragAndDropMode);
    799799#else
    800800    return S_OK;
    … …  
    817817    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    818818
    819     return mConsole->onUSBDeviceAttach(aDevice, aError, aMaskedIfs);
     819    return mConsole->i_onUSBDeviceAttach(aDevice, aError, aMaskedIfs);
    820820#else
    821821    return S_OK;
    … …  
    837837    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    838838
    839     return mConsole->onUSBDeviceDetach(aId, aError);
     839    return mConsole->i_onUSBDeviceDetach(aId, aError);
    840840#else
    841841    return S_OK;
    … …  
    867867
    868868#ifndef VBOX_COM_INPROC_API_CLIENT
    869     return mConsole->onShowWindow(aCheck, aCanShow, aWinId);
     869    return mConsole->i_onShowWindow(aCheck, aCanShow, aWinId);
    870870#else
    871871    return S_OK;
    … …  
    886886    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    887887
    888     return mConsole->onBandwidthGroupChange(aBandwidthGroup);
     888    return mConsole->i_onBandwidthGroupChange(aBandwidthGroup);
    889889#else
    890890    return S_OK;
    … …  
    905905    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    906906
    907     return mConsole->onStorageDeviceChange(aMediumAttachment, aRemove, aSilent);
     907    return mConsole->i_onStorageDeviceChange(aMediumAttachment, aRemove, aSilent);
    908908#else
    909909    return S_OK;
    … …  
    944944
    945945    if (!aIsSetter)
    946         return mConsole->getGuestProperty(aName, aRetValue, aRetTimestamp, aRetFlags);
     946        return mConsole->i_getGuestProperty(aName, aRetValue, aRetTimestamp, aRetFlags);
    947947    else
    948         return mConsole->setGuestProperty(aName, aValue, aFlags);
     948        return mConsole->i_setGuestProperty(aName, aValue, aFlags);
    949949
    950950# else  /* VBOX_COM_INPROC_API_CLIENT */
    … …  
    991991        return E_ACCESSDENIED;
    992992
    993     return mConsole->enumerateGuestProperties(aPatterns,
    994                                               ComSafeArrayOutArg(aNames),
    995                                               ComSafeArrayOutArg(aValues),
    996                                               ComSafeArrayOutArg(aTimestamps),
    997                                               ComSafeArrayOutArg(aFlags));
     993    return mConsole->i_enumerateGuestProperties(aPatterns,
     994                                                ComSafeArrayOutArg(aNames),
     995                                                ComSafeArrayOutArg(aValues),
     996                                                ComSafeArrayOutArg(aTimestamps),
     997                                                ComSafeArrayOutArg(aFlags));
    998998#else /* VBOX_WITH_GUEST_PROPS not defined */
    999999    ReturnComNotImplemented();
    … …  
    10171017    CheckComArgNotNull(aMediumAttachment);
    10181018
    1019     return mConsole->onlineMergeMedium(aMediumAttachment,
    1020                                        aSourceIdx, aTargetIdx,
    1021                                        aProgress);
     1019    return mConsole->i_onlineMergeMedium(aMediumAttachment,
     1020                                         aSourceIdx, aTargetIdx,
     1021                                         aProgress);
    10221022#else
    10231023    AssertFailed();
    … …  
    10371037    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    10381038
    1039     mConsole->enableVMMStatistics(aEnable);
     1039    mConsole->i_enableVMMStatistics(aEnable);
    10401040
    10411041    return S_OK;
    … …  
    10571057    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    10581058
    1059     return mConsole->pause(aReason);
     1059    return mConsole->i_pause(aReason);
    10601060#else
    10611061    AssertFailed();
    … …  
    10751075    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    10761076
    1077     return mConsole->resume(aReason);
     1077    return mConsole->i_resume(aReason);
    10781078#else
    10791079    AssertFailed();
    … …  
    10931093    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
    10941094
    1095     return mConsole->saveState(aReason, aProgress);
     1095    return mConsole->i_saveState(aReason, aProgress);
    10961096#else
    10971097    AssertFailed();

  • trunk/src/VBox/Main/src-client/UsbCardReader.cpp

    r45927 r51612  
    55
    66/*
    7  * Copyright (C) 2011-2012 Oracle Corporation
     7 * Copyright (C) 2011-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    693693int UsbCardReader::vrdeSCardRequest(void *pvUser, uint32_t u32Function, const void *pvData, uint32_t cbData)
    694694{
    695     int rc = mParent->consoleVRDPServer()->SCardRequest(pvUser, u32Function, pvData, cbData);
     695    int rc = mParent->i_consoleVRDPServer()->SCardRequest(pvUser, u32Function, pvData, cbData);
    696696    LogFlowFunc(("%d %Rrc\n", u32Function, rc));
    697697    return rc;

  • trunk/src/VBox/Main/src-client/UsbWebcamInterface.cpp

    r50580 r51612  
    55
    66/*
    7  * Copyright (C) 2011-2013 Oracle Corporation
     7 * Copyright (C) 2011-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    258258
    259259        /* Try to attach the device. */
    260         EmulatedUSB *pEUSB = mParent->getConsole()->getEmulatedUSB();
     260        EmulatedUSB *pEUSB = mParent->getConsole()->i_getEmulatedUSB();
    261261        pEUSB->i_webcamAttachInternal("", "", "EmWebcam", pRemote);
    262262    }

  • trunk/src/VBox/Main/src-client/VMMDevInterface.cpp

    r51436 r51612  
    55
    66/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     7 * Copyright (C) 2006-2014 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    160160
    161161    /* Store that information in IGuest */
    162     Guest* guest = pConsole->getGuest();
     162    Guest* guest = pConsole->i_getGuest();
    163163    AssertPtrReturnVoid(guest);
    164164
    165165    guest->setAdditionsStatus((VBoxGuestFacilityType)uFacility, (VBoxGuestFacilityStatus)uStatus, fFlags, pTimeSpecTS);
    166     pConsole->onAdditionsStateChange();
     166    pConsole->i_onAdditionsStateChange();
    167167}
    168168
    … …  
    182182
    183183    /* Store that information in IGuest. */
    184     Guest* pGuest = pConsole->getGuest();
     184    Guest* pGuest = pConsole->i_getGuest();
    185185    AssertPtrReturnVoid(pGuest);
    186186
    … …  
    203203{
    204204    AssertPtrReturnVoid(guestInfo);
    205    
     205
    206206    PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, Connector);
    207207    Console *pConsole = pDrv->pVMMDev->getParent();
    208208
    209209    /* Store that information in IGuest */
    210     Guest* guest = pConsole->getGuest();
     210    Guest* guest = pConsole->i_getGuest();
    211211    AssertPtrReturnVoid(guest);
    212212
    … …  
    221221         * so that it can notify its consumers.
    222222         */
    223         pConsole->onAdditionsStateChange();
     223        pConsole->i_onAdditionsStateChange();
    224224
    225225        if (guestInfo->interfaceVersion < VMMDEV_VERSION)
    226             pConsole->onAdditionsOutdated();
     226            pConsole->i_onAdditionsOutdated();
    227227    }
    228228    else
    … …  
    239239        RTTimeNow(&TimeSpecTS);
    240240        guest->setAdditionsStatus(VBoxGuestFacilityType_All, VBoxGuestFacilityStatus_Inactive, 0 /*fFlags*/, &TimeSpecTS);
    241         pConsole->onAdditionsStateChange();
     241        pConsole->i_onAdditionsStateChange();
    242242    }
    243243}
    … …  
    254254
    255255    /* Store that information in IGuest. */
    256     Guest *pGuest = pDrv->pVMMDev->getParent()->getGuest();
     256    Guest *pGuest = pDrv->pVMMDev->getParent()->i_getGuest();
    257257    AssertPtrReturnVoid(pGuest);
    258258
    … …  
    283283
    284284    /* store that information in IGuest */
    285     Guest* pGuest = pConsole->getGuest();
     285    Guest* pGuest = pConsole->i_getGuest();
    286286    AssertPtrReturnVoid(pGuest);
    287287
    … …  
    295295     * so that it can notify its consumers.
    296296     */
    297     pConsole->onAdditionsStateChange();
     297    pConsole->i_onAdditionsStateChange();
    298298}
    299299
    … …  
    316316     * so that it can notify its consumers.
    317317     */
    318     Mouse *pMouse = pConsole->getMouse();
     318    Mouse *pMouse = pConsole->i_getMouse();
    319319    if (pMouse)  /** @todo and if not?  Can that actually happen? */
    320320        pMouse->i_onVMMDevGuestCapsChange(fNewCaps & VMMDEV_MOUSE_GUEST_MASK);
    … …  
    356356    if (pShape)
    357357        ::memcpy(shapeData.raw(), pShape, cbShapeSize);
    358     pConsole->onMousePointerShapeChange(fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayAsInParam(shapeData));
     358    pConsole->i_onMousePointerShapeChange(fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayAsInParam(shapeData));
    359359}
    360360
    … …  
    364364    Console *pConsole = pDrv->pVMMDev->getParent();
    365365
    366     Display *display = pConsole->getDisplay();
     366    Display *display = pConsole->i_getDisplay();
    367367
    368368    if (display)
    … …  
    379379    Console *pConsole = pDrv->pVMMDev->getParent();
    380380
    381     Display *display = pConsole->getDisplay();
     381    Display *display = pConsole->i_getDisplay();
    382382
    383383    if (display)
    … …  
    400400#endif
    401401    IFramebuffer *framebuffer = NULL;
    402     HRESULT hrc = pConsole->getDisplay()->QueryFramebuffer(display, &framebuffer);
     402    HRESULT hrc = pConsole->i_getDisplay()->QueryFramebuffer(display, &framebuffer);
    403403    if (SUCCEEDED(hrc) && framebuffer)
    404404    {
    … …  
    424424        return VERR_INVALID_PARAMETER;
    425425    IFramebuffer *framebuffer = NULL;
    426     HRESULT hrc = pConsole->getDisplay()->QueryFramebuffer(0, &framebuffer);
     426    HRESULT hrc = pConsole->i_getDisplay()->QueryFramebuffer(0, &framebuffer);
    427427    if (SUCCEEDED(hrc) && framebuffer)
    428428    {
    … …  
    451451
    452452    /* Forward to Display, which calls corresponding framebuffers. */
    453     pConsole->getDisplay()->handleSetVisibleRegion(cRect, pRect);
     453    pConsole->i_getDisplay()->handleSetVisibleRegion(cRect, pRect);
    454454
    455455    return VINF_SUCCESS;
    … …  
    462462
    463463    /* Forward to Display, which calls corresponding framebuffers. */
    464     pConsole->getDisplay()->handleQueryVisibleRegion(pcRect, pRect);
     464    pConsole->i_getDisplay()->handleQueryVisibleRegion(pcRect, pRect);
    465465
    466466    return VINF_SUCCESS;
    … …  
    485485
    486486    /* store that information in IGuest */
    487     Guest* guest = pConsole->getGuest();
     487    Guest* guest = pConsole->i_getGuest();
    488488    AssertPtrReturn(guest, VERR_GENERAL_FAILURE);
    489489
    … …  
    511511
    512512    /* store that information in IGuest */
    513     Guest* guest = pConsole->getGuest();
     513    Guest* guest = pConsole->i_getGuest();
    514514    AssertPtrReturn(guest, VERR_GENERAL_FAILURE);
    515515
    … …  
    537537
    538538    /* store that information in IGuest */
    539     Guest* guest = pConsole->getGuest();
     539    Guest* guest = pConsole->i_getGuest();
    540540    AssertPtrReturn(guest, VERR_GENERAL_FAILURE);
    541541
    … …  
    560560
    561561    /* store that information in IGuest */
    562     Guest* guest = pConsole->getGuest();
     562    Guest* guest = pConsole->i_getGuest();
    563563    AssertPtrReturn(guest, VERR_GENERAL_FAILURE);
    564564
    … …  
    574574
    575575    /** @todo r=bird: Convert from 4KB to 1KB units?
    576      *        CollectorGuestHAL::getGuestMemLoad says it returns KB units to
     576     *        CollectorGuestHAL::i_getGuestMemLoad says it returns KB units to
    577577     *        preCollect().  I might be wrong ofc, this is convoluted code... */
    578578    if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)

  • trunk/src/VBox/Main/src-client/xpcom/module.cpp

    r51092 r51612  
    8282 #endif
    8383
    84 NS_DECL_CLASSINFO(Console)
    85 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Console, IConsole)
     84// NS_DECL_CLASSINFO(Console)
     85// NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Console, IConsole)
    8686
    8787#endif /* VBOX_COM_INPROC_API_CLIENT */
Note: See TracChangeset for help on using the changeset viewer.

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