VirtualBox

Changeset 51612 in vbox for trunk/src/VBox


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
Files:
25 edited

Legend:

Unmodified
Added
Removed

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

    r42551 r51612  
    77
    88/*
    9  * Copyright (C) 2010-2012 Oracle Corporation
     9 * Copyright (C) 2010-2014 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2323#include "VBox/pci.h"
    2424#include "VirtualBoxBase.h"
     25#include <vector>
    2526
    2627class BusAssignmentManager
    … …  
    3334    virtual ~BusAssignmentManager();
    3435
    35     HRESULT assignPCIDeviceImpl(const char* pszDevName, PCFGMNODE pCfg, PCIBusAddress& GuestAddress, PCIBusAddress HostAddress, bool fGuestAddressRequired = false);
     36    HRESULT assignPCIDeviceImpl(const char* pszDevName, PCFGMNODE pCfg, PCIBusAddress& GuestAddress,
     37                                PCIBusAddress HostAddress, bool fGuestAddressRequired = false);
    3638
    3739public:
    … …  
    4042    virtual void Release();
    4143
    42     virtual HRESULT assignHostPCIDevice(const char* pszDevName, PCFGMNODE pCfg, PCIBusAddress HostAddress, PCIBusAddress& GuestAddress, bool fAddressRequired = false)
     44    virtual HRESULT assignHostPCIDevice(const char* pszDevName, PCFGMNODE pCfg, PCIBusAddress HostAddress,
     45                                        PCIBusAddress& GuestAddress, bool fAddressRequired = false)
    4346    {
    4447        return assignPCIDeviceImpl(pszDevName, pCfg, GuestAddress, HostAddress, fAddressRequired);
    … …  
    6366        return findPCIAddress(pszDevName, iInstance, Address);
    6467    }
    65     virtual void listAttachedPCIDevices(ComSafeArrayOut(IPCIDeviceAttachment*, aAttached));
     68    virtual void listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached);
    6669};
    6770

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

    r51476 r51612  
    2222#include "VBox/com/array.h"
    2323#include "EventImpl.h"
     24#include "ConsoleWrap.h"
    2425
    2526class Guest;
    … …  
    9798{
    9899public:
    99     virtual VMMDevMouseInterface  *getVMMDevMouseInterface()  = 0;
    100     virtual DisplayMouseInterface *getDisplayMouseInterface() = 0;
    101     virtual void onMouseCapabilityChange(BOOL supportsAbsolute,
    102                                          BOOL supportsRelative,
    103                                          BOOL supportsMT,
    104                                          BOOL needsHostCursor) = 0;
     100    virtual VMMDevMouseInterface  *i_getVMMDevMouseInterface(){return NULL;}
     101    virtual DisplayMouseInterface *i_getDisplayMouseInterface(){return NULL;}
     102    virtual void i_onMouseCapabilityChange(BOOL supportsAbsolute,
     103                                           BOOL supportsRelative,
     104                                           BOOL supportsMT,
     105                                           BOOL needsHostCursor){NOREF(supportsAbsolute); NOREF(supportsRelative); NOREF(supportsMT); NOREF(needsHostCursor);}
    105106};
    106107
    107108/** IConsole implementation class */
    108109class ATL_NO_VTABLE Console :
    109     public VirtualBoxBase,
    110     VBOX_SCRIPTABLE_IMPL(IConsole), public ConsoleMouseInterface
     110    public ConsoleWrap,
     111    public ConsoleMouseInterface
    111112{
    112     Q_OBJECT
    113113
    114114public:
    115115
    116     VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Console, IConsole)
    117 
    118     DECLARE_NOT_AGGREGATABLE(Console)
    119 
    120     DECLARE_PROTECT_FINAL_CONSTRUCT()
    121 
    122     BEGIN_COM_MAP(Console)
    123         VBOX_DEFAULT_INTERFACE_ENTRIES(IConsole)
    124     END_COM_MAP()
    125 
    126     Console();
    127     ~Console();
     116    DECLARE_EMPTY_CTOR_DTOR(Console)
    128117
    129118    HRESULT FinalConstruct();
    … …  
    134123    void uninit();
    135124
    136     // IConsole properties
    137     STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    138     STDMETHOD(COMGETTER(State))(MachineState_T *aMachineState);
    139     STDMETHOD(COMGETTER(Guest))(IGuest **aGuest);
    140     STDMETHOD(COMGETTER(Keyboard))(IKeyboard **aKeyboard);
    141     STDMETHOD(COMGETTER(Mouse))(IMouse **aMouse);
    142     STDMETHOD(COMGETTER(Display))(IDisplay **aDisplay);
    143     STDMETHOD(COMGETTER(Debugger))(IMachineDebugger **aDebugger);
    144     STDMETHOD(COMGETTER(USBDevices))(ComSafeArrayOut(IUSBDevice *, aUSBDevices));
    145     STDMETHOD(COMGETTER(RemoteUSBDevices))(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices));
    146     STDMETHOD(COMGETTER(VRDEServerInfo))(IVRDEServerInfo **aVRDEServerInfo);
    147     STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
    148     STDMETHOD(COMGETTER(EventSource)) (IEventSource ** aEventSource);
    149     STDMETHOD(COMGETTER(AttachedPCIDevices))(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachments));
    150     STDMETHOD(COMGETTER(UseHostClipboard))(BOOL *aUseHostClipboard);
    151     STDMETHOD(COMSETTER(UseHostClipboard))(BOOL aUseHostClipboard);
    152     STDMETHOD(COMGETTER(EmulatedUSB))(IEmulatedUSB **aEmulatedUSB);
    153 
    154     // IConsole methods
    155     STDMETHOD(PowerUp)(IProgress **aProgress);
    156     STDMETHOD(PowerUpPaused)(IProgress **aProgress);
    157     STDMETHOD(PowerDown)(IProgress **aProgress);
    158     STDMETHOD(Reset)();
    159     STDMETHOD(Pause)();
    160     STDMETHOD(Resume)();
    161     STDMETHOD(PowerButton)();
    162     STDMETHOD(SleepButton)();
    163     STDMETHOD(GetPowerButtonHandled)(BOOL *aHandled);
    164     STDMETHOD(GetGuestEnteredACPIMode)(BOOL *aEntered);
    165     STDMETHOD(SaveState)(IProgress **aProgress);
    166     STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
    167     STDMETHOD(DiscardSavedState)(BOOL aRemoveFile);
    168     STDMETHOD(GetDeviceActivity)(DeviceType_T aDeviceType,
    169                                 DeviceActivity_T *aDeviceActivity);
    170     STDMETHOD(AttachUSBDevice)(IN_BSTR aId);
    171     STDMETHOD(DetachUSBDevice)(IN_BSTR aId, IUSBDevice **aDevice);
    172     STDMETHOD(FindUSBDeviceByAddress)(IN_BSTR aAddress, IUSBDevice **aDevice);
    173     STDMETHOD(FindUSBDeviceById)(IN_BSTR aId, IUSBDevice **aDevice);
    174     STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
    175     STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
    176     STDMETHOD(TakeSnapshot)(IN_BSTR aName, IN_BSTR aDescription,
    177                             IProgress **aProgress);
    178     STDMETHOD(DeleteSnapshot)(IN_BSTR aId, IProgress **aProgress);
    179     STDMETHOD(DeleteSnapshotAndAllChildren)(IN_BSTR aId, IProgress **aProgress);
    180     STDMETHOD(DeleteSnapshotRange)(IN_BSTR aStartId, IN_BSTR aEndId, IProgress **aProgress);
    181     STDMETHOD(RestoreSnapshot)(ISnapshot *aSnapshot, IProgress **aProgress);
    182     STDMETHOD(Teleport)(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress);
    183125
    184126    // public methods for internal purposes only
    … …  
    189131     */
    190132
    191     Guest *getGuest() const { return mGuest; }
    192     Keyboard *getKeyboard() const { return mKeyboard; }
    193     Mouse *getMouse() const { return mMouse; }
    194     Display *getDisplay() const { return mDisplay; }
    195     MachineDebugger *getMachineDebugger() const { return mDebugger; }
     133    Guest *i_getGuest() const { return mGuest; }
     134    Keyboard *i_getKeyboard() const { return mKeyboard; }
     135    Mouse *i_getMouse() const { return mMouse; }
     136    Display *i_getDisplay() const { return mDisplay; }
     137    MachineDebugger *i_getMachineDebugger() const { return mDebugger; }
    196138#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
    197     AudioVRDE *getAudioVRDE() const { return mAudioVRDE; }
     139    AudioVRDE *i_getAudioVRDE() const { return mAudioVRDE; }
    198140#else
    199     AudioSniffer *getAudioSniffer() const { return mAudioSniffer; }
    200 #endif
    201 
    202     const ComPtr<IMachine> &machine() const { return mMachine; }
    203 
    204     bool useHostClipboard() { return mfUseHostClipboard; }
     141    AudioSniffer *i_getAudioSniffer() const { return mAudioSniffer; }
     142#endif
     143
     144    const ComPtr<IMachine> &i_machine() const { return mMachine; }
     145
     146    bool i_useHostClipboard() { return mfUseHostClipboard; }
    205147
    206148    /** Method is called only from ConsoleVRDPServer */
    207     IVRDEServer *getVRDEServer() const { return mVRDEServer; }
    208 
    209     ConsoleVRDPServer *consoleVRDPServer() const { return mConsoleVRDPServer; }
    210 
    211     HRESULT updateMachineState(MachineState_T aMachineState);
     149    IVRDEServer *i_getVRDEServer() const { return mVRDEServer; }
     150
     151    ConsoleVRDPServer *i_consoleVRDPServer() const { return mConsoleVRDPServer; }
     152
     153    HRESULT i_updateMachineState(MachineState_T aMachineState);
    212154
    213155    // events from IInternalSessionControl
    214     HRESULT onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
    215     HRESULT onSerialPortChange(ISerialPort *aSerialPort);
    216     HRESULT onParallelPortChange(IParallelPort *aParallelPort);
    217     HRESULT onStorageControllerChange();
    218     HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
    219     HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
    220     HRESULT onCPUExecutionCapChange(ULONG aExecutionCap);
    221     HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
    222     HRESULT onDnDModeChange(DnDMode_T aDnDMode);
    223     HRESULT onVRDEServerChange(BOOL aRestart);
    224     HRESULT onVideoCaptureChange();
    225     HRESULT onUSBControllerChange();
    226     HRESULT onSharedFolderChange(BOOL aGlobal);
    227     HRESULT onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs);
    228     HRESULT onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
    229     HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
    230     HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
    231     HRESULT onExtraDataChange(IN_BSTR aMachineId, IN_BSTR aKey, IN_BSTR aVal);
    232 
    233     HRESULT getGuestProperty(IN_BSTR aKey, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags);
    234     HRESULT setGuestProperty(IN_BSTR aKey, IN_BSTR aValue, IN_BSTR aFlags);
    235     HRESULT enumerateGuestProperties(IN_BSTR aPatterns,
    236                                      ComSafeArrayOut(BSTR, aNames),
    237                                      ComSafeArrayOut(BSTR, aValues),
    238                                      ComSafeArrayOut(LONG64, aTimestamps),
    239                                      ComSafeArrayOut(BSTR, aFlags));
    240     HRESULT onlineMergeMedium(IMediumAttachment *aMediumAttachment,
    241                               ULONG aSourceIdx, ULONG aTargetIdx,
    242                               IProgress *aProgress);
    243     int hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName);
    244     VMMDev *getVMMDev() { return m_pVMMDev; }
     156    HRESULT i_onNetworkAdapterChange(INetworkAdapter *aNetworkAdapter, BOOL changeAdapter);
     157    HRESULT i_onSerialPortChange(ISerialPort *aSerialPort);
     158    HRESULT i_onParallelPortChange(IParallelPort *aParallelPort);
     159    HRESULT i_onStorageControllerChange();
     160    HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
     161    HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
     162    HRESULT i_onCPUExecutionCapChange(ULONG aExecutionCap);
     163    HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
     164    HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
     165    HRESULT i_onVRDEServerChange(BOOL aRestart);
     166    HRESULT i_onVideoCaptureChange();
     167    HRESULT i_onUSBControllerChange();
     168    HRESULT i_onSharedFolderChange(BOOL aGlobal);
     169    HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs);
     170    HRESULT i_onUSBDeviceDetach(IN_BSTR aId, IVirtualBoxErrorInfo *aError);
     171    HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
     172    HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
     173    HRESULT i_onExtraDataChange(IN_BSTR aMachineId, IN_BSTR aKey, IN_BSTR aVal);
     174
     175    HRESULT i_getGuestProperty(IN_BSTR aKey, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags);
     176    HRESULT i_setGuestProperty(IN_BSTR aKey, IN_BSTR aValue, IN_BSTR aFlags);
     177    HRESULT i_enumerateGuestProperties(IN_BSTR aPatterns,
     178                                       ComSafeArrayOut(BSTR, aNames),
     179                                       ComSafeArrayOut(BSTR, aValues),
     180                                       ComSafeArrayOut(LONG64, aTimestamps),
     181                                       ComSafeArrayOut(BSTR, aFlags));
     182    HRESULT i_onlineMergeMedium(IMediumAttachment *aMediumAttachment,
     183                                ULONG aSourceIdx, ULONG aTargetIdx,
     184                                IProgress *aProgress);
     185    int i_hgcmLoadService(const char *pszServiceLibrary, const char *pszServiceName);
     186    VMMDev *i_getVMMDev() { return m_pVMMDev; }
    245187#ifdef VBOX_WITH_PDM_AUDIO_DRIVER
    246     AudioVRDE *getAudioVRDE() { return mAudioVRDE; }
     188    AudioVRDE *i_getAudioVRDE() { return mAudioVRDE; }
    247189#else
    248     AudioSniffer *getAudioSniffer() { return mAudioSniffer; }
     190    AudioSniffer *i_getAudioSniffer() { return mAudioSniffer; }
    249191#endif
    250192
    251193#ifdef VBOX_WITH_EXTPACK
    252     ExtPackManager *getExtPackManager();
    253 #endif
    254     EventSource *getEventSource() { return mEventSource; }
     194    ExtPackManager *i_getExtPackManager();
     195#endif
     196    EventSource *i_getEventSource() { return mEventSource; }
    255197#ifdef VBOX_WITH_USB_CARDREADER
    256     UsbCardReader *getUsbCardReader() { return mUsbCardReader; }
    257 #endif
    258 
    259     int VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain);
    260     void VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
    261     void VRDPClientConnect(uint32_t u32ClientId);
    262     void VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
    263     void VRDPInterceptAudio(uint32_t u32ClientId);
    264     void VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
    265     void VRDPInterceptClipboard(uint32_t u32ClientId);
    266 
    267     void processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
    268     void reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
    269                                ULONG aCpuKernel, ULONG aCpuIdle,
    270                                ULONG aMemTotal, ULONG aMemFree,
    271                                ULONG aMemBalloon, ULONG aMemShared,
    272                                ULONG aMemCache, ULONG aPageTotal,
    273                                ULONG aAllocVMM, ULONG aFreeVMM,
    274                                ULONG aBalloonedVMM, ULONG aSharedVMM,
    275                                ULONG aVmNetRx, ULONG aVmNetTx)
     198    UsbCardReader *i_getUsbCardReader() { return mUsbCardReader; }
     199#endif
     200
     201    int i_VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain);
     202    void i_VRDPClientStatusChange(uint32_t u32ClientId, const char *pszStatus);
     203    void i_VRDPClientConnect(uint32_t u32ClientId);
     204    void i_VRDPClientDisconnect(uint32_t u32ClientId, uint32_t fu32Intercepted);
     205    void i_VRDPInterceptAudio(uint32_t u32ClientId);
     206    void i_VRDPInterceptUSB(uint32_t u32ClientId, void **ppvIntercept);
     207    void i_VRDPInterceptClipboard(uint32_t u32ClientId);
     208
     209    void i_processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList, bool fDescExt);
     210    void i_reportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
     211                              ULONG aCpuKernel, ULONG aCpuIdle,
     212                              ULONG aMemTotal, ULONG aMemFree,
     213                              ULONG aMemBalloon, ULONG aMemShared,
     214                              ULONG aMemCache, ULONG aPageTotal,
     215                              ULONG aAllocVMM, ULONG aFreeVMM,
     216                              ULONG aBalloonedVMM, ULONG aSharedVMM,
     217                              ULONG aVmNetRx, ULONG aVmNetTx)
    276218    {
    277219        mControl->ReportVmStatistics(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
    … …  
    280222                                     aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
    281223    }
    282     void enableVMMStatistics(BOOL aEnable);
    283 
    284     HRESULT pause(Reason_T aReason);
    285     HRESULT resume(Reason_T aReason);
    286     HRESULT saveState(Reason_T aReason, IProgress **aProgress);
     224    void i_enableVMMStatistics(BOOL aEnable);
     225
     226    HRESULT i_pause(Reason_T aReason);
     227    HRESULT i_resume(Reason_T aReason);
     228    HRESULT i_saveState(Reason_T aReason, IProgress **aProgress);
    287229
    288230    // callback callers (partly; for some events console callbacks are notified
    289231    // directly from IInternalSessionControl event handlers declared above)
    290     void onMousePointerShapeChange(bool fVisible, bool fAlpha,
    291                                    uint32_t xHot, uint32_t yHot,
    292                                    uint32_t width, uint32_t height,
    293                                    ComSafeArrayIn(uint8_t, aShape));
    294     void onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
    295                                  BOOL supportsMT, BOOL needsHostCursor);
    296     void onStateChange(MachineState_T aMachineState);
    297     void onAdditionsStateChange();
    298     void onAdditionsOutdated();
    299     void onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
    300     void onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
    301                                 IVirtualBoxErrorInfo *aError);
    302     void onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
    303     HRESULT onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId);
    304     void onVRDEServerInfoChange();
     232    void i_onMousePointerShapeChange(bool fVisible, bool fAlpha,
     233                                     uint32_t xHot, uint32_t yHot,
     234                                     uint32_t width, uint32_t height,
     235                                     ComSafeArrayIn(uint8_t, aShape));
     236    void i_onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative,
     237                                   BOOL supportsMT, BOOL needsHostCursor);
     238    void i_onStateChange(MachineState_T aMachineState);
     239    void i_onAdditionsStateChange();
     240    void i_onAdditionsOutdated();
     241    void i_onKeyboardLedsChange(bool fNumLock, bool fCapsLock, bool fScrollLock);
     242    void i_onUSBDeviceStateChange(IUSBDevice *aDevice, bool aAttached,
     243                                  IVirtualBoxErrorInfo *aError);
     244    void i_onRuntimeError(BOOL aFatal, IN_BSTR aErrorID, IN_BSTR aMessage);
     245    HRESULT i_onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId);
     246    void i_onVRDEServerInfoChange();
    305247
    306248    static const PDMDRVREG DrvStatusReg;
    307249
    308     static HRESULT setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
    309     HRESULT setInvalidMachineStateError();
    310 
    311     static const char *convertControllerTypeToDev(StorageControllerType_T enmCtrlType);
    312     static HRESULT convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
     250    static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcsz, ...);
     251    HRESULT i_setInvalidMachineStateError();
     252
     253    static const char *i_convertControllerTypeToDev(StorageControllerType_T enmCtrlType);
     254    static HRESULT i_convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun);
    313255    // Called from event listener
    314     HRESULT onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
    315                                  NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
     256    HRESULT i_onNATRedirectRuleChange(ULONG ulInstance, BOOL aNatRuleRemove,
     257                                      NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
    316258
    317259    // Mouse interface
    318     VMMDevMouseInterface *getVMMDevMouseInterface();
    319     DisplayMouseInterface *getDisplayMouseInterface();
    320 
    321     EmulatedUSB *getEmulatedUSB(void) { return mEmulatedUSB; }
     260    VMMDevMouseInterface *i_getVMMDevMouseInterface();
     261    DisplayMouseInterface *i_getDisplayMouseInterface();
     262
     263    EmulatedUSB *i_getEmulatedUSB(void) { return mEmulatedUSB; }
    322264
    323265    /**
    … …  
    335277     *            - dek: The data encryption key in base64 encoding
    336278     */
    337     HRESULT setDiskEncryptionKeys(const Utf8Str &strCfg);
     279    HRESULT i_setDiskEncryptionKeys(const Utf8Str &strCfg);
    338280
    339281private:
     282
     283    // wraped IConsole properties
     284    HRESULT getMachine(ComPtr<IMachine> &aMachine);
     285    HRESULT getState(MachineState_T *aState);
     286    HRESULT getGuest(ComPtr<IGuest> &aGuest);
     287    HRESULT getKeyboard(ComPtr<IKeyboard> &aKeyboard);
     288    HRESULT getMouse(ComPtr<IMouse> &aMouse);
     289    HRESULT getDisplay(ComPtr<IDisplay> &aDisplay);
     290    HRESULT getDebugger(ComPtr<IMachineDebugger> &aDebugger);
     291    HRESULT getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices);
     292    HRESULT getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices);
     293    HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
     294    HRESULT getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo);
     295    HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
     296    HRESULT getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices);
     297    HRESULT getUseHostClipboard(BOOL *aUseHostClipboard);
     298    HRESULT setUseHostClipboard(BOOL aUseHostClipboard);
     299    HRESULT getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB);
     300
     301    // wraped IConsole methods
     302    HRESULT powerUp(ComPtr<IProgress> &aProgress);
     303    HRESULT powerUpPaused(ComPtr<IProgress> &aProgress);
     304    HRESULT powerDown(ComPtr<IProgress> &aProgress);
     305    HRESULT reset();
     306    HRESULT pause();
     307    HRESULT resume();
     308    HRESULT powerButton();
     309    HRESULT sleepButton();
     310    HRESULT getPowerButtonHandled(BOOL *aHandled);
     311    HRESULT getGuestEnteredACPIMode(BOOL *aEntered);
     312    HRESULT saveState(ComPtr<IProgress> &aProgress);
     313    HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
     314    HRESULT discardSavedState(BOOL aFRemoveFile);
     315    HRESULT getDeviceActivity(DeviceType_T aType,
     316                              DeviceActivity_T *aActivity);
     317    HRESULT attachUSBDevice(const com::Guid &aId);
     318    HRESULT detachUSBDevice(const com::Guid &aId,
     319                            ComPtr<IUSBDevice> &aDevice);
     320    HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
     321                                   ComPtr<IUSBDevice> &aDevice);
     322    HRESULT findUSBDeviceById(const com::Guid &aId,
     323                              ComPtr<IUSBDevice> &aDevice);
     324    HRESULT createSharedFolder(const com::Utf8Str &aName,
     325                               const com::Utf8Str &aHostPath,
     326                               BOOL aWritable,
     327                               BOOL aAutomount);
     328    HRESULT removeSharedFolder(const com::Utf8Str &aName);
     329    HRESULT takeSnapshot(const com::Utf8Str &aName,
     330                         const com::Utf8Str &aDescription,
     331                         ComPtr<IProgress> &aProgress);
     332    HRESULT deleteSnapshot(const com::Guid &aId,
     333                           ComPtr<IProgress> &aProgress);
     334    HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
     335                                         ComPtr<IProgress> &aProgress);
     336    HRESULT deleteSnapshotRange(const com::Guid &aStartId,
     337                                const com::Guid &aEndId,
     338                                ComPtr<IProgress> &aProgress);
     339    HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
     340                            ComPtr<IProgress> &aProgress);
     341    HRESULT teleport(const com::Utf8Str &aHostname,
     342                     ULONG aTcpport,
     343                     const com::Utf8Str &aPassword,
     344                     ULONG aMaxDowntime,
     345                     ComPtr<IProgress> &aProgress);
    340346
    341347    /**
    … …  
    350356        {
    351357            Assert(aThat);
    352             mRC = aThat->addVMCaller(taQuiet, taAllowNullVM);
     358            mRC = aThat->i_addVMCaller(taQuiet, taAllowNullVM);
    353359        }
    354360        ~AutoVMCallerBase()
    … …  
    367373        {
    368374            AssertReturnVoid(!SUCCEEDED(mRC));
    369             mRC = mThat->addVMCaller(taQuiet, taAllowNullVM);
     375            mRC = mThat->i_addVMCaller(taQuiet, taAllowNullVM);
    370376        }
    371377        /** Returns the result of Console::addVMCaller() */
    … …  
    379385            if (SUCCEEDED(mRC))
    380386            {
    381                 mThat->releaseVMCaller();
     387                mThat->i_releaseVMCaller();
    382388                mRC = E_FAIL;
    383389            }
    … …  
    447453        {
    448454            if (Base::isOk())
    449                 mRC = aThat->safeVMPtrRetainer(&mpUVM, taQuiet);
     455                mRC = aThat->i_safeVMPtrRetainer(&mpUVM, taQuiet);
    450456        }
    451457        ~SafeVMPtrBase()
    … …  
    472478            if (SUCCEEDED(mRC))
    473479            {
    474                 Base::mThat->safeVMPtrReleaser(&mpUVM);
     480                Base::mThat->i_safeVMPtrReleaser(&mpUVM);
    475481                mRC = E_FAIL;
    476482            }
    … …  
    571577    typedef std::list <ComObjPtr<RemoteUSBDevice> > RemoteUSBDeviceList;
    572578
    573     HRESULT addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
    574     void    releaseVMCaller();
    575     HRESULT safeVMPtrRetainer(PUVM *a_ppUVM, bool aQuiet);
    576     void    safeVMPtrReleaser(PUVM *a_ppUVM);
    577 
    578     HRESULT consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
    579 
    580     HRESULT powerUp(IProgress **aProgress, bool aPaused);
    581     HRESULT powerDown(IProgress *aProgress = NULL);
     579    HRESULT i_addVMCaller(bool aQuiet = false, bool aAllowNullVM = false);
     580    void    i_releaseVMCaller();
     581    HRESULT i_safeVMPtrRetainer(PUVM *a_ppUVM, bool aQuiet);
     582    void    i_safeVMPtrReleaser(PUVM *a_ppUVM);
     583
     584    HRESULT i_consoleInitReleaseLog(const ComPtr<IMachine> aMachine);
     585
     586    HRESULT i_powerUp(IProgress **aProgress, bool aPaused);
     587    HRESULT i_powerDown(IProgress *aProgress = NULL);
    582588
    583589/* Note: FreeBSD needs this whether netflt is used or not. */
    584590#if ((defined(RT_OS_LINUX) && !defined(VBOX_WITH_NETFLT)) || defined(RT_OS_FREEBSD))
    585     HRESULT attachToTapInterface(INetworkAdapter *networkAdapter);
    586     HRESULT detachFromTapInterface(INetworkAdapter *networkAdapter);
    587 #endif
    588     HRESULT powerDownHostInterfaces();
    589 
    590     HRESULT setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
    591     HRESULT setMachineStateLocally(MachineState_T aMachineState)
     591    HRESULT i_attachToTapInterface(INetworkAdapter *networkAdapter);
     592    HRESULT i_detachFromTapInterface(INetworkAdapter *networkAdapter);
     593#endif
     594    HRESULT i_powerDownHostInterfaces();
     595
     596    HRESULT i_setMachineState(MachineState_T aMachineState, bool aUpdateServer = true);
     597    HRESULT i_setMachineStateLocally(MachineState_T aMachineState)
    592598    {
    593         return setMachineState(aMachineState, false /* aUpdateServer */);
     599        return i_setMachineState(aMachineState, false /* aUpdateServer */);
    594600    }
    595601
    596     HRESULT findSharedFolder(const Utf8Str &strName,
    597                              ComObjPtr<SharedFolder> &aSharedFolder,
    598                              bool aSetError = false);
    599 
    600     HRESULT fetchSharedFolders(BOOL aGlobal);
    601     bool findOtherSharedFolder(const Utf8Str &straName,
    602                                SharedFolderDataMap::const_iterator &aIt);
    603 
    604     HRESULT createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
    605     HRESULT removeSharedFolder(const Utf8Str &strName);
    606 
    607     HRESULT suspendBeforeConfigChange(PUVM pUVM, AutoWriteLock *pAlock, bool *pfResume);
    608     void    resumeAfterConfigChange(PUVM pUVM);
    609 
    610     static DECLCALLBACK(int) configConstructor(PUVM pUVM, PVM pVM, void *pvConsole);
    611     int configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock);
    612     int configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine);
    613     int configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine);
    614 
    615     int configGraphicsController(PCFGMNODE pDevices,
    616                                  const GraphicsControllerType_T graphicsController,
    617                                  BusAssignmentManager *pBusMgr,
    618                                  const ComPtr<IMachine> &pMachine,
    619                                  const ComPtr<IBIOSSettings> &biosSettings,
    620                                  bool fHMEnabled);
    621     int configMediumAttachment(PCFGMNODE pCtlInst,
    622                                const char *pcszDevice,
    623                                unsigned uInstance,
    624                                StorageBus_T enmBus,
    625                                bool fUseHostIOCache,
    626                                bool fBuiltinIoCache,
    627                                bool fSetupMerge,
    628                                unsigned uMergeSource,
    629                                unsigned uMergeTarget,
    630                                IMediumAttachment *pMediumAtt,
    631                                MachineState_T aMachineState,
    632                                HRESULT *phrc,
    633                                bool fAttachDetach,
    634                                bool fForceUnmount,
    635                                bool fHotplug,
    636                                PUVM pUVM,
    637                                DeviceType_T *paLedDevType,
    638                                PCFGMNODE *ppLunL0);
    639     int configMedium(PCFGMNODE pLunL0,
    640                      bool fPassthrough,
    641                      DeviceType_T enmType,
    642                      bool fUseHostIOCache,
    643                      bool fBuiltinIoCache,
    644                      bool fSetupMerge,
    645                      unsigned uMergeSource,
    646                      unsigned uMergeTarget,
    647                      const char *pcszBwGroup,
    648                      bool fDiscard,
    649                      IMedium *pMedium,
    650                      MachineState_T aMachineState,
    651                      HRESULT *phrc);
    652     static DECLCALLBACK(int) reconfigureMediumAttachment(Console *pThis,
    653                                                          PUVM pUVM,
    654                                                          const char *pcszDevice,
    655                                                          unsigned uInstance,
    656                                                          StorageBus_T enmBus,
    657                                                          bool fUseHostIOCache,
    658                                                          bool fBuiltinIoCache,
    659                                                          bool fSetupMerge,
    660                                                          unsigned uMergeSource,
    661                                                          unsigned uMergeTarget,
    662                                                          IMediumAttachment *aMediumAtt,
    663                                                          MachineState_T aMachineState,
    664                                                          HRESULT *phrc);
    665     static DECLCALLBACK(int) changeRemovableMedium(Console *pThis,
     602    HRESULT i_findSharedFolder(const Utf8Str &strName,
     603                               ComObjPtr<SharedFolder> &aSharedFolder,
     604                               bool aSetError = false);
     605
     606    HRESULT i_fetchSharedFolders(BOOL aGlobal);
     607    bool    i_findOtherSharedFolder(const Utf8Str &straName,
     608                                    SharedFolderDataMap::const_iterator &aIt);
     609
     610    HRESULT i_createSharedFolder(const Utf8Str &strName, const SharedFolderData &aData);
     611    HRESULT i_removeSharedFolder(const Utf8Str &strName);
     612
     613    HRESULT i_suspendBeforeConfigChange(PUVM pUVM, AutoWriteLock *pAlock, bool *pfResume);
     614    void    i_resumeAfterConfigChange(PUVM pUVM);
     615
     616    static DECLCALLBACK(int) i_configConstructor(PUVM pUVM, PVM pVM, void *pvConsole);
     617    int i_configConstructorInner(PUVM pUVM, PVM pVM, AutoWriteLock *pAlock);
     618    int i_configCfgmOverlay(PCFGMNODE pRoot, IVirtualBox *pVirtualBox, IMachine *pMachine);
     619    int i_configDumpAPISettingsTweaks(IVirtualBox *pVirtualBox, IMachine *pMachine);
     620
     621    int i_configGraphicsController(PCFGMNODE pDevices,
     622                                   const GraphicsControllerType_T graphicsController,
     623                                   BusAssignmentManager *pBusMgr,
     624                                   const ComPtr<IMachine> &pMachine,
     625                                   const ComPtr<IBIOSSettings> &biosSettings,
     626                                   bool fHMEnabled);
     627    int i_configMediumAttachment(PCFGMNODE pCtlInst,
     628                                 const char *pcszDevice,
     629                                 unsigned uInstance,
     630                                 StorageBus_T enmBus,
     631                                 bool fUseHostIOCache,
     632                                 bool fBuiltinIoCache,
     633                                 bool fSetupMerge,
     634                                 unsigned uMergeSource,
     635                                 unsigned uMergeTarget,
     636                                 IMediumAttachment *pMediumAtt,
     637                                 MachineState_T aMachineState,
     638                                 HRESULT *phrc,
     639                                 bool fAttachDetach,
     640                                 bool fForceUnmount,
     641                                 bool fHotplug,
     642                                 PUVM pUVM,
     643                                 DeviceType_T *paLedDevType,
     644                                 PCFGMNODE *ppLunL0);
     645    int i_configMedium(PCFGMNODE pLunL0,
     646                       bool fPassthrough,
     647                       DeviceType_T enmType,
     648                       bool fUseHostIOCache,
     649                       bool fBuiltinIoCache,
     650                       bool fSetupMerge,
     651                       unsigned uMergeSource,
     652                       unsigned uMergeTarget,
     653                       const char *pcszBwGroup,
     654                       bool fDiscard,
     655                       IMedium *pMedium,
     656                       MachineState_T aMachineState,
     657                       HRESULT *phrc);
     658    static DECLCALLBACK(int) i_reconfigureMediumAttachment(Console *pThis,
     659                                                           PUVM pUVM,
     660                                                           const char *pcszDevice,
     661                                                           unsigned uInstance,
     662                                                           StorageBus_T enmBus,
     663                                                           bool fUseHostIOCache,
     664                                                           bool fBuiltinIoCache,
     665                                                           bool fSetupMerge,
     666                                                           unsigned uMergeSource,
     667                                                           unsigned uMergeTarget,
     668                                                           IMediumAttachment *aMediumAtt,
     669                                                           MachineState_T aMachineState,
     670                                                           HRESULT *phrc);
     671    static DECLCALLBACK(int) i_changeRemovableMedium(Console *pThis,
     672                                                     PUVM pUVM,
     673                                                     const char *pcszDevice,
     674                                                     unsigned uInstance,
     675                                                     StorageBus_T enmBus,
     676                                                     bool fUseHostIOCache,
     677                                                     IMediumAttachment *aMediumAtt,
     678                                                     bool fForce);
     679
     680    HRESULT i_attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
     681    void i_attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
     682                              uint64_t uFirst, uint64_t uLast,
     683                              Console::MediumAttachmentMap *pmapMediumAttachments,
     684                              const char *pcszDevice, unsigned uInstance);
     685
     686    int i_configNetwork(const char *pszDevice, unsigned uInstance, unsigned uLun,
     687                        INetworkAdapter *aNetworkAdapter, PCFGMNODE pCfg,
     688                        PCFGMNODE pLunL0, PCFGMNODE pInst,
     689                        bool fAttachDetach, bool fIgnoreConnectFailure);
     690
     691    static DECLCALLBACK(int) i_configGuestProperties(void *pvConsole, PUVM pUVM);
     692    static DECLCALLBACK(int) i_configGuestControl(void *pvConsole);
     693    static DECLCALLBACK(void) i_vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
     694    static DECLCALLBACK(int) i_unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
     695    static DECLCALLBACK(int) i_plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
     696    HRESULT i_doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM);
     697    HRESULT i_doCPURemove(ULONG aCpu, PUVM pUVM);
     698    HRESULT i_doCPUAdd(ULONG aCpu, PUVM pUVM);
     699
     700    HRESULT i_doNetworkAdapterChange(PUVM pUVM, const char *pszDevice, unsigned uInstance,
     701                                     unsigned uLun, INetworkAdapter *aNetworkAdapter);
     702    static DECLCALLBACK(int) i_changeNetworkAttachment(Console *pThis, PUVM pUVM, const char *pszDevice,
     703                                                       unsigned uInstance, unsigned uLun,
     704                                                       INetworkAdapter *aNetworkAdapter);
     705
     706    void i_changeClipboardMode(ClipboardMode_T aClipboardMode);
     707    int i_changeDnDMode(DnDMode_T aDnDMode);
     708
     709#ifdef VBOX_WITH_USB
     710    HRESULT i_attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs);
     711    HRESULT i_detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
     712
     713    static DECLCALLBACK(int) i_usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid,
     714                                                 bool aRemote, const char *aAddress, void *pvRemoteBackend,
     715                                                 USHORT aPortVersion, ULONG aMaskedIfs);
     716    static DECLCALLBACK(int) i_usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid);
     717#endif
     718
     719    static DECLCALLBACK(int) i_attachStorageDevice(Console *pThis,
    666720                                                   PUVM pUVM,
    667721                                                   const char *pcszDevice,
    … …  
    670724                                                   bool fUseHostIOCache,
    671725                                                   IMediumAttachment *aMediumAtt,
    672                                                    bool fForce);
    673 
    674     HRESULT attachRawPCIDevices(PUVM pUVM, BusAssignmentManager *BusMgr, PCFGMNODE pDevices);
    675     void attachStatusDriver(PCFGMNODE pCtlInst, PPDMLED *papLeds,
    676                             uint64_t uFirst, uint64_t uLast,
    677                             Console::MediumAttachmentMap *pmapMediumAttachments,
    678                             const char *pcszDevice, unsigned uInstance);
    679 
    680     int configNetwork(const char *pszDevice, unsigned uInstance, unsigned uLun,
    681                       INetworkAdapter *aNetworkAdapter, PCFGMNODE pCfg,
    682                       PCFGMNODE pLunL0, PCFGMNODE pInst,
    683                       bool fAttachDetach, bool fIgnoreConnectFailure);
    684 
    685     static DECLCALLBACK(int) configGuestProperties(void *pvConsole, PUVM pUVM);
    686     static DECLCALLBACK(int) configGuestControl(void *pvConsole);
    687     static DECLCALLBACK(void) vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
    688     static DECLCALLBACK(int) unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
    689     static DECLCALLBACK(int) plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
    690     HRESULT doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM);
    691     HRESULT doCPURemove(ULONG aCpu, PUVM pUVM);
    692     HRESULT doCPUAdd(ULONG aCpu, PUVM pUVM);
    693 
    694     HRESULT doNetworkAdapterChange(PUVM pUVM, const char *pszDevice, unsigned uInstance,
    695                                    unsigned uLun, INetworkAdapter *aNetworkAdapter);
    696     static DECLCALLBACK(int) changeNetworkAttachment(Console *pThis, PUVM pUVM, const char *pszDevice,
    697                                                      unsigned uInstance, unsigned uLun,
    698                                                      INetworkAdapter *aNetworkAdapter);
    699 
    700     void changeClipboardMode(ClipboardMode_T aClipboardMode);
    701     int changeDnDMode(DnDMode_T aDnDMode);
    702 
    703 #ifdef VBOX_WITH_USB
    704     HRESULT attachUSBDevice(IUSBDevice *aHostDevice, ULONG aMaskedIfs);
    705     HRESULT detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
    706 
    707     static DECLCALLBACK(int) usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid,
    708                        bool aRemote, const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs);
    709     static DECLCALLBACK(int) usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid);
    710 #endif
    711 
    712     static DECLCALLBACK(int) attachStorageDevice(Console *pThis,
    713                                                  PUVM pUVM,
    714                                                  const char *pcszDevice,
    715                                                  unsigned uInstance,
    716                                                  StorageBus_T enmBus,
    717                                                  bool fUseHostIOCache,
    718                                                  IMediumAttachment *aMediumAtt,
    719                                                  bool fSilent);
    720     static DECLCALLBACK(int) detachStorageDevice(Console *pThis,
    721                                                  PUVM pUVM,
    722                                                  const char *pcszDevice,
    723                                                  unsigned uInstance,
    724                                                  StorageBus_T enmBus,
    725                                                  IMediumAttachment *aMediumAtt,
    726                                                  bool fSilent);
    727     HRESULT doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
    728     HRESULT doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
    729 
    730     static DECLCALLBACK(int)    fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser);
    731 
    732     static DECLCALLBACK(int)    stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
    733 
    734     static DECLCALLBACK(void)   genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
    735                                                           const char *pszErrorFmt, va_list va);
    736 
    737     void                        setVMRuntimeErrorCallbackF(uint32_t fFatal, const char *pszErrorId, const char *pszFormat, ...);
    738     static DECLCALLBACK(void)   setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
    739                                                           const char *pszErrorId, const char *pszFormat, va_list va);
    740 
    741     HRESULT                     captureUSBDevices(PUVM pUVM);
    742     void                        detachAllUSBDevices(bool aDone);
    743 
    744     static DECLCALLBACK(int)   powerUpThread(RTTHREAD Thread, void *pvUser);
    745     static DECLCALLBACK(int)   saveStateThread(RTTHREAD Thread, void *pvUser);
    746     static DECLCALLBACK(int)   powerDownThread(RTTHREAD Thread, void *pvUser);
    747 
    748     static DECLCALLBACK(int)    vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
    749     static DECLCALLBACK(void)   vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
    750     static DECLCALLBACK(void)   vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
    751     static DECLCALLBACK(void)   vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
    752     static DECLCALLBACK(void)   vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
    753     static DECLCALLBACK(void)   vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
    754 
    755     static DECLCALLBACK(void *) drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID);
    756     static DECLCALLBACK(void)   drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
    757     static DECLCALLBACK(int)    drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
    758     static DECLCALLBACK(void)   drvStatus_Destruct(PPDMDRVINS pDrvIns);
    759     static DECLCALLBACK(int)    drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
     726                                                   bool fSilent);
     727    static DECLCALLBACK(int) i_detachStorageDevice(Console *pThis,
     728                                                   PUVM pUVM,
     729                                                   const char *pcszDevice,
     730                                                   unsigned uInstance,
     731                                                   StorageBus_T enmBus,
     732                                                   IMediumAttachment *aMediumAtt,
     733                                                   bool fSilent);
     734    HRESULT i_doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
     735    HRESULT i_doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM, bool fSilent);
     736
     737    static DECLCALLBACK(int)    i_fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser);
     738
     739    static DECLCALLBACK(int)    i_stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
     740
     741    static DECLCALLBACK(void)   i_genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
     742                                                            const char *pszErrorFmt, va_list va);
     743
     744    void                        i_setVMRuntimeErrorCallbackF(uint32_t fFatal, const char *pszErrorId, const char *pszFormat, ...);
     745    static DECLCALLBACK(void)   i_setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
     746                                                            const char *pszErrorId, const char *pszFormat, va_list va);
     747
     748    HRESULT                     i_captureUSBDevices(PUVM pUVM);
     749    void                        i_detachAllUSBDevices(bool aDone);
     750
     751    static DECLCALLBACK(int)    i_powerUpThread(RTTHREAD Thread, void *pvUser);
     752    static DECLCALLBACK(int)    i_saveStateThread(RTTHREAD Thread, void *pvUser);
     753    static DECLCALLBACK(int)    i_powerDownThread(RTTHREAD Thread, void *pvUser);
     754
     755    static DECLCALLBACK(int)    i_vmm2User_SaveState(PCVMM2USERMETHODS pThis, PUVM pUVM);
     756    static DECLCALLBACK(void)   i_vmm2User_NotifyEmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
     757    static DECLCALLBACK(void)   i_vmm2User_NotifyEmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM, PUVMCPU pUVCpu);
     758    static DECLCALLBACK(void)   i_vmm2User_NotifyPdmtInit(PCVMM2USERMETHODS pThis, PUVM pUVM);
     759    static DECLCALLBACK(void)   i_vmm2User_NotifyPdmtTerm(PCVMM2USERMETHODS pThis, PUVM pUVM);
     760    static DECLCALLBACK(void)   i_vmm2User_NotifyResetTurnedIntoPowerOff(PCVMM2USERMETHODS pThis, PUVM pUVM);
     761
     762    static DECLCALLBACK(void *) i_drvStatus_QueryInterface(PPDMIBASE pInterface, const char *pszIID);
     763    static DECLCALLBACK(void)   i_drvStatus_UnitChanged(PPDMILEDCONNECTORS pInterface, unsigned iLUN);
     764    static DECLCALLBACK(int)    i_drvStatus_MediumEjected(PPDMIMEDIANOTIFY pInterface, unsigned iLUN);
     765    static DECLCALLBACK(void)   i_drvStatus_Destruct(PPDMDRVINS pDrvIns);
     766    static DECLCALLBACK(int)    i_drvStatus_Construct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
    760767
    761768    int mcAudioRefs;
    … …  
    767774    static uint32_t sSSMConsoleVer;
    768775
    769     HRESULT loadDataFromSavedState();
    770     int loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version);
    771 
    772     static DECLCALLBACK(void)   saveStateFileExec(PSSMHANDLE pSSM, void *pvUser);
    773     static DECLCALLBACK(int)    loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
     776    HRESULT i_loadDataFromSavedState();
     777    int i_loadStateFileExecInternal(PSSMHANDLE pSSM, uint32_t u32Version);
     778
     779    static DECLCALLBACK(void)   i_saveStateFileExec(PSSMHANDLE pSSM, void *pvUser);
     780    static DECLCALLBACK(int)    i_loadStateFileExec(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
    774781
    775782#ifdef VBOX_WITH_GUEST_PROPS
    776     static DECLCALLBACK(int)    doGuestPropNotification(void *pvExtension, uint32_t, void *pvParms, uint32_t cbParms);
    777     HRESULT                     doEnumerateGuestProperties(CBSTR aPatterns,
    778                                                            ComSafeArrayOut(BSTR, aNames),
    779                                                            ComSafeArrayOut(BSTR, aValues),
    780                                                            ComSafeArrayOut(LONG64, aTimestamps),
    781                                                            ComSafeArrayOut(BSTR, aFlags));
    782 
    783     void guestPropertiesHandleVMReset(void);
    784     bool guestPropertiesVRDPEnabled(void);
    785     void guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain);
    786     void guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
    787     void guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
    788     void guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
    789     void guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
    790     void guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
    791     void guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
    792     void guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
    793 #endif
    794 
    795     bool isResetTurnedIntoPowerOff(void);
     783    static DECLCALLBACK(int)    i_doGuestPropNotification(void *pvExtension, uint32_t, void *pvParms, uint32_t cbParms);
     784    HRESULT                     i_doEnumerateGuestProperties(CBSTR aPatterns,
     785                                                             ComSafeArrayOut(BSTR, aNames),
     786                                                             ComSafeArrayOut(BSTR, aValues),
     787                                                             ComSafeArrayOut(LONG64, aTimestamps),
     788                                                             ComSafeArrayOut(BSTR, aFlags));
     789
     790    void i_guestPropertiesHandleVMReset(void);
     791    bool i_guestPropertiesVRDPEnabled(void);
     792    void i_guestPropertiesVRDPUpdateLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain);
     793    void i_guestPropertiesVRDPUpdateActiveClient(uint32_t u32ClientId);
     794    void i_guestPropertiesVRDPUpdateClientAttach(uint32_t u32ClientId, bool fAttached);
     795    void i_guestPropertiesVRDPUpdateNameChange(uint32_t u32ClientId, const char *pszName);
     796    void i_guestPropertiesVRDPUpdateIPAddrChange(uint32_t u32ClientId, const char *pszIPAddr);
     797    void i_guestPropertiesVRDPUpdateLocationChange(uint32_t u32ClientId, const char *pszLocation);
     798    void i_guestPropertiesVRDPUpdateOtherInfoChange(uint32_t u32ClientId, const char *pszOtherInfo);
     799    void i_guestPropertiesVRDPUpdateDisconnect(uint32_t u32ClientId);
     800#endif
     801
     802    bool i_isResetTurnedIntoPowerOff(void);
    796803
    797804    /** @name Disk encryption support
    798805     * @{ */
    799     HRESULT consoleParseDiskEncryption(const char *psz, const char **ppszEnd);
    800     HRESULT configureEncryptionForDisk(const char *pszUuid, const uint8_t *pbKey, size_t cbKey);
    801     int consoleParseKeyValue(const char *psz, const char **ppszEnd,
    802                              char **ppszKey, char **ppszVal);
     806    HRESULT i_consoleParseDiskEncryption(const char *psz, const char **ppszEnd);
     807    HRESULT i_configureEncryptionForDisk(const char *pszUuid, const uint8_t *pbKey, size_t cbKey);
     808    int i_consoleParseKeyValue(const char *psz, const char **ppszEnd,
     809                               char **ppszKey, char **ppszVal);
    803810    /** @} */
    804811
    805812    /** @name Teleporter support
    806813     * @{ */
    807     static DECLCALLBACK(int)    teleporterSrcThreadWrapper(RTTHREAD hThread, void *pvUser);
    808     HRESULT                     teleporterSrc(TeleporterStateSrc *pState);
    809     HRESULT                     teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich, const char *pszNAckMsg = NULL);
    810     HRESULT                     teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck = true);
    811     HRESULT                     teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused,
     814    static DECLCALLBACK(int)    i_teleporterSrcThreadWrapper(RTTHREAD hThread, void *pvUser);
     815    HRESULT                     i_teleporterSrc(TeleporterStateSrc *pState);
     816    HRESULT                     i_teleporterSrcReadACK(TeleporterStateSrc *pState, const char *pszWhich, const char *pszNAckMsg = NULL);
     817    HRESULT                     i_teleporterSrcSubmitCommand(TeleporterStateSrc *pState, const char *pszCommand, bool fWaitForAck = true);
     818    HRESULT                     i_teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused,
    812819                                              Progress *pProgress, bool *pfPowerOffOnFailure);
    813     static DECLCALLBACK(int)    teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
     820    static DECLCALLBACK(int)    i_teleporterTrgServeConnection(RTSOCKET Sock, void *pvUser);
    814821    /** @} */
    815822

  • trunk/src/VBox/Main/src-all/ExtPackManagerImpl.cpp

    r50914 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
    … …  
    15511551
    15521552    Console *pCon = (Console *)pConsole;
    1553     return pCon->hgcmLoadService(pszServiceLibrary, pszServiceName);
     1553    return pCon->i_hgcmLoadService(pszServiceLibrary, pszServiceName);
    15541554#else
    15551555    NOREF(pHlp); NOREF(pConsole); NOREF(pszServiceLibrary); NOREF(pszServiceName);

  • 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