Changeset 49795 in vbox for trunk/src

Timestamp:

Dec 5, 2013 6:53:18 PM (11 years ago)

Author:

vboxsync

Message:

6813 - stage 3 rev 1

Location:

trunk/src/VBox/Main

Files:

• include/MediumImpl.h (modified) (4 diffs)
• src-server/ApplianceImplExport.cpp (modified) (1 diff)
• src-server/ApplianceImplImport.cpp (modified) (4 diffs)
• src-server/HostImpl.cpp (modified) (6 diffs)
• src-server/MachineImpl.cpp (modified) (68 diffs)
• src-server/MachineImplCloneVM.cpp (modified) (11 diffs)
• src-server/MediumImpl.cpp (modified) (312 diffs)
• src-server/MediumLock.cpp (modified) (1 diff)
• src-server/Performance.cpp (modified) (1 diff)
• src-server/SerialPortImpl.cpp (modified) (1 diff)
• src-server/SnapshotImpl.cpp (modified) (48 diffs)
• src-server/TokenImpl.cpp (modified) (1 diff)
• src-server/VirtualBoxImpl.cpp (modified) (18 diffs)
• src-server/xpcom/server.cpp (modified) (1 diff)

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

@@ -22 +22 @@
 
 #include <VBox/vd.h>
-
-#include "VirtualBoxBase.h"
-#include "MediumLock.h"
-
+#include "MediumWrap.h"
 class Progress;
 class MediumFormat;
+class MediumLockList;
 
 namespace settings
@@ -40 +38 @@
  */
 class ATL_NO_VTABLE Medium :
-    public VirtualBoxBase,
-    VBOX_SCRIPTABLE_IMPL(IMedium)
+    public MediumWrap
 {
 public:
-    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Medium, IMedium)
-
-    DECLARE_NOT_AGGREGATABLE(Medium)
-
-    DECLARE_PROTECT_FINAL_CONSTRUCT()
-
-    BEGIN_COM_MAP(Medium)
-        VBOX_DEFAULT_INTERFACE_ENTRIES(IMedium)
-    END_COM_MAP()
-
     DECLARE_EMPTY_CTOR_DTOR(Medium)
 
@@ -96 +83 @@
     void uninit();
 
-    void deparent();
-    void setParent(const ComObjPtr<Medium> &pParent);
-
-    // IMedium properties
-    STDMETHOD(COMGETTER(Id))(BSTR *aId);
-    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
-    STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
-    STDMETHOD(COMGETTER(State))(MediumState_T *aState);
-    STDMETHOD(COMGETTER(Variant))(ComSafeArrayOut(MediumVariant_T, aVariant));
-    STDMETHOD(COMGETTER(Location))(BSTR *aLocation);
-    STDMETHOD(COMGETTER(Name))(BSTR *aName);
-    STDMETHOD(COMGETTER(DeviceType))(DeviceType_T *aDeviceType);
-    STDMETHOD(COMGETTER(HostDrive))(BOOL *aHostDrive);
-    STDMETHOD(COMGETTER(Size))(LONG64 *aSize);
-    STDMETHOD(COMGETTER(Format))(BSTR *aFormat);
-    STDMETHOD(COMGETTER(MediumFormat))(IMediumFormat **aMediumFormat);
-    STDMETHOD(COMGETTER(Type))(MediumType_T *aType);
-    STDMETHOD(COMSETTER(Type))(MediumType_T aType);
-    STDMETHOD(COMGETTER(AllowedTypes))(ComSafeArrayOut(MediumType_T, aAllowedTypes));
-    STDMETHOD(COMGETTER(Parent))(IMedium **aParent);
-    STDMETHOD(COMGETTER(Children))(ComSafeArrayOut(IMedium *, aChildren));
-    STDMETHOD(COMGETTER(Base))(IMedium **aBase);
-    STDMETHOD(COMGETTER(ReadOnly))(BOOL *aReadOnly);
-    STDMETHOD(COMGETTER(LogicalSize))(LONG64 *aLogicalSize);
-    STDMETHOD(COMGETTER(AutoReset))(BOOL *aAutoReset);
-    STDMETHOD(COMSETTER(AutoReset))(BOOL aAutoReset);
-    STDMETHOD(COMGETTER(LastAccessError))(BSTR *aLastAccessError);
-    STDMETHOD(COMGETTER(MachineIds))(ComSafeArrayOut(BSTR, aMachineIds));
-
-    // IMedium methods
-    STDMETHOD(SetIds)(BOOL aSetImageId, IN_BSTR aImageId,
-                      BOOL aSetParentId, IN_BSTR aParentId);
-    STDMETHOD(RefreshState)(MediumState_T *aState);
-    STDMETHOD(GetSnapshotIds)(IN_BSTR aMachineId,
-                              ComSafeArrayOut(BSTR, aSnapshotIds));
-    STDMETHOD(LockRead)(IToken **aToken);
-    STDMETHOD(LockWrite)(IToken **aToken);
-    STDMETHOD(Close)();
-    STDMETHOD(GetProperty)(IN_BSTR aName, BSTR *aValue);
-    STDMETHOD(SetProperty)(IN_BSTR aName, IN_BSTR aValue);
-    STDMETHOD(GetProperties)(IN_BSTR aNames,
-                             ComSafeArrayOut(BSTR, aReturnNames),
-                             ComSafeArrayOut(BSTR, aReturnValues));
-    STDMETHOD(SetProperties)(ComSafeArrayIn(IN_BSTR, aNames),
-                             ComSafeArrayIn(IN_BSTR, aValues));
-    STDMETHOD(CreateBaseStorage)(LONG64 aLogicalSize,
-                                 ComSafeArrayIn(MediumVariant_T, aVariant),
-                                 IProgress **aProgress);
-    STDMETHOD(DeleteStorage)(IProgress **aProgress);
-    STDMETHOD(CreateDiffStorage)(IMedium *aTarget,
-                                 ComSafeArrayIn(MediumVariant_T, aVariant),
-                                 IProgress **aProgress);
-    STDMETHOD(MergeTo)(IMedium *aTarget, IProgress **aProgress);
-    STDMETHOD(CloneTo)(IMedium *aTarget, ComSafeArrayIn(MediumVariant_T, aVariant),
-                        IMedium *aParent, IProgress **aProgress);
-    STDMETHOD(CloneToBase)(IMedium *aTarget, ComSafeArrayIn(MediumVariant_T, aVariant),
-                           IProgress **aProgress);
-    STDMETHOD(SetLocation)(IN_BSTR aLocation, IProgress **aProgress);
-    STDMETHOD(Compact)(IProgress **aProgress);
-    STDMETHOD(Resize)(LONG64 aLogicalSize, IProgress **aProgress);
-    STDMETHOD(Reset)(IProgress **aProgress);
+    void i_deparent();
+    void i_setParent(const ComObjPtr<Medium> &pParent);
 
     // unsafe methods for internal purposes only (ensure there is
     // a caller and a read lock before calling them!)
-    const ComObjPtr<Medium>& getParent() const;
-    const MediaList& getChildren() const;
-
-    const Guid& getId() const;
-    MediumState_T getState() const;
-    MediumVariant_T getVariant() const;
-    bool isHostDrive() const;
-    const Utf8Str& getLocationFull() const;
-    const Utf8Str& getFormat() const;
-    const ComObjPtr<MediumFormat> & getMediumFormat() const;
-    bool isMediumFormatFile() const;
-    uint64_t getSize() const;
-    DeviceType_T getDeviceType() const;
-    MediumType_T getType() const;
-    Utf8Str getName();
+    const ComObjPtr<Medium>& i_getParent() const;
+    const MediaList& i_getChildren() const;
+
+    const Guid& i_getId() const;
+    MediumState_T i_getState() const;
+    MediumVariant_T i_getVariant() const;
+    bool i_isHostDrive() const;
+    const Utf8Str& i_getLocationFull() const;
+    const Utf8Str& i_getFormat() const;
+    const ComObjPtr<MediumFormat> & i_getMediumFormat() const;
+    bool i_isMediumFormatFile() const;
+    uint64_t i_getSize() const;
+    DeviceType_T i_getDeviceType() const;
+    MediumType_T i_getType() const;
+    Utf8Str i_getName();
 
     /* handles caller/locking itself */
-    bool addRegistry(const Guid& id, bool fRecurse);
+    bool i_addRegistry(const Guid& id, bool fRecurse);
     /* handles caller/locking itself */
-    bool removeRegistry(const Guid& id, bool fRecurse);
-    bool isInRegistry(const Guid& id);
-    bool getFirstRegistryMachineId(Guid &uuid) const;
-    void markRegistriesModified();
-
-    HRESULT setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
-
-    HRESULT addBackReference(const Guid &aMachineId,
-                             const Guid &aSnapshotId = Guid::Empty);
-    HRESULT removeBackReference(const Guid &aMachineId,
-                                const Guid &aSnapshotId = Guid::Empty);
-
-
-    const Guid* getFirstMachineBackrefId() const;
-    const Guid* getAnyMachineBackref() const;
-    const Guid* getFirstMachineBackrefSnapshotId() const;
-    size_t getMachineBackRefCount() const;
+    bool i_removeRegistry(const Guid& id, bool fRecurse);
+    bool i_isInRegistry(const Guid& id);
+    bool i_getFirstRegistryMachineId(Guid &uuid) const;
+    void i_markRegistriesModified();
+
+    HRESULT i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue);
+
+    HRESULT i_addBackReference(const Guid &aMachineId,
+                               const Guid &aSnapshotId = Guid::Empty);
+    HRESULT i_removeBackReference(const Guid &aMachineId,
+                                  const Guid &aSnapshotId = Guid::Empty);
+
+
+    const Guid* i_getFirstMachineBackrefId() const;
+    const Guid* i_getAnyMachineBackref() const;
+    const Guid* i_getFirstMachineBackrefSnapshotId() const;
+    size_t i_getMachineBackRefCount() const;
 
 #ifdef DEBUG
-    void dumpBackRefs();
+    void i_dumpBackRefs();
 #endif
 
-    HRESULT updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
-
-    ComObjPtr<Medium> getBase(uint32_t *aLevel = NULL);
-
-    bool isReadOnly();
-    void updateId(const Guid &id);
-
-    HRESULT saveSettings(settings::Medium &data,
-                         const Utf8Str &strHardDiskFolder);
-
-    HRESULT createMediumLockList(bool fFailIfInaccessible,
-                                 bool fMediumLockWrite,
-                                 Medium *pToBeParent,
-                                 MediumLockList &mediumLockList);
-
-    HRESULT createDiffStorage(ComObjPtr<Medium> &aTarget,
-                              MediumVariant_T aVariant,
-                              MediumLockList *pMediumLockList,
-                              ComObjPtr<Progress> *aProgress,
-                              bool aWait);
-    Utf8Str getPreferredDiffFormat();
-
-    HRESULT close(AutoCaller &autoCaller);
-    HRESULT unlockRead(MediumState_T *aState);
-    HRESULT unlockWrite(MediumState_T *aState);
-    HRESULT deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait);
-    HRESULT markForDeletion();
-    HRESULT unmarkForDeletion();
-    HRESULT markLockedForDeletion();
-    HRESULT unmarkLockedForDeletion();
-
-    HRESULT queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
-                                         bool &fMergeForward);
-
-    HRESULT prepareMergeTo(const ComObjPtr<Medium> &pTarget,
-                           const Guid *aMachineId,
-                           const Guid *aSnapshotId,
-                           bool fLockMedia,
-                           bool &fMergeForward,
-                           ComObjPtr<Medium> &pParentForTarget,
-                           MediumLockList * &aChildrenToReparent,
-                           MediumLockList * &aMediumLockList);
-    HRESULT mergeTo(const ComObjPtr<Medium> &pTarget,
-                    bool fMergeForward,
-                    const ComObjPtr<Medium> &pParentForTarget,
-                    MediumLockList *aChildrenToReparent,
-                    MediumLockList *aMediumLockList,
-                    ComObjPtr<Progress> *aProgress,
-                    bool aWait);
-    void cancelMergeTo(MediumLockList *aChildrenToReparent,
+    HRESULT i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath);
+
+    ComObjPtr<Medium> i_getBase(uint32_t *aLevel = NULL);
+
+    bool i_isReadOnly();
+    void i_updateId(const Guid &id);
+
+    HRESULT i_saveSettings(settings::Medium &data,
+                           const Utf8Str &strHardDiskFolder);
+
+    HRESULT i_createMediumLockList(bool fFailIfInaccessible,
+                                   bool fMediumLockWrite,
+                                   Medium *pToBeParent,
+                                   MediumLockList &mediumLockList);
+
+    HRESULT i_createDiffStorage(ComObjPtr<Medium> &aTarget,
+                                MediumVariant_T aVariant,
+                                MediumLockList *pMediumLockList,
+                                ComObjPtr<Progress> *aProgress,
+                                bool aWait);
+    Utf8Str i_getPreferredDiffFormat();
+
+    HRESULT i_close(AutoCaller &autoCaller);
+    HRESULT i_unlockRead(MediumState_T *aState);
+    HRESULT i_unlockWrite(MediumState_T *aState);
+    HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait);
+    HRESULT i_markForDeletion();
+    HRESULT i_unmarkForDeletion();
+    HRESULT i_markLockedForDeletion();
+    HRESULT i_unmarkLockedForDeletion();
+
+    HRESULT i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
+                                           bool &fMergeForward);
+
+    HRESULT i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
+                             const Guid *aMachineId,
+                             const Guid *aSnapshotId,
+                             bool fLockMedia,
+                             bool &fMergeForward,
+                             ComObjPtr<Medium> &pParentForTarget,
+                             MediumLockList * &aChildrenToReparent,
+                             MediumLockList * &aMediumLockList);
+    HRESULT i_mergeTo(const ComObjPtr<Medium> &pTarget,
+                      bool fMergeForward,
+                      const ComObjPtr<Medium> &pParentForTarget,
+                      MediumLockList *aChildrenToReparent,
+                      MediumLockList *aMediumLockList,
+                      ComObjPtr<Progress> *aProgress,
+                      bool aWait);
+    void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
                        MediumLockList *aMediumLockList);
 
-    HRESULT fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
-
-    HRESULT exportFile(const char *aFilename,
-                       const ComObjPtr<MediumFormat> &aFormat,
-                       MediumVariant_T aVariant,
-                       PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
-                       const ComObjPtr<Progress> &aProgress);
-    HRESULT importFile(const char *aFilename,
-                       const ComObjPtr<MediumFormat> &aFormat,
-                       MediumVariant_T aVariant,
-                       PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
-                       const ComObjPtr<Medium> &aParent,
-                       const ComObjPtr<Progress> &aProgress);
-
-    HRESULT cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
-                      const ComObjPtr<Medium> &aParent, IProgress **aProgress,
-                      uint32_t idxSrcImageSame, uint32_t idxDstImageSame);
+    HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
+
+    HRESULT i_exportFile(const char *aFilename,
+                         const ComObjPtr<MediumFormat> &aFormat,
+                         MediumVariant_T aVariant,
+                         PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+                         const ComObjPtr<Progress> &aProgress);
+    HRESULT i_importFile(const char *aFilename,
+                        const ComObjPtr<MediumFormat> &aFormat,
+                        MediumVariant_T aVariant,
+                        PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+                        const ComObjPtr<Medium> &aParent,
+                        const ComObjPtr<Progress> &aProgress);
+
+    HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
+                        const ComObjPtr<Medium> &aParent, IProgress **aProgress,
+                        uint32_t idxSrcImageSame, uint32_t idxDstImageSame);
 
 private:
 
-    HRESULT queryInfo(bool fSetImageId, bool fSetParentId);
-
-    HRESULT canClose();
-    HRESULT unregisterWithVirtualBox();
-
-    HRESULT setStateError();
-
-    HRESULT setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
-    HRESULT setFormat(const Utf8Str &aFormat);
-
-    VDTYPE convertDeviceType();
-    DeviceType_T convertToDeviceType(VDTYPE enmType);
-
-    Utf8Str vdError(int aVRC);
-
-    static DECLCALLBACK(void) vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
-                                          const char *pszFormat, va_list va);
-
-    static DECLCALLBACK(bool) vdConfigAreKeysValid(void *pvUser,
-                                                   const char *pszzValid);
-    static DECLCALLBACK(int) vdConfigQuerySize(void *pvUser, const char *pszName,
-                                               size_t *pcbValue);
-    static DECLCALLBACK(int) vdConfigQuery(void *pvUser, const char *pszName,
-                                           char *pszValue, size_t cchValue);
-
-    static DECLCALLBACK(int) vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
-    static DECLCALLBACK(int) vdTcpSocketDestroy(VDSOCKET Sock);
-    static DECLCALLBACK(int) vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort);
-    static DECLCALLBACK(int) vdTcpClientClose(VDSOCKET Sock);
-    static DECLCALLBACK(bool) vdTcpIsClientConnected(VDSOCKET Sock);
-    static DECLCALLBACK(int) vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
-    static DECLCALLBACK(int) vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
-    static DECLCALLBACK(int) vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
-    static DECLCALLBACK(int) vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
-    static DECLCALLBACK(int) vdTcpFlush(VDSOCKET Sock);
-    static DECLCALLBACK(int) vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
-    static DECLCALLBACK(int) vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
-    static DECLCALLBACK(int) vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
+    // wrapped IMedium properties
+    HRESULT getId(com::Guid &aId);
+    HRESULT getDescription(com::Utf8Str &aDescription);
+    HRESULT setDescription(const com::Utf8Str &aDescription);
+    HRESULT getState(MediumState_T *aState);
+    HRESULT getVariant(std::vector<MediumVariant_T> &aVariant);
+    HRESULT getLocation(com::Utf8Str &aLocation);
+    HRESULT getName(com::Utf8Str &aName);
+    HRESULT getDeviceType(DeviceType_T *aDeviceType);
+    HRESULT getHostDrive(BOOL *aHostDrive);
+    HRESULT getSize(LONG64 *aSize);
+    HRESULT getFormat(com::Utf8Str &aFormat);
+    HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat);
+    HRESULT getType(MediumType_T *aType);
+    HRESULT setType(MediumType_T aType);
+    HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes);
+    HRESULT getParent(ComPtr<IMedium> &aParent);
+    HRESULT getChildren(std::vector<ComPtr<IMedium> > &aChildren);
+    HRESULT getBase(ComPtr<IMedium> &aBase);
+    HRESULT getReadOnly(BOOL *aReadOnly);
+    HRESULT getLogicalSize(LONG64 *aLogicalSize);
+    HRESULT getAutoReset(BOOL *aAutoReset);
+    HRESULT setAutoReset(BOOL aAutoReset);
+    HRESULT getLastAccessError(com::Utf8Str &aLastAccessError);
+    HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds);
+
+    // wrapped IMedium methods
+    HRESULT setIds(BOOL aSetImageId,
+                   const com::Guid &aImageId,
+                   BOOL aSetParentId,
+                   const com::Guid &aParentId);
+    HRESULT refreshState(MediumState_T *aState);
+    HRESULT getSnapshotIds(const com::Guid &aMachineId,
+                           std::vector<com::Guid> &aSnapshotIds);
+    HRESULT lockRead(ComPtr<IToken> &aToken);
+    HRESULT lockWrite(ComPtr<IToken> &aToken);
+    HRESULT close();
+    HRESULT getProperty(const com::Utf8Str &aName,
+                        com::Utf8Str &aValue);
+    HRESULT setProperty(const com::Utf8Str &aName,
+                        const com::Utf8Str &aValue);
+    HRESULT getProperties(const com::Utf8Str &aNames,
+                          std::vector<com::Utf8Str> &aReturnNames,
+                          std::vector<com::Utf8Str> &aReturnValues);
+    HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
+                          const std::vector<com::Utf8Str> &aValues);
+    HRESULT createBaseStorage(LONG64 aLogicalSize,
+                              const std::vector<MediumVariant_T> &aVariant,
+                              ComPtr<IProgress> &aProgress);
+    HRESULT deleteStorage(ComPtr<IProgress> &aProgress);
+    HRESULT createDiffStorage(const ComPtr<IMedium> &aTarget,
+                              const std::vector<MediumVariant_T> &aVariant,
+                              ComPtr<IProgress> &aProgress);
+    HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
+                    ComPtr<IProgress> &aProgress);
+    HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
+                    const std::vector<MediumVariant_T> &aVariant,
+                    const ComPtr<IMedium> &aParent,
+                    ComPtr<IProgress> &aProgress);
+    HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
+                        const std::vector<MediumVariant_T> &aVariant,
+                        ComPtr<IProgress> &aProgress);
+    HRESULT setLocation(const com::Utf8Str &aLocation,
+                        ComPtr<IProgress> &aProgress);
+    HRESULT compact(ComPtr<IProgress> &aProgress);
+    HRESULT resize(LONG64 aLogicalSize,
+                   ComPtr<IProgress> &aProgress);
+    HRESULT reset(ComPtr<IProgress> &aProgress);
+
+    // Private internal nmethods
+    HRESULT i_queryInfo(bool fSetImageId, bool fSetParentId);
+    HRESULT i_canClose();
+    HRESULT i_unregisterWithVirtualBox();
+    HRESULT i_setStateError();
+    HRESULT i_setLocation(const Utf8Str &aLocation, const Utf8Str &aFormat = Utf8Str::Empty);
+    HRESULT i_setFormat(const Utf8Str &aFormat);
+    VDTYPE i_convertDeviceType();
+    DeviceType_T i_convertToDeviceType(VDTYPE enmType);
+    Utf8Str i_vdError(int aVRC);
+
+    static DECLCALLBACK(void) i_vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
+                                            const char *pszFormat, va_list va);
+    static DECLCALLBACK(bool) i_vdConfigAreKeysValid(void *pvUser,
+                                                     const char *pszzValid);
+    static DECLCALLBACK(int) i_vdConfigQuerySize(void *pvUser, const char *pszName,
+                                                 size_t *pcbValue);
+    static DECLCALLBACK(int) i_vdConfigQuery(void *pvUser, const char *pszName,
+                                             char *pszValue, size_t cchValue);
+    static DECLCALLBACK(int) i_vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock);
+    static DECLCALLBACK(int) i_vdTcpSocketDestroy(VDSOCKET Sock);
+    static DECLCALLBACK(int) i_vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort);
+    static DECLCALLBACK(int) i_vdTcpClientClose(VDSOCKET Sock);
+    static DECLCALLBACK(bool) i_vdTcpIsClientConnected(VDSOCKET Sock);
+    static DECLCALLBACK(int) i_vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies);
+    static DECLCALLBACK(int) i_vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead);
+    static DECLCALLBACK(int) i_vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer);
+    static DECLCALLBACK(int) i_vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf);
+    static DECLCALLBACK(int) i_vdTcpFlush(VDSOCKET Sock);
+    static DECLCALLBACK(int) i_vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable);
+    static DECLCALLBACK(int) i_vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr);
+    static DECLCALLBACK(int) i_vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr);
 
     class Task;
@@ -335 +326 @@
     friend class ImportTask;
 
-    HRESULT startThread(Medium::Task *pTask);
-    HRESULT runNow(Medium::Task *pTask);
-
-    HRESULT taskCreateBaseHandler(Medium::CreateBaseTask &task);
-    HRESULT taskCreateDiffHandler(Medium::CreateDiffTask &task);
-    HRESULT taskMergeHandler(Medium::MergeTask &task);
-    HRESULT taskCloneHandler(Medium::CloneTask &task);
-    HRESULT taskDeleteHandler(Medium::DeleteTask &task);
-    HRESULT taskResetHandler(Medium::ResetTask &task);
-    HRESULT taskCompactHandler(Medium::CompactTask &task);
-    HRESULT taskResizeHandler(Medium::ResizeTask &task);
-    HRESULT taskExportHandler(Medium::ExportTask &task);
-    HRESULT taskImportHandler(Medium::ImportTask &task);
+    HRESULT i_startThread(Medium::Task *pTask);
+    HRESULT i_runNow(Medium::Task *pTask);
+
+    HRESULT i_taskCreateBaseHandler(Medium::CreateBaseTask &task);
+    HRESULT i_taskCreateDiffHandler(Medium::CreateDiffTask &task);
+    HRESULT i_taskMergeHandler(Medium::MergeTask &task);
+    HRESULT i_taskCloneHandler(Medium::CloneTask &task);
+    HRESULT i_taskDeleteHandler(Medium::DeleteTask &task);
+    HRESULT i_taskResetHandler(Medium::ResetTask &task);
+    HRESULT i_taskCompactHandler(Medium::CompactTask &task);
+    HRESULT i_taskResizeHandler(Medium::ResizeTask &task);
+    HRESULT i_taskExportHandler(Medium::ExportTask &task);
+    HRESULT i_taskImportHandler(Medium::ImportTask &task);
 
     struct Data;            // opaque data struct, defined in MediumImpl.cpp

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

@@ -2135 +2135 @@
                     if (FAILED(rc)) throw rc;
 
-                    rc = pSourceDisk->exportFile(strTargetFilePath.c_str(),
-                                                 format,
-                                                 MediumVariant_VmdkStreamOptimized,
-                                                 pIfIo,
-                                                 pStorage,
-                                                 pProgress2);
+                    rc = pSourceDisk->i_exportFile(strTargetFilePath.c_str(),
+                                                   format,
+                                                   MediumVariant_VmdkStreamOptimized,
+                                                   pIfIo,
+                                                   pStorage,
+                                                   pProgress2);
                     if (FAILED(rc)) throw rc;
 

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

@@ -1566 +1566 @@
         /*
          * Restoring original UUID from OVF description file.
-         * During import VB creates new UUIDs for imported images and 
+         * During import VB creates new UUIDs for imported images and
          * assigns them to the images. In case of failure we have to restore
          * the original UUIDs because those new UUIDs are obsolete now and
@@ -1792 +1792 @@
         /*
          * Restoring original UUID from OVF description file.
-         * During import VB creates new UUIDs for imported images and 
+         * During import VB creates new UUIDs for imported images and
          * assigns them to the images. In case of failure we have to restore
          * the original UUIDs because those new UUIDs are obsolete now and
@@ -2488 +2488 @@
                     /* Clone the source disk image */
                     ComObjPtr<Medium> nullParent;
-                    rc = pTargetHD->importFile(strSrcFilePath.c_str(),
-                                               srcFormat,
-                                               MediumVariant_Standard,
-                                               pCallbacks, pRealUsedStorage,
-                                               nullParent,
-                                               pProgress);
+                    rc = pTargetHD->i_importFile(strSrcFilePath.c_str(),
+                                                 srcFormat,
+                                                 MediumVariant_Standard,
+                                                 pCallbacks, pRealUsedStorage,
+                                                 nullParent,
+                                                 pProgress);
                     if (FAILED(rc)) throw rc;
 
@@ -3764 +3764 @@
 
                 /*
-                 * 1. saving original UUID for restoring in case of failure. 
+                 * 1. saving original UUID for restoring in case of failure.
                  * 2. replacement of original UUID by new UUID in the current VM config (settings::MachineConfigFile).
                  */

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

@@ -1857 +1857 @@
             {
                 Medium *pCached = *itCached;
-                const Utf8Str strLocationCached = pCached->getLocationFull();
+                const Utf8Str strLocationCached = pCached->i_getLocationFull();
                 bool fFound = false;
                 for (MediaList::iterator itNew = llNew.begin();
@@ -1864 +1864 @@
                 {
                     Medium *pNew = *itNew;
-                    const Utf8Str strLocationNew = pNew->getLocationFull();
+                    const Utf8Str strLocationNew = pNew->i_getLocationFull();
                     if (strLocationNew == strLocationCached)
                     {
@@ -1883 +1883 @@
             {
                 Medium *pNew = *itNew;
-                const Utf8Str strLocationNew = pNew->getLocationFull();
+                const Utf8Str strLocationNew = pNew->i_getLocationFull();
                 bool fFound = false;
                 for (MediaList::iterator itCached = pllCached->begin();
@@ -1890 +1890 @@
                 {
                     Medium *pCached = *itCached;
-                    const Utf8Str strLocationCached = pCached->getLocationFull();
+                    const Utf8Str strLocationCached = pCached->i_getLocationFull();
                     if (strLocationNew == strLocationCached)
                     {
@@ -1939 +1939 @@
             AutoCaller mediumCaller(pThis);
             AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
-            if (pThis->getId() == uuid)
+            if (pThis->i_getId() == uuid)
             {
                 pMedium = pThis;
@@ -1979 +1979 @@
             AutoCaller mediumCaller(pThis);
             AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
-            if (pThis->getLocationFull() == strLocationFull)
+            if (pThis->i_getLocationFull() == strLocationFull)
             {
                 pMedium = pThis;

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

@@ -4086 +4086 @@
             return setError(VBOX_E_OBJECT_IN_USE,
                             tr("Medium '%s' is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
-                            pMedium->getLocationFull().c_str(),
+                            pMedium->i_getLocationFull().c_str(),
                             aControllerPort,
                             aDevice,
@@ -4111 +4111 @@
         return setError(VBOX_E_OBJECT_IN_USE,
                         tr("Medium '%s' is already attached to this virtual machine"),
-                        medium->getLocationFull().c_str());
+                        medium->i_getLocationFull().c_str());
 
     if (!medium.isNull())
     {
-        MediumType_T mtype = medium->getType();
+        MediumType_T mtype = medium->i_getType();
         // MediumType_Readonly is also new, but only applies to DVDs and floppies.
         // For DVDs it's not written to the config file, so needs no global config
@@ -4133 +4133 @@
             // global registry:
             const Guid &uuidGlobalRegistry = mParent->getGlobalRegistryId();
-            if (    medium->isInRegistry(uuidGlobalRegistry)
+            if (    medium->i_isInRegistry(uuidGlobalRegistry)
                  || !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
                )
@@ -4139 +4139 @@
                                 tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
                                    "to machines that were created with VirtualBox 4.0 or later"),
-                                medium->getLocationFull().c_str());
+                                medium->i_getLocationFull().c_str());
         }
     }
@@ -4145 +4145 @@
     bool fIndirect = false;
     if (!medium.isNull())
-        fIndirect = medium->isReadOnly();
+        fIndirect = medium->i_isReadOnly();
     bool associate = true;
 
@@ -4178 +4178 @@
                         MediumLockList *pMediumLockList(new MediumLockList());
 
-                        rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                          true /* fMediumLockWrite */,
-                                                          NULL,
-                                                          *pMediumLockList);
+                        rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                                            true /* fMediumLockWrite */,
+                                                            NULL,
+                                                            *pMediumLockList);
                         alock.acquire();
                         if (FAILED(rc))
@@ -4226 +4226 @@
          * hard disks. */
 
-        if (medium->getParent().isNull())
+        if (medium->i_getParent().isNull())
         {
             /* first, investigate the backup copy of the current hard disk
@@ -4249 +4249 @@
                         continue;
 
-                    if (pMedium->getBase(&level) == medium)
+                    if (pMedium->i_getBase(&level) == medium)
                     {
                         /* skip the hard disk if its currently attached (we
@@ -4277 +4277 @@
                                 MediumLockList *pMediumLockList(new MediumLockList());
 
-                                rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                                  true /* fMediumLockWrite */,
-                                                                  NULL,
-                                                                  *pMediumLockList);
+                                rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                                                    true /* fMediumLockWrite */,
+                                                                    NULL,
+                                                                    *pMediumLockList);
                                 alock.acquire();
                                 if (FAILED(rc))
@@ -4364 +4364 @@
 
                     uint32_t level = 0;
-                    if (pMedium->getBase(&level) == medium)
+                    if (pMedium->i_getBase(&level) == medium)
                     {
                         /* matched device, channel and bus (i.e. attached to the
@@ -4419 +4419 @@
         // store this diff in the same registry as the parent
         Guid uuidRegistryParent;
-        if (!medium->getFirstRegistryMachineId(uuidRegistryParent))
+        if (!medium->i_getFirstRegistryMachineId(uuidRegistryParent))
         {
             // parent image has no registry: this can happen if we're attaching a new immutable
@@ -4432 +4432 @@
             treeLock.acquire();
             mediumLock.acquire();
-            medium->getFirstRegistryMachineId(uuidRegistryParent);
+            medium->i_getFirstRegistryMachineId(uuidRegistryParent);
         }
         rc = diff->init(mParent,
-                        medium->getPreferredDiffFormat(),
+                        medium->i_getPreferredDiffFormat(),
                         strFullSnapshotFolder.append(RTPATH_SLASH_STR),
                         uuidRegistryParent);
@@ -4444 +4444 @@
         mediumLock.release();
         treeLock.release();
-        rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
-                                        true /* fMediumLockWrite */,
-                                        medium,
-                                        *pMediumLockList);
+        rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                          true /* fMediumLockWrite */,
+                                          medium,
+                                          *pMediumLockList);
         treeLock.acquire();
         mediumLock.acquire();
@@ -4460 +4460 @@
                 setError(rc,
                          tr("Could not lock medium when creating diff '%s'"),
-                         diff->getLocationFull().c_str());
+                         diff->i_getLocationFull().c_str());
             else
             {
@@ -4472 +4472 @@
                 alock.release();
 
-                rc = medium->createDiffStorage(diff,
-                                               MediumVariant_Standard,
-                                               pMediumLockList,
-                                               NULL /* aProgress */,
-                                               true /* aWait */);
+                rc = medium->i_createDiffStorage(diff,
+                                                 MediumVariant_Standard,
+                                                 pMediumLockList,
+                                                 NULL /* aProgress */,
+                                                 true /* aWait */);
 
                 alock.acquire();
@@ -4519 +4519 @@
     {
         // as the last step, associate the medium to the VM
-        rc = medium->addBackReference(mData->mUuid);
+        rc = medium->i_addBackReference(mData->mUuid);
         // here we can fail because of Deleting, or being in process of creating a Diff
         if (FAILED(rc)) return rc;
@@ -4547 +4547 @@
             MediumLockList *pMediumLockList(new MediumLockList());
 
-            rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
+            rc = medium->i_createMediumLockList(true /* fFailIfInaccessible */,
                                               true /* fMediumLockWrite */,
                                               NULL,
@@ -5090 +5090 @@
                                  aDevice);
         if (!oldmedium.isNull())
-            oldmedium->removeBackReference(mData->mUuid);
+            oldmedium->i_removeBackReference(mData->mUuid);
         if (!pMedium.isNull())
         {
-            pMedium->addBackReference(mData->mUuid);
+            pMedium->i_addBackReference(mData->mUuid);
 
             mediumLock.release();
@@ -5118 +5118 @@
     {
         if (!pMedium.isNull())
-            pMedium->removeBackReference(mData->mUuid);
+            pMedium->i_removeBackReference(mData->mUuid);
         pAttach = findAttachment(mMediaData->mAttachments,
                                  aControllerName,
@@ -5128 +5128 @@
         AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
         if (!oldmedium.isNull())
-            oldmedium->addBackReference(mData->mUuid);
+            oldmedium->i_addBackReference(mData->mUuid);
         pAttach->updateMedium(oldmedium);
     }
@@ -5697 +5697 @@
                 AutoCaller mac(pMedium);
                 if (FAILED(mac.rc())) throw mac.rc();
-                Utf8Str strLocation = pMedium->getLocationFull();
+                Utf8Str strLocation = pMedium->i_getLocationFull();
                 rc = task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
                 if (FAILED(rc)) throw rc;
@@ -5724 +5724 @@
                 pMedium->Close();
             }
-
         }
         setMachineState(oldState);
@@ -8824 +8823 @@
             if (pMedium.isNull())
                 continue;
-            HRESULT rc = pMedium->removeBackReference(mData->mUuid, getSnapshotId());
+            HRESULT rc = pMedium->i_removeBackReference(mData->mUuid, getSnapshotId());
             AssertComRC(rc);
         }
@@ -9702 +9701 @@
                 AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
 
-                if (medium->getType() == MediumType_Immutable)
+                if (medium->i_getType() == MediumType_Immutable)
                 {
                     if (isSnapshotMachine())
@@ -9708 +9707 @@
                                         tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
                                            "of the virtual machine '%s' ('%s')"),
-                                        medium->getLocationFull().c_str(),
+                                        medium->i_getLocationFull().c_str(),
                                         dev.uuid.raw(),
                                         puuidSnapshot->raw(),
@@ -9716 +9715 @@
                     return setError(E_FAIL,
                                     tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
+                                    medium->i_getLocationFull().c_str(),
                                     dev.uuid.raw(),
                                     mUserData->s.strName.c_str(),
@@ -9722 +9721 @@
                 }
 
-                if (medium->getType() == MediumType_MultiAttach)
+                if (medium->i_getType() == MediumType_MultiAttach)
                 {
                     if (isSnapshotMachine())
@@ -9728 +9727 @@
                                         tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
                                            "of the virtual machine '%s' ('%s')"),
-                                        medium->getLocationFull().c_str(),
+                                        medium->i_getLocationFull().c_str(),
                                         dev.uuid.raw(),
                                         puuidSnapshot->raw(),
@@ -9736 +9735 @@
                     return setError(E_FAIL,
                                     tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
+                                    medium->i_getLocationFull().c_str(),
                                     dev.uuid.raw(),
                                     mUserData->s.strName.c_str(),
@@ -9743 +9742 @@
 
                 if (    !isSnapshotMachine()
-                     && medium->getChildren().size() != 0
+                     && medium->i_getChildren().size() != 0
                    )
                     return setError(E_FAIL,
                                     tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
                                        "because it has %d differencing child hard disks"),
-                                    medium->getLocationFull().c_str(),
+                                    medium->i_getLocationFull().c_str(),
                                     dev.uuid.raw(),
                                     mUserData->s.strName.c_str(),
                                     mData->m_strConfigFileFull.c_str(),
-                                    medium->getChildren().size());
+                                    medium->i_getChildren().size());
 
                 if (findAttachment(mMediaData->mAttachments,
@@ -9758 +9757 @@
                     return setError(E_FAIL,
                                     tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
+                                    medium->i_getLocationFull().c_str(),
                                     dev.uuid.raw(),
                                     mUserData->s.strName.c_str(),
@@ -9769 +9768 @@
                 return setError(E_FAIL,
                                 tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
-                                medium->getLocationFull().c_str(),
+                                medium->i_getLocationFull().c_str(),
                                 mUserData->s.strName.c_str(),
                                 mData->m_strConfigFileFull.c_str());
@@ -9786 +9785 @@
                 return setError(E_FAIL,
                                 tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
-                                medium->getLocationFull().c_str(),
+                                medium->i_getLocationFull().c_str(),
                                 dev.strBwGroup.c_str(),
                                 mUserData->s.strName.c_str(),
@@ -9819 +9818 @@
 
             if (isSnapshotMachine())
-                rc = medium->addBackReference(mData->mUuid, *puuidSnapshot);
+                rc = medium->i_addBackReference(mData->mUuid, *puuidSnapshot);
             else
-                rc = medium->addBackReference(mData->mUuid);
+                rc = medium->i_addBackReference(mData->mUuid);
             /* If the medium->addBackReference fails it sets an appropriate
              * error message, so no need to do any guesswork here. */
@@ -9827 +9826 @@
             if (puuidRegistry)
                 // caller wants registry ID to be set on all attached media (OVF import case)
-                medium->addRegistry(*puuidRegistry, false /* fRecurse */);
+                medium->i_addRegistry(*puuidRegistry, false /* fRecurse */);
         }
 
@@ -10406 +10405 @@
  * with it.
  *
- * Caller must hold the machine lock!
+  Caller must hold the machine lock!
  *
  * This throws XML errors and HRESULT, so the caller must have a catch block!
@@ -10915 +10914 @@
         if (pMedium)
         {
-            if (pMedium->isHostDrive())
-                dev.strHostDriveSrc = pMedium->getLocationFull();
+            if (pMedium->i_isHostDrive())
+                dev.strHostDriveSrc = pMedium->i_getLocationFull();
             else
-                dev.uuid = pMedium->getId();
+                dev.uuid = pMedium->i_getId();
             dev.fTempEject = pAttach->getTempEject();
             dev.fNonRotational = pAttach->getNonRotational();
@@ -11009 +11008 @@
     {
         AutoReadLock treeLock(&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-        pBase = pMedium->getBase();
+        pBase = pMedium->i_getBase();
     }
 
@@ -11024 +11023 @@
         uuid = mParent->getGlobalRegistryId(); // VirtualBox global registry UUID
 
-    if (pMedium->addRegistry(uuid, false /* fRecurse */))
+    if (pMedium->i_addRegistry(uuid, false /* fRecurse */))
         mParent->markRegistryModified(uuid);
 
@@ -11031 +11030 @@
     if (pMedium != pBase)
     {
-        if (pBase->addRegistry(uuid, true /* fRecurse */))
+        if (pBase->i_addRegistry(uuid, true /* fRecurse */))
             mParent->markRegistryModified(uuid);
     }
@@ -11114 +11113 @@
                     MediumLockList *pMediumLockList(new MediumLockList());
                     alock.release();
-                    rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                       false /* fMediumLockWrite */,
-                                                       NULL,
-                                                       *pMediumLockList);
+                    rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                                         false /* fMediumLockWrite */,
+                                                         NULL,
+                                                         *pMediumLockList);
                     alock.acquire();
                     if (FAILED(rc))
@@ -11164 +11163 @@
             if (   devType != DeviceType_HardDisk
                 || pMedium == NULL
-                || pMedium->getType() != MediumType_Normal)
+                || pMedium->i_getType() != MediumType_Normal)
             {
                 /* copy the attachment as is */
@@ -11178 +11177 @@
                     else
                         aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
-                                                            pMedium->getBase()->getName().c_str()).raw(),
+                                                            pMedium->i_getBase()->i_getName().c_str()).raw(),
                                                     aWeight);        // weight
                 }
@@ -11188 +11187 @@
             /* need a diff */
             aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
-                                                pMedium->getBase()->getName().c_str()).raw(),
+                                                pMedium->i_getBase()->i_getName().c_str()).raw(),
                                         aWeight);        // weight
 
@@ -11200 +11199 @@
             // unregistered images)
             Guid uuidRegistryParent;
-            bool fInRegistry = pMedium->getFirstRegistryMachineId(uuidRegistryParent);
+            bool fInRegistry = pMedium->i_getFirstRegistryMachineId(uuidRegistryParent);
             Assert(fInRegistry); NOREF(fInRegistry);
             rc = diff->init(mParent,
-                            pMedium->getPreferredDiffFormat(),
+                            pMedium->i_getPreferredDiffFormat(),
                             strFullSnapshotFolder.append(RTPATH_SLASH_STR),
                             uuidRegistryParent);
@@ -11229 +11228 @@
             /* release the locks before the potentially lengthy operation */
             alock.release();
-            rc = pMedium->createDiffStorage(diff, MediumVariant_Standard,
-                                            pMediumLockList,
-                                            NULL /* aProgress */,
-                                            true /* aWait */);
+            rc = pMedium->i_createDiffStorage(diff, MediumVariant_Standard,
+                                              pMediumLockList,
+                                              NULL /* aProgress */,
+                                              true /* aWait */);
             alock.acquire();
             if (FAILED(rc)) throw rc;
@@ -11238 +11237 @@
             /* actual lock list update is done in Medium::commitMedia */
 
-            rc = diff->addBackReference(mData->mUuid);
+            rc = diff->i_addBackReference(mData->mUuid);
             AssertComRCThrowRC(rc);
 
@@ -11364 +11363 @@
                     MediumLockList *pMediumLockList(new MediumLockList());
                     alock.release();
-                    rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                       false /* fMediumLockWrite */,
-                                                       NULL,
-                                                       *pMediumLockList);
+                    rc = pMedium->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                                         false /* fMediumLockWrite */,
+                                                         NULL,
+                                                         *pMediumLockList);
                     alock.acquire();
 
@@ -11406 +11405 @@
                 /* Deassociate and mark for deletion */
                 LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->getLogName()));
-                rc = pMedium->removeBackReference(mData->mUuid);
+                rc = pMedium->i_removeBackReference(mData->mUuid);
                 if (FAILED(rc))
                    throw rc;
@@ -11418 +11417 @@
                 /* no: de-associate */
                 LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->getLogName()));
-                rc = pMedium->removeBackReference(mData->mUuid);
+                rc = pMedium->i_removeBackReference(mData->mUuid);
                 if (FAILED(rc))
                     throw rc;
@@ -11461 +11460 @@
                 Assert(pMedium);
 
-                rc = pMedium->deleteStorage(NULL /*aProgress*/, true /*aWait*/);
+                rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/);
                 // continue on delete failure, just collect error messages
-                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->getLogName(), pMedium->getLocationFull().c_str() ));
+                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->getLogName(), pMedium->i_getLocationFull().c_str() ));
                 mrc = rc;
             }
@@ -11579 +11578 @@
         MediumAttachment *pAttach = *it;
         ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
-        if (pMediumThis->getId() == id)
+        if (pMediumThis->i_getId() == id)
             return pAttach;
     }
@@ -11602 +11601 @@
     DeviceType_T mediumType = pAttach->getType();
 
-    LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->getLocationFull().c_str() : "NULL"));
+    LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->i_getLocationFull().c_str() : "NULL"));
 
     if (pAttach->isImplicit())
@@ -11621 +11620 @@
         writeLock.release();
 
-        HRESULT rc = oldmedium->deleteStorage(NULL /*aProgress*/,
-                                              true /*aWait*/);
+        HRESULT rc = oldmedium->i_deleteStorage(NULL /*aProgress*/,
+                                                true /*aWait*/);
 
         writeLock.acquire();
@@ -11639 +11638 @@
         // if this is from a snapshot, do not defer detachment to commitMedia()
         if (pSnapshot)
-            oldmedium->removeBackReference(mData->mUuid, pSnapshot->getId());
+            oldmedium->i_removeBackReference(mData->mUuid, pSnapshot->getId());
         // else if non-hard disk media, do not defer detachment to commitMedia() either
         else if (mediumType != DeviceType_HardDisk)
-            oldmedium->removeBackReference(mData->mUuid);
+            oldmedium->i_removeBackReference(mData->mUuid);
     }
 
@@ -11697 +11696 @@
             if (FAILED(mac.rc())) return mac.rc();
             AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
-            DeviceType_T devType = pMedium->getDeviceType();
+            DeviceType_T devType = pMedium->i_getDeviceType();
             if (    (    cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
                       && devType == DeviceType_HardDisk)
@@ -11704 +11703 @@
             {
                 llMedia.push_back(pMedium);
-                ComObjPtr<Medium> pParent = pMedium->getParent();
+                ComObjPtr<Medium> pParent = pMedium->i_getParent();
                 /*
                  * Search for medias which are not attached to any machine, but
@@ -11718 +11717 @@
                     if (FAILED(mac1.rc())) return mac1.rc();
                     AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
-                    if (pParent->getChildren().size() == 1)
+                    if (pParent->i_getChildren().size() == 1)
                     {
-                        if (   pParent->getMachineBackRefCount() == 0
-                            && pParent->getType() == MediumType_Normal
+                        if (   pParent->i_getMachineBackRefCount() == 0
+                            && pParent->i_getType() == MediumType_Normal
                             && find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
                             llMedia.push_back(pParent);
@@ -11727 +11726 @@
                     else
                         break;
-                    pParent = pParent->getParent();
+                    pParent = pParent->i_getParent();
                 }
             }
@@ -11787 +11786 @@
 
         LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
-                         (pMedium) ? pMedium->getName().c_str() : "NULL",
+                         (pMedium) ? pMedium->i_getName().c_str() : "NULL",
                          fImplicit));
 
@@ -11802 +11801 @@
                )
             {
-                ComObjPtr<Medium> parent = pMedium->getParent();
+                ComObjPtr<Medium> parent = pMedium->i_getParent();
                 AutoWriteLock parentLock(parent COMMA_LOCKVAL_SRC_POS);
 
@@ -11838 +11837 @@
                 if (pOldAttach->getMedium() == pMedium)
                 {
-                    LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->getName().c_str()));
+                    LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->i_getName().c_str()));
 
                     /* yes: remove from old to avoid de-association */
@@ -11861 +11860 @@
         if (pAttach->getType() == DeviceType_HardDisk && pMedium)
         {
-            LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->getName().c_str()));
+            LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->i_getName().c_str()));
 
             /* now de-associate from the current machine state */
-            rc = pMedium->removeBackReference(mData->mUuid);
+            rc = pMedium->i_removeBackReference(mData->mUuid);
             AssertComRC(rc);
 
@@ -11964 +11963 @@
             if (pMedium)
             {
-                rc = pMedium->removeBackReference(mData->mUuid);
+                rc = pMedium->i_removeBackReference(mData->mUuid);
                 AssertComRC(rc);
             }
@@ -11978 +11977 @@
             if (pMedium)
             {
-                rc = pMedium->addBackReference(mData->mUuid);
+                rc = pMedium->i_addBackReference(mData->mUuid);
                 AssertComRC(rc);
             }
@@ -13994 +13993 @@
             AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
             if (!oldmedium.isNull())
-                oldmedium->removeBackReference(mData->mUuid);
+                oldmedium->i_removeBackReference(mData->mUuid);
 
             pAttach->updateMedium(NULL);
@@ -14726 +14725 @@
         if (pMedium != NULL)
         {
-            MediumType_T mediumType = pMedium->getType();
+            MediumType_T mediumType = pMedium->i_getType();
             bool fIsReadOnlyLock =    mediumType == MediumType_Readonly
                                    || mediumType == MediumType_Shareable;
@@ -14732 +14731 @@
 
             alock.release();
-            mrc = pMedium->createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
-                                                !fIsReadOnlyLock /* fMediumLockWrite */,
-                                                NULL,
-                                                *pMediumLockList);
+            mrc = pMedium->i_createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
+                                                  !fIsReadOnlyLock /* fMediumLockWrite */,
+                                                  NULL,
+                                                  *pMediumLockList);
             alock.acquire();
             if (FAILED(mrc))

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

@@ -659 +659 @@
         diff.createObject();
         rc = diff->init(p->getVirtualBox(),
-                        pParent->getPreferredDiffFormat(),
+                        pParent->i_getPreferredDiffFormat(),
                         Utf8StrFmt("%s%c", strSnapshotFolder.c_str(), RTPATH_DELIMITER),
                         Guid::Empty /* empty media registry */);
@@ -665 +665 @@
 
         MediumLockList *pMediumLockList(new MediumLockList());
-        rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
-                                        true /* fMediumLockWrite */,
-                                        pParent,
-                                        *pMediumLockList);
+        rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                          true /* fMediumLockWrite */,
+                                          pParent,
+                                          *pMediumLockList);
         if (FAILED(rc)) throw rc;
         rc = pMediumLockList->Lock();
@@ -674 +674 @@
 
         /* this already registers the new diff image */
-        rc = pParent->createDiffStorage(diff, MediumVariant_Standard,
-                                        pMediumLockList,
-                                        NULL /* aProgress */,
-                                        true /* aWait */);
+        rc = pParent->i_createDiffStorage(diff, MediumVariant_Standard,
+                                          pMediumLockList,
+                                          NULL /* aProgress */,
+                                          true /* aWait */);
         delete pMediumLockList;
         if (FAILED(rc)) throw rc;
@@ -1054 +1054 @@
                     if (pLMedium.isNull())
                         throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
-                    ComObjPtr<Medium> pBase = pLMedium->getBase();
-                    if (pBase->isReadOnly())
+                    ComObjPtr<Medium> pBase = pLMedium->i_getBase();
+                    if (pBase->i_isReadOnly())
                     {
                         ComObjPtr<Medium> pDiff;
@@ -1181 +1181 @@
 
                         /* Update the new uuid. */
-                        pTarget->updateId(newId);
+                        pTarget->i_updateId(newId);
 
                         srcLock.release();
@@ -1188 +1188 @@
 
                         ComObjPtr<Medium> pLMedium = static_cast<Medium*>((IMedium*)pMedium);
-                        rc = pLMedium->cloneToEx(pTarget,
-                                                 srcVar,
-                                                 pNewParent,
-                                                 progress2.asOutParam(),
-                                                 uSrcParentIdx,
-                                                 uTrgParentIdx);
+                        rc = pLMedium->i_cloneToEx(pTarget,
+                                                   srcVar,
+                                                   pNewParent,
+                                                   progress2.asOutParam(),
+                                                   uSrcParentIdx,
+                                                   uTrgParentIdx);
                         if (FAILED(rc)) throw rc;
 
@@ -1254 +1254 @@
                 if (pLMedium.isNull())
                     throw p->setError(VBOX_E_OBJECT_NOT_FOUND);
-                ComObjPtr<Medium> pBase = pLMedium->getBase();
-                if (pBase->isReadOnly())
+                ComObjPtr<Medium> pBase = pLMedium->i_getBase();
+                if (pBase->i_isReadOnly())
                 {
                     ComObjPtr<Medium> pDiff;
@@ -1292 +1292 @@
             if (d->options.contains(CloneOptions_Link))
             {
-                ComObjPtr<Medium> pParent = pMedium->getParent();
+                ComObjPtr<Medium> pParent = pMedium->i_getParent();
                 mlock.release();
                 if (!pParent.isNull())
@@ -1299 +1299 @@
                     if (FAILED(mac2.rc())) throw mac2.rc();
                     AutoReadLock mlock2(pParent COMMA_LOCKVAL_SRC_POS);
-                    if (pParent->getFirstRegistryMachineId(uuid))
+                    if (pParent->i_getFirstRegistryMachineId(uuid))
                     {
                         mlock2.release();
@@ -1312 +1312 @@
                 mlock.acquire();
             }
-            pMedium->addRegistry(uuid, false /* fRecurse */);
+            pMedium->i_addRegistry(uuid, false /* fRecurse */);
         }
         /* Check if a snapshot folder is necessary and if so doesn't already
@@ -1407 +1407 @@
         {
             const ComObjPtr<Medium> &pMedium = newMedia.at(i - 1);
-            mrc = pMedium->deleteStorage(NULL /* aProgress */,
+            mrc = pMedium->i_deleteStorage(NULL /* aProgress */,
                                          true /* aWait */);
             pMedium->Close();

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

@@ -251 +251 @@
     AutoCaller mMediumCaller;
 
-    friend HRESULT Medium::runNow(Medium::Task*);
+    friend HRESULT Medium::i_runNow(Medium::Task*);
 
 protected:
@@ -729 +729 @@
 HRESULT Medium::CreateBaseTask::handler()
 {
-    return mMedium->taskCreateBaseHandler(*this);
+    return mMedium->i_taskCreateBaseHandler(*this);
 }
 
@@ -737 +737 @@
 HRESULT Medium::CreateDiffTask::handler()
 {
-    return mMedium->taskCreateDiffHandler(*this);
+    return mMedium->i_taskCreateDiffHandler(*this);
 }
 
@@ -745 +745 @@
 HRESULT Medium::CloneTask::handler()
 {
-    return mMedium->taskCloneHandler(*this);
+    return mMedium->i_taskCloneHandler(*this);
 }
 
@@ -753 +753 @@
 HRESULT Medium::CompactTask::handler()
 {
-    return mMedium->taskCompactHandler(*this);
+    return mMedium->i_taskCompactHandler(*this);
 }
 
@@ -761 +761 @@
 HRESULT Medium::ResizeTask::handler()
 {
-    return mMedium->taskResizeHandler(*this);
+    return mMedium->i_taskResizeHandler(*this);
 }
 
@@ -770 +770 @@
 HRESULT Medium::ResetTask::handler()
 {
-    return mMedium->taskResetHandler(*this);
+    return mMedium->i_taskResetHandler(*this);
 }
 
@@ -778 +778 @@
 HRESULT Medium::DeleteTask::handler()
 {
-    return mMedium->taskDeleteHandler(*this);
+    return mMedium->i_taskDeleteHandler(*this);
 }
 
@@ -786 +786 @@
 HRESULT Medium::MergeTask::handler()
 {
-    return mMedium->taskMergeHandler(*this);
+    return mMedium->i_taskMergeHandler(*this);
 }
 
@@ -794 +794 @@
 HRESULT Medium::ExportTask::handler()
 {
-    return mMedium->taskExportHandler(*this);
+    return mMedium->i_taskExportHandler(*this);
 }
 
@@ -802 +802 @@
 HRESULT Medium::ImportTask::handler()
 {
-    return mMedium->taskImportHandler(*this);
+    return mMedium->i_taskImportHandler(*this);
 }
 
@@ -818 +818 @@
 
     /* Initialize the callbacks of the VD error interface */
-    m->vdIfError.pfnError = vdErrorCall;
+    m->vdIfError.pfnError = i_vdErrorCall;
     m->vdIfError.pfnMessage = NULL;
 
     /* Initialize the callbacks of the VD config interface */
-    m->vdIfConfig.pfnAreKeysValid = vdConfigAreKeysValid;
-    m->vdIfConfig.pfnQuerySize = vdConfigQuerySize;
-    m->vdIfConfig.pfnQuery = vdConfigQuery;
+    m->vdIfConfig.pfnAreKeysValid = i_vdConfigAreKeysValid;
+    m->vdIfConfig.pfnQuerySize = i_vdConfigQuerySize;
+    m->vdIfConfig.pfnQuery = i_vdConfigQuery;
 
     /* Initialize the callbacks of the VD TCP interface (we always use the host
      * IP stack for now) */
-    m->vdIfTcpNet.pfnSocketCreate = vdTcpSocketCreate;
-    m->vdIfTcpNet.pfnSocketDestroy = vdTcpSocketDestroy;
-    m->vdIfTcpNet.pfnClientConnect = vdTcpClientConnect;
-    m->vdIfTcpNet.pfnClientClose = vdTcpClientClose;
-    m->vdIfTcpNet.pfnIsClientConnected = vdTcpIsClientConnected;
-    m->vdIfTcpNet.pfnSelectOne = vdTcpSelectOne;
-    m->vdIfTcpNet.pfnRead = vdTcpRead;
-    m->vdIfTcpNet.pfnWrite = vdTcpWrite;
-    m->vdIfTcpNet.pfnSgWrite = vdTcpSgWrite;
-    m->vdIfTcpNet.pfnFlush = vdTcpFlush;
-    m->vdIfTcpNet.pfnSetSendCoalescing = vdTcpSetSendCoalescing;
-    m->vdIfTcpNet.pfnGetLocalAddress = vdTcpGetLocalAddress;
-    m->vdIfTcpNet.pfnGetPeerAddress = vdTcpGetPeerAddress;
+    m->vdIfTcpNet.pfnSocketCreate = i_vdTcpSocketCreate;
+    m->vdIfTcpNet.pfnSocketDestroy = i_vdTcpSocketDestroy;
+    m->vdIfTcpNet.pfnClientConnect = i_vdTcpClientConnect;
+    m->vdIfTcpNet.pfnClientClose = i_vdTcpClientClose;
+    m->vdIfTcpNet.pfnIsClientConnected = i_vdTcpIsClientConnected;
+    m->vdIfTcpNet.pfnSelectOne = i_vdTcpSelectOne;
+    m->vdIfTcpNet.pfnRead = i_vdTcpRead;
+    m->vdIfTcpNet.pfnWrite = i_vdTcpWrite;
+    m->vdIfTcpNet.pfnSgWrite = i_vdTcpSgWrite;
+    m->vdIfTcpNet.pfnFlush = i_vdTcpFlush;
+    m->vdIfTcpNet.pfnSetSendCoalescing = i_vdTcpSetSendCoalescing;
+    m->vdIfTcpNet.pfnGetLocalAddress = i_vdTcpGetLocalAddress;
+    m->vdIfTcpNet.pfnGetPeerAddress = i_vdTcpGetPeerAddress;
     m->vdIfTcpNet.pfnSelectOneEx = NULL;
     m->vdIfTcpNet.pfnPoke = NULL;
@@ -927 +927 @@
     /* No storage unit is created yet, no need to call Medium::queryInfo */
 
-    rc = setFormat(aFormat);
+    rc = i_setFormat(aFormat);
     if (FAILED(rc)) return rc;
 
-    rc = setLocation(aLocation);
+    rc = i_setLocation(aLocation);
     if (FAILED(rc)) return rc;
 
@@ -1040 +1040 @@
             m->type = MediumType_Writethrough;
 
-        rc = setLocation(aLocation);
+        rc = i_setLocation(aLocation);
         if (FAILED(rc)) return rc;
 
@@ -1065 +1065 @@
     /* need to call queryInfo immediately to correctly place the medium in
      * the respective media tree and update other information such as uuid */
-    rc = queryInfo(fForceNewUuid /* fSetImageId */, false /* fSetParentId */);
+    rc = i_queryInfo(fForceNewUuid /* fSetImageId */, false /* fSetParentId */);
     if (SUCCEEDED(rc))
     {
@@ -1168 +1168 @@
     {
         AssertReturn(!data.strFormat.isEmpty(), E_FAIL);
-        rc = setFormat(data.strFormat);
+        rc = i_setFormat(data.strFormat);
         if (FAILED(rc)) return rc;
     }
@@ -1175 +1175 @@
         /// @todo handle host drive settings here as well?
         if (!data.strFormat.isEmpty())
-            rc = setFormat(data.strFormat);
+            rc = i_setFormat(data.strFormat);
         else
-            rc = setFormat("RAW");
+            rc = i_setFormat("RAW");
         if (FAILED(rc)) return rc;
     }
@@ -1237 +1237 @@
         strFull = data.strLocation;
 
-    rc = setLocation(strFull);
+    rc = i_setLocation(strFull);
     if (FAILED(rc)) return rc;
 
@@ -1345 +1345 @@
     m->state = MediumState_Created;
     m->hostDrive = true;
-    HRESULT rc = setFormat("RAW");
+    HRESULT rc = i_setFormat("RAW");
     if (FAILED(rc)) return rc;
-    rc = setLocation(aLocation);
+    rc = i_setLocation(aLocation);
     if (FAILED(rc)) return rc;
     m->strDescription = aDescription;
@@ -1399 +1399 @@
         {
             // this is a differencing disk: then remove it from the parent's children list
-            deparent();
+            i_deparent();
         }
     }
@@ -1412 +1412 @@
  * The caller must hold the medium tree lock!
  */
-void Medium::deparent()
+void Medium::i_deparent()
 {
     MediaList &llParent = m->pParent->m->llChildren;
@@ -1435 +1435 @@
  * The caller must hold the medium tree lock!
  */
-void Medium::setParent(const ComObjPtr<Medium> &pParent)
+void Medium::i_setParent(const ComObjPtr<Medium> &pParent)
 {
     m->pParent = pParent;
@@ -1449 +1449 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP Medium::COMGETTER(Id)(BSTR *aId)
-{
-    CheckComArgOutPointerValid(aId);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getId(com::Guid &aId)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m->id.toUtf16().cloneTo(aId);
+    aId = m->id;
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Description)(BSTR *aDescription)
-{
-    CheckComArgOutPointerValid(aDescription);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getDescription(com::Utf8Str &aDescription)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m->strDescription.cloneTo(aDescription);
+    aDescription = m->strDescription;
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMSETTER(Description)(IN_BSTR aDescription)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setDescription(const com::Utf8Str &aDescription)
+{
 //     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1488 +1475 @@
     /// require to add the mRegistered flag to data
 
-    NOREF(aDescription);
-
     ReturnComNotImplemented();
 }
 
-STDMETHODIMP Medium::COMGETTER(State)(MediumState_T *aState)
-{
-    CheckComArgOutPointerValid(aState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getState(MediumState_T *aState)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     *aState = m->state;
@@ -1506 +1486 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(Variant)(ComSafeArrayOut(MediumVariant_T, aVariant))
-{
-    CheckComArgOutSafeArrayPointerValid(aVariant);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getVariant(std::vector<MediumVariant_T> &aVariant)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     SafeArray<MediumVariant_T> variants(sizeof(MediumVariant_T)*8);
 
+    aVariant.resize(variants.size());
     for (ULONG i = 0; i < variants.size(); ++i)
     {
         ULONG temp = m->variant;
         temp &= 1<<i;
-        variants [i] = (MediumVariant_T)temp;
-    }
-
-    variants.detachTo(ComSafeArrayOutArg(aVariant));
+        aVariant[i] = (MediumVariant_T)temp;
+    }
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Location)(BSTR *aLocation)
-{
-    CheckComArgOutPointerValid(aLocation);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getLocation(com::Utf8Str &aLocation)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m->strLocationFull.cloneTo(aLocation);
+    aLocation = m->strLocationFull;
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Name)(BSTR *aName)
-{
-    CheckComArgOutPointerValid(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getName(com::Utf8Str &aName)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    getName().cloneTo(aName);
+    aName = i_getName();
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(DeviceType)(DeviceType_T *aDeviceType)
-{
-    CheckComArgOutPointerValid(aDeviceType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getDeviceType(DeviceType_T *aDeviceType)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1571 +1530 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(HostDrive)(BOOL *aHostDrive)
-{
-    CheckComArgOutPointerValid(aHostDrive);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getHostDrive(BOOL *aHostDrive)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1585 +1539 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(Size)(LONG64 *aSize)
-{
-    CheckComArgOutPointerValid(aSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getSize(LONG64 *aSize)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1599 +1548 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(Format)(BSTR *aFormat)
-{
-    CheckComArgOutPointerValid(aFormat);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getFormat(com::Utf8Str &aFormat)
+{
     /* no need to lock, m->strFormat is const */
-    m->strFormat.cloneTo(aFormat);
-
+
+    aFormat = m->strFormat;
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(MediumFormat)(IMediumFormat **aMediumFormat)
-{
-    CheckComArgOutPointerValid(aMediumFormat);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat)
+{
     /* no need to lock, m->formatObj is const */
-    m->formatObj.queryInterfaceTo(aMediumFormat);
+    m->formatObj.queryInterfaceTo(aMediumFormat.asOutParam());
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Type)(MediumType_T *aType)
-{
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getType(MediumType_T *aType)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1639 +1573 @@
 }
 
-STDMETHODIMP Medium::COMSETTER(Type)(MediumType_T aType)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setType(MediumType_T aType)
+{
     // we access mParent and members
     AutoWriteLock treeLock(m->pVirtualBox->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
@@ -1654 +1585 @@
             break;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 
@@ -1663 +1594 @@
     }
 
-    DeviceType_T devType = getDeviceType();
+    DeviceType_T devType = i_getDeviceType();
     // DVD media can only be readonly.
     if (devType == DeviceType_DVD && aType != MediumType_Readonly)
@@ -1714 +1645 @@
             /* cannot change to writethrough, shareable or readonly
              * if there are children */
-            if (getChildren().size() != 0)
+            if (i_getChildren().size() != 0)
                 return setError(VBOX_E_OBJECT_IN_USE,
                                 tr("Cannot change type for medium '%s' since it has %d child media"),
-                                m->strLocationFull.c_str(), getChildren().size());
+                                m->strLocationFull.c_str(), i_getChildren().size());
             if (aType == MediumType_Shareable)
             {
-                MediumVariant_T variant = getVariant();
+                MediumVariant_T variant = i_getVariant();
                 if (!(variant & MediumVariant_Fixed))
                     return setError(VBOX_E_INVALID_OBJECT_STATE,
@@ -1753 +1684 @@
         // global registry:
         const Guid &uuidGlobalRegistry = m->pVirtualBox->getGlobalRegistryId();
-        if (isInRegistry(uuidGlobalRegistry))
+        if (i_isInRegistry(uuidGlobalRegistry))
             return setError(VBOX_E_INVALID_OBJECT_STATE,
                             tr("Cannot change type for medium '%s': the media type 'MultiAttach' can only be used "
@@ -1765 +1696 @@
     mlock.release();
     treeLock.release();
-    markRegistriesModified();
+    i_markRegistriesModified();
     m->pVirtualBox->saveModifiedRegistries();
 
@@ -1771 +1702 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(AllowedTypes)(ComSafeArrayOut(MediumType_T, aAllowedTypes))
-{
-    CheckComArgOutSafeArrayPointerValid(aAllowedTypes);
-    NOREF(aAllowedTypes);
-#ifndef RT_OS_WINDOWS
-    NOREF(aAllowedTypesSize);
-#endif
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1787 +1709 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(Parent)(IMedium **aParent)
-{
-    CheckComArgOutPointerValid(aParent);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getParent(ComPtr<IMedium> &aParent)
+{
     /* we access mParent */
     AutoReadLock treeLock(m->pVirtualBox->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
 
-    m->pParent.queryInterfaceTo(aParent);
+    m->pParent.queryInterfaceTo(aParent.asOutParam());
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Children)(ComSafeArrayOut(IMedium *, aChildren))
-{
-    CheckComArgOutSafeArrayPointerValid(aChildren);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getChildren(std::vector<ComPtr<IMedium> > &aChildren)
+{
     /* we access children */
     AutoReadLock treeLock(m->pVirtualBox->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
 
-    SafeIfaceArray<IMedium> children(this->getChildren());
-    children.detachTo(ComSafeArrayOutArg(aChildren));
-
+    MediaList children(this->i_getChildren());
+    aChildren.resize(children.size());
+    size_t i = 0;
+    for (MediaList::const_iterator it =  children.begin(); it != children.end(); ++it, ++i)
+        (*it).queryInterfaceTo(aChildren[i].asOutParam());
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(Base)(IMedium **aBase)
-{
-    CheckComArgOutPointerValid(aBase);
-
-    /* base() will do callers/locking */
-
-    getBase().queryInterfaceTo(aBase);
+HRESULT Medium::getBase(ComPtr<IMedium> &aBase)
+{
+    /* i_getBase() will do callers/locking */
+    i_getBase().queryInterfaceTo(aBase.asOutParam());
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(ReadOnly)(BOOL *aReadOnly)
-{
-    CheckComArgOutPointerValid(aReadOnly);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getReadOnly(BOOL *aReadOnly)
+{
     /* isReadOnly() will do locking */
-
-    *aReadOnly = isReadOnly();
+    *aReadOnly = i_isReadOnly();
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(LogicalSize)(LONG64 *aLogicalSize)
-{
-    CheckComArgOutPointerValid(aLogicalSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getLogicalSize(LONG64 *aLogicalSize)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1857 +1757 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(AutoReset)(BOOL *aAutoReset)
-{
-    CheckComArgOutPointerValid(aAutoReset);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getAutoReset(BOOL *aAutoReset)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1874 +1769 @@
 }
 
-STDMETHODIMP Medium::COMSETTER(AutoReset)(BOOL aAutoReset)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setAutoReset(BOOL aAutoReset)
+{
     AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1892 +1784 @@
         // save the settings
         mlock.release();
-        markRegistriesModified();
+        i_markRegistriesModified();
         m->pVirtualBox->saveModifiedRegistries();
     }
@@ -1899 +1791 @@
 }
 
-STDMETHODIMP Medium::COMGETTER(LastAccessError)(BSTR *aLastAccessError)
-{
-    CheckComArgOutPointerValid(aLastAccessError);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getLastAccessError(com::Utf8Str &aLastAccessError)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    m->strLastAccessError.cloneTo(aLastAccessError);
+    aLastAccessError = m->strLastAccessError;
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::COMGETTER(MachineIds)(ComSafeArrayOut(BSTR,aMachineIds))
-{
-    CheckComArgOutSafeArrayPointerValid(aMachineIds);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getMachineIds(std::vector<com::Guid> &aMachineIds)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    com::SafeArray<BSTR> machineIds;
-
     if (m->backRefs.size() != 0)
     {
-        machineIds.reset(m->backRefs.size());
-
+        BackRefList brlist(m->backRefs);
+        aMachineIds.resize(brlist.size());
         size_t i = 0;
-        for (BackRefList::const_iterator it = m->backRefs.begin();
-             it != m->backRefs.end(); ++it, ++i)
-        {
-             it->machineId.toUtf16().detachTo(&machineIds[i]);
-        }
-    }
-
-    machineIds.detachTo(ComSafeArrayOutArg(aMachineIds));
+        for (BackRefList::const_iterator it = brlist.begin(); it != brlist.end(); ++it, ++i)
+             aMachineIds[i] = it->machineId;
+    }
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::SetIds(BOOL aSetImageId,
-                            IN_BSTR aImageId,
-                            BOOL aSetParentId,
-                            IN_BSTR aParentId)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setIds(BOOL aSetImageId,
+                       const com::Guid &aImageId,
+                       BOOL aSetParentId,
+                       const com::Guid &aParentId)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -1956 +1828 @@
             break;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 
@@ -1962 +1834 @@
     if (aSetImageId)
     {
-        if (Bstr(aImageId).isEmpty())
+        if (aImageId.toUtf16().isEmpty())
             imageId.create();
         else
         {
-            imageId = Guid(aImageId);
+            imageId = aImageId;
             if (!imageId.isValid())
                 return setError(E_INVALIDARG, tr("Argument %s is invalid"), "aImageId");
@@ -1973 +1845 @@
     if (aSetParentId)
     {
-        if (Bstr(aParentId).isEmpty())
+        if (aParentId.toUtf16().isEmpty())
             parentId.create();
         else
-            parentId = Guid(aParentId);
+            parentId = aParentId;
     }
 
@@ -1985 +1857 @@
     alock.release();
 
-    HRESULT rc = queryInfo(!!aSetImageId /* fSetImageId */,
+    HRESULT rc = i_queryInfo(!!aSetImageId /* fSetImageId */,
                            !!aSetParentId /* fSetParentId */);
 
@@ -1991 +1863 @@
 }
 
-STDMETHODIMP Medium::RefreshState(MediumState_T *aState)
-{
-    CheckComArgOutPointerValid(aState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::refreshState(MediumState_T *aState)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2011 +1878 @@
             alock.release();
 
-            rc = queryInfo(false /* fSetImageId */, false /* fSetParentId */);
+            rc = i_queryInfo(false /* fSetImageId */, false /* fSetParentId */);
 
             alock.acquire();
@@ -2025 +1892 @@
 }
 
-STDMETHODIMP Medium::GetSnapshotIds(IN_BSTR aMachineId,
-                                    ComSafeArrayOut(BSTR, aSnapshotIds))
-{
-    CheckComArgExpr(aMachineId, Guid(aMachineId).isValid());
-    CheckComArgOutSafeArrayPointerValid(aSnapshotIds);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getSnapshotIds(const com::Guid &aMachineId,
+                               std::vector<com::Guid> &aSnapshotIds)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    com::SafeArray<BSTR> snapshotIds;
-
-    Guid id(aMachineId);
     for (BackRefList::const_iterator it = m->backRefs.begin();
          it != m->backRefs.end(); ++it)
     {
-        if (it->machineId == id)
+        if (it->machineId == aMachineId)
         {
             size_t size = it->llSnapshotIds.size();
@@ -2053 +1911 @@
             if (size > 0)
             {
-                snapshotIds.reset(size);
+                aSnapshotIds.resize(size);
 
                 size_t j = 0;
                 if (it->fInCurState)
-                    it->machineId.toUtf16().detachTo(&snapshotIds[j++]);
-
-                for (GuidList::const_iterator jt = it->llSnapshotIds.begin();
-                     jt != it->llSnapshotIds.end();
-                     ++jt, ++j)
-                {
-                     (*jt).toUtf16().detachTo(&snapshotIds[j]);
-                }
+                    aSnapshotIds[j++] = it->machineId.toUtf16();
+
+                for(GuidList::const_iterator jt = it->llSnapshotIds.begin(); jt != it->llSnapshotIds.end(); ++jt, ++j)
+                    aSnapshotIds[j] = (*jt);
             }
 
@@ -2071 +1925 @@
     }
 
-    snapshotIds.detachTo(ComSafeArrayOutArg(aSnapshotIds));
-
     return S_OK;
 }
 
-STDMETHODIMP Medium::LockRead(IToken **aToken)
-{
-    CheckComArgNotNull(aToken);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::lockRead(ComPtr<IToken> &aToken)
+{
     /* Must not hold the object lock, as we need control over it below. */
     Assert(!isWriteLockOnCurrentThread());
@@ -2134 +1981 @@
             }
 
-            pToken.queryInterfaceTo(aToken);
+            pToken.queryInterfaceTo(aToken.asOutParam());
             break;
         }
@@ -2140 +1987 @@
         {
             LogFlowThisFunc(("Failing - state=%d\n", m->state));
-            rc = setStateError();
+            rc = i_setStateError();
             break;
         }
@@ -2152 +1999 @@
  *       in-process calls).
  */
-HRESULT Medium::unlockRead(MediumState_T *aState)
+HRESULT Medium::i_unlockRead(MediumState_T *aState)
 {
     AutoCaller autoCaller(this);
@@ -2198 +2045 @@
     return rc;
 }
-
-STDMETHODIMP Medium::LockWrite(IToken **aToken)
-{
-    CheckComArgNotNull(aToken);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::lockWrite(ComPtr<IToken> &aToken)
+{
     /* Must not hold the object lock, as we need control over it below. */
     Assert(!isWriteLockOnCurrentThread());
@@ -2235 +2076 @@
             m->preLockState = m->state;
 
-            LogFlowThisFunc(("Okay - prev state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
+            LogFlowThisFunc(("Okay - prev state=%d locationFull=%s\n", m->state, i_getLocationFull().c_str()));
             m->state = MediumState_LockedWrite;
 
@@ -2248 +2089 @@
             }
 
-            pToken.queryInterfaceTo(aToken);
+            pToken.queryInterfaceTo(aToken.asOutParam());
             break;
         }
         default:
         {
-            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
-            rc = setStateError();
+            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, i_getLocationFull().c_str()));
+            rc = i_setStateError();
             break;
         }
@@ -2266 +2107 @@
  *       in-process calls).
  */
-HRESULT Medium::unlockWrite(MediumState_T *aState)
+HRESULT Medium::i_unlockWrite(MediumState_T *aState)
 {
     AutoCaller autoCaller(this);
@@ -2285 +2126 @@
             if (m->preLockState == MediumState_Deleting)
                 m->preLockState = MediumState_Created;
-            LogFlowThisFunc(("new state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
+            LogFlowThisFunc(("new state=%d locationFull=%s\n", m->state, i_getLocationFull().c_str()));
             break;
         }
         default:
         {
-            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, getLocationFull().c_str()));
+            LogFlowThisFunc(("Failing - state=%d locationFull=%s\n", m->state, i_getLocationFull().c_str()));
             rc = setError(VBOX_E_INVALID_OBJECT_STATE,
                           tr("Medium '%s' is not locked for writing"),
@@ -2305 +2146 @@
 }
 
-STDMETHODIMP Medium::Close()
+HRESULT Medium::close()
 {
     AutoCaller autoCaller(this);
@@ -2313 +2154 @@
     ComObjPtr<VirtualBox> pVirtualBox(m->pVirtualBox);
 
-    MultiResult mrc = close(autoCaller);
+    MultiResult mrc = i_close(autoCaller);
 
     pVirtualBox->saveModifiedRegistries();
@@ -2320 +2161 @@
 }
 
-STDMETHODIMP Medium::GetProperty(IN_BSTR aName, BSTR *aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgOutPointerValid(aValue);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getProperty(const com::Utf8Str &aName,
+                            com::Utf8Str &aValue)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    settings::StringsMap::const_iterator it = m->mapProperties.find(Utf8Str(aName));
+    settings::StringsMap::const_iterator it = m->mapProperties.find(aName);
     if (it == m->mapProperties.end())
     {
-        if (!Utf8Str(aName).startsWith("Special/"))
+        if (!aName.startsWith("Special/"))
             return setError(VBOX_E_OBJECT_NOT_FOUND,
-                            tr("Property '%ls' does not exist"), aName);
+                            tr("Property '%ls' does not exist"), Bstr(aName).raw());
         else
             /* be more silent here */
@@ -2341 +2177 @@
     }
 
-    it->second.cloneTo(aValue);
+    aValue = it->second;
 
     return S_OK;
 }
 
-STDMETHODIMP Medium::SetProperty(IN_BSTR aName, IN_BSTR aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setProperty(const com::Utf8Str &aName,
+                            const com::Utf8Str &aValue)
+{
     AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2361 +2193 @@
             break;
         default:
-            return setStateError();
-    }
-
-    Utf8Str strName(aName);
-    Utf8Str strValue(aValue);
-    settings::StringsMap::iterator it = m->mapProperties.find(strName);
-    if (!strName.startsWith("Special/"))
+            return i_setStateError();
+    }
+
+    settings::StringsMap::iterator it = m->mapProperties.find(aName);
+    if (!aName.startsWith("Special/"))
     {
         if (it == m->mapProperties.end())
             return setError(VBOX_E_OBJECT_NOT_FOUND,
                             tr("Property '%s' does not exist"),
-                            strName.c_str());
-        it->second = strValue;
+                            aName.c_str());
+        it->second = aValue;
     }
     else
@@ -2379 +2209 @@
         if (it == m->mapProperties.end())
         {
-            if (!strValue.isEmpty())
-                m->mapProperties[strName] = strValue;
+            if (!aValue.isEmpty())
+                m->mapProperties[aName] = aValue;
         }
         else
         {
-            if (!strValue.isEmpty())
+            if (!aValue.isEmpty())
                 it->second = aValue;
             else
@@ -2393 +2223 @@
     // save the settings
     mlock.release();
-    markRegistriesModified();
+    i_markRegistriesModified();
     m->pVirtualBox->saveModifiedRegistries();
 
@@ -2399 +2229 @@
 }
 
-STDMETHODIMP Medium::GetProperties(IN_BSTR aNames,
-                                   ComSafeArrayOut(BSTR, aReturnNames),
-                                   ComSafeArrayOut(BSTR, aReturnValues))
-{
-    CheckComArgOutSafeArrayPointerValid(aReturnNames);
-    CheckComArgOutSafeArrayPointerValid(aReturnValues);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::getProperties(const com::Utf8Str &aNames,
+                              std::vector<com::Utf8Str> &aReturnNames,
+                              std::vector<com::Utf8Str> &aReturnValues)
+{
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2414 +2238 @@
     NOREF(aNames);
 
-    com::SafeArray<BSTR> names(m->mapProperties.size());
-    com::SafeArray<BSTR> values(m->mapProperties.size());
+    aReturnNames.resize(m->mapProperties.size());
+    aReturnValues.resize(m->mapProperties.size());
     size_t i = 0;
-
     for (settings::StringsMap::const_iterator it = m->mapProperties.begin();
          it != m->mapProperties.end();
-         ++it)
-    {
-        it->first.cloneTo(&names[i]);
-        it->second.cloneTo(&values[i]);
-        ++i;
-    }
-
-    names.detachTo(ComSafeArrayOutArg(aReturnNames));
-    values.detachTo(ComSafeArrayOutArg(aReturnValues));
-
+         ++it, ++i)
+    {
+        aReturnNames[i] = it->first;
+        aReturnValues[i] = it->second;
+    }
     return S_OK;
 }
 
-STDMETHODIMP Medium::SetProperties(ComSafeArrayIn(IN_BSTR, aNames),
-                                   ComSafeArrayIn(IN_BSTR, aValues))
-{
-    CheckComArgSafeArrayNotNull(aNames);
-    CheckComArgSafeArrayNotNull(aValues);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setProperties(const std::vector<com::Utf8Str> &aNames,
+                              const std::vector<com::Utf8Str> &aValues)
+{
     AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
-
-    com::SafeArray<IN_BSTR> names(ComSafeArrayInArg(aNames));
-    com::SafeArray<IN_BSTR> values(ComSafeArrayInArg(aValues));
 
     /* first pass: validate names */
     for (size_t i = 0;
-         i < names.size();
+         i < aNames.size();
          ++i)
     {
-        Utf8Str strName(names[i]);
+        Utf8Str strName(aNames[i]);
         if (   !strName.startsWith("Special/")
             && m->mapProperties.find(strName) == m->mapProperties.end())
@@ -2461 +2270 @@
     /* second pass: assign */
     for (size_t i = 0;
-         i < names.size();
+         i < aNames.size();
          ++i)
     {
-        Utf8Str strName(names[i]);
-        Utf8Str strValue(values[i]);
+        Utf8Str strName(aNames[i]);
+        Utf8Str strValue(aValues[i]);
         settings::StringsMap::iterator it = m->mapProperties.find(strName);
         if (!strName.startsWith("Special/"))
@@ -2491 +2300 @@
     // save the settings
     mlock.release();
-    markRegistriesModified();
+    i_markRegistriesModified();
     m->pVirtualBox->saveModifiedRegistries();
 
     return S_OK;
 }
-
-STDMETHODIMP Medium::CreateBaseStorage(LONG64 aLogicalSize,
-                                       ComSafeArrayIn(MediumVariant_T, aVariant),
-                                       IProgress **aProgress)
-{
-    CheckComArgSafeArrayNotNull(aVariant);
-    CheckComArgOutPointerValid(aProgress);
+HRESULT Medium::createBaseStorage(LONG64 aLogicalSize,
+                                  const std::vector<MediumVariant_T> &aVariant,
+                                  ComPtr<IProgress> &aProgress)
+{
     if (aLogicalSize < 0)
         return setError(E_INVALIDARG, tr("The medium size argument (%lld) is negative"), aLogicalSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     HRESULT rc = S_OK;
@@ -2519 +2322 @@
         ULONG mediumVariantFlags = 0;
 
-        if (aVariant)
-        {
-            com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
+        if (aVariant.size())
+        {
+            com::SafeArray<MediumVariant_T> variants(aVariant);
             for (size_t i = 0; i < variants.size(); i++)
                 mediumVariantFlags |= variants[i];
@@ -2541 +2344 @@
 
         if (m->state != MediumState_NotCreated)
-            throw setStateError();
+            throw i_setStateError();
 
         pProgress.createObject();
@@ -2568 +2371 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
-            pProgress.queryInterfaceTo(aProgress);
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
     else if (pTask != NULL)
@@ -2579 +2382 @@
 }
 
-STDMETHODIMP Medium::DeleteStorage(IProgress **aProgress)
-{
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::deleteStorage(ComPtr<IProgress> &aProgress)
+{
     ComObjPtr<Progress> pProgress;
 
-    MultiResult mrc = deleteStorage(&pProgress,
-                                    false /* aWait */);
+    MultiResult mrc = i_deleteStorage(&pProgress,
+                                      false /* aWait */);
     /* Must save the registries in any case, since an entry was removed. */
     m->pVirtualBox->saveModifiedRegistries();
 
     if (SUCCEEDED(mrc))
-        pProgress.queryInterfaceTo(aProgress);
+        pProgress.queryInterfaceTo(aProgress.asOutParam());
 
     return mrc;
 }
 
-STDMETHODIMP Medium::CreateDiffStorage(IMedium *aTarget,
-                                         ComSafeArrayIn(MediumVariant_T, aVariant),
-                                         IProgress **aProgress)
-{
-    CheckComArgNotNull(aTarget);
-    CheckComArgOutPointerValid(aProgress);
-    CheckComArgSafeArrayNotNull(aVariant);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<Medium> diff = static_cast<Medium*>(aTarget);
+HRESULT Medium::createDiffStorage(const ComPtr<IMedium> &aTarget,
+                                  const std::vector<MediumVariant_T> &aVariant,
+                                  ComPtr<IProgress> &aProgress)
+{
+    IMedium *aT = aTarget;
+    ComObjPtr<Medium> diff = static_cast<Medium*>(aT);
 
     // locking: we need the tree lock first because we access parent pointers
@@ -2632 +2424 @@
     MediumLockList *pMediumLockList(new MediumLockList());
     alock.release();
-    HRESULT rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
+    HRESULT rc = diff->i_createMediumLockList(true /* fFailIfInaccessible */,
                                             true /* fMediumLockWrite */,
                                             this,
@@ -2651 +2443 @@
 
         return setError(rc, tr("Could not lock medium when creating diff '%s'"),
-                        diff->getLocationFull().c_str());
+                        diff->i_getLocationFull().c_str());
     }
 
     Guid parentMachineRegistry;
-    if (getFirstRegistryMachineId(parentMachineRegistry))
+    if (i_getFirstRegistryMachineId(parentMachineRegistry))
     {
         /* since this medium has been just created it isn't associated yet */
         diff->m->llRegistryIDs.push_back(parentMachineRegistry);
         alock.release();
-        diff->markRegistriesModified();
+        diff->i_markRegistriesModified();
         alock.acquire();
     }
@@ -2670 +2462 @@
     ULONG mediumVariantFlags = 0;
 
-    if (aVariant)
-    {
-        com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
+    if (aVariant.size())
+    {
+        com::SafeArray<MediumVariant_T> variants(aVariant);
         for (size_t i = 0; i < variants.size(); i++)
             mediumVariantFlags |= variants[i];
     }
 
-    rc = createDiffStorage(diff, (MediumVariant_T)mediumVariantFlags, pMediumLockList,
-                           &pProgress, false /* aWait */);
+    rc = i_createDiffStorage(diff, (MediumVariant_T)mediumVariantFlags, pMediumLockList,
+                             &pProgress, false /* aWait */);
     if (FAILED(rc))
         delete pMediumLockList;
     else
-        pProgress.queryInterfaceTo(aProgress);
+        pProgress.queryInterfaceTo(aProgress.asOutParam());
 
     return rc;
 }
 
-STDMETHODIMP Medium::MergeTo(IMedium *aTarget, IProgress **aProgress)
-{
-    CheckComArgNotNull(aTarget);
-    CheckComArgOutPointerValid(aProgress);
-    ComAssertRet(aTarget != this, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<Medium> pTarget = static_cast<Medium*>(aTarget);
+HRESULT Medium::mergeTo(const ComPtr<IMedium> &aTarget,
+                        ComPtr<IProgress> &aProgress)
+{
+
+    IMedium *aT = aTarget;
+
+    ComAssertRet(aT != this, E_INVALIDARG);
+
+    ComObjPtr<Medium> pTarget = static_cast<Medium*>(aT);
 
     bool fMergeForward = false;
@@ -2705 +2496 @@
     HRESULT rc = S_OK;
 
-    rc = prepareMergeTo(pTarget, NULL, NULL, true, fMergeForward,
-                        pParentForTarget, pChildrenToReparent, pMediumLockList);
+    rc = i_prepareMergeTo(pTarget, NULL, NULL, true, fMergeForward,
+                          pParentForTarget, pChildrenToReparent, pMediumLockList);
     if (FAILED(rc)) return rc;
 
     ComObjPtr<Progress> pProgress;
 
-    rc = mergeTo(pTarget, fMergeForward, pParentForTarget, pChildrenToReparent,
-                 pMediumLockList, &pProgress, false /* aWait */);
+    rc = i_mergeTo(pTarget, fMergeForward, pParentForTarget, pChildrenToReparent,
+                   pMediumLockList, &pProgress, false /* aWait */);
     if (FAILED(rc))
-        cancelMergeTo(pChildrenToReparent, pMediumLockList);
+        i_cancelMergeTo(pChildrenToReparent, pMediumLockList);
     else
-        pProgress.queryInterfaceTo(aProgress);
+        pProgress.queryInterfaceTo(aProgress.asOutParam());
 
     return rc;
 }
 
-STDMETHODIMP Medium::CloneToBase(IMedium   *aTarget,
-                                  ComSafeArrayIn(MediumVariant_T, aVariant),
-                                  IProgress **aProgress)
+HRESULT Medium::cloneToBase(const ComPtr<IMedium> &aTarget,
+                            const std::vector<MediumVariant_T> &aVariant,
+                            ComPtr<IProgress> &aProgress)
 {
      int rc = S_OK;
-     CheckComArgNotNull(aTarget);
-     CheckComArgOutPointerValid(aProgress);
-     CheckComArgSafeArrayNotNull(aVariant);
-
-     com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
-
-     rc =  CloneTo(aTarget, ComSafeArrayAsInParam(variants), NULL, aProgress);
+
+     rc =  cloneTo(aTarget, aVariant, NULL, aProgress);
      return rc;
 }
 
-STDMETHODIMP Medium::CloneTo(IMedium *aTarget,
-                             ComSafeArrayIn(MediumVariant_T, aVariant),
-                             IMedium *aParent,
-                             IProgress **aProgress)
-{
-    CheckComArgNotNull(aTarget);
-    CheckComArgOutPointerValid(aProgress);
-    CheckComArgSafeArrayNotNull(aVariant);
-
+HRESULT Medium::cloneTo(const ComPtr<IMedium> &aTarget,
+                        const std::vector<MediumVariant_T> &aVariant,
+                        const ComPtr<IMedium> &aParent,
+                        ComPtr<IProgress> &aProgress)
+{
     ComAssertRet(aTarget != this, E_INVALIDARG);
 
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<Medium> pTarget = static_cast<Medium*>(aTarget);
+    IMedium *aT = aTarget;
+    ComObjPtr<Medium> pTarget = static_cast<Medium*>(aT);
     ComObjPtr<Medium> pParent;
     if (aParent)
-        pParent = static_cast<Medium*>(aParent);
+    {
+        IMedium *aP = aParent;
+        pParent = static_cast<Medium*>(aP);
+    }
 
     HRESULT rc = S_OK;
@@ -2776 +2559 @@
         if (    pTarget->m->state != MediumState_NotCreated
             &&  pTarget->m->state != MediumState_Created)
-            throw pTarget->setStateError();
+            throw pTarget->i_setStateError();
 
         /* Build the source lock list. */
         MediumLockList *pSourceMediumLockList(new MediumLockList());
         alock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  false /* fMediumLockWrite */,
-                                  NULL,
-                                  *pSourceMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    false /* fMediumLockWrite */,
+                                    NULL,
+                                    *pSourceMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -2795 +2578 @@
         MediumLockList *pTargetMediumLockList(new MediumLockList());
         alock.release();
-        rc = pTarget->createMediumLockList(true /* fFailIfInaccessible */,
-                                           true /* fMediumLockWrite */,
-                                           pParent,
-                                           *pTargetMediumLockList);
+        rc = pTarget->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                             true /* fMediumLockWrite */,
+                                             pParent,
+                                             *pTargetMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -2816 +2599 @@
             throw setError(rc,
                            tr("Failed to lock source media '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
         alock.release();
@@ -2827 +2610 @@
             throw setError(rc,
                            tr("Failed to lock target media '%s'"),
-                           pTarget->getLocationFull().c_str());
+                           pTarget->i_getLocationFull().c_str());
         }
 
@@ -2844 +2627 @@
         ULONG mediumVariantFlags = 0;
 
-        if (aVariant)
-        {
-            com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
+        if (aVariant.size())
+        {
+            com::SafeArray<MediumVariant_T> variants(aVariant);
             for (size_t i = 0; i < variants.size(); i++)
                 mediumVariantFlags |= variants[i];
@@ -2868 +2651 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
-            pProgress.queryInterfaceTo(aProgress);
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
     else if (pTask != NULL)
@@ -2879 +2662 @@
 }
 
-STDMETHODIMP Medium::SetLocation(IN_BSTR aLocation, IProgress **aProgress)
-{
-    CheckComArgStrNotEmptyOrNull(aLocation);
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::setLocation(const com::Utf8Str &aLocation, ComPtr<IProgress> &aProgress)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2898 +2675 @@
     /// this medium), this will also require to add the mRegistered flag to data
 
-    *aProgress = NULL;
     ReturnComNotImplemented();
 }
 
-STDMETHODIMP Medium::Compact(IProgress **aProgress)
-{
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::compact(ComPtr<IProgress> &aProgress)
+{
     HRESULT rc = S_OK;
     ComObjPtr<Progress> pProgress;
@@ -2920 +2691 @@
         MediumLockList *pMediumLockList(new MediumLockList());
         alock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */ ,
-                                  true /* fMediumLockWrite */,
-                                  NULL,
-                                  *pMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */ ,
+                                    true /* fMediumLockWrite */,
+                                    NULL,
+                                    *pMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -2939 +2710 @@
             throw setError(rc,
                            tr("Failed to lock media when compacting '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -2964 +2735 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
-            pProgress.queryInterfaceTo(aProgress);
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
     else if (pTask != NULL)
@@ -2975 +2746 @@
 }
 
-STDMETHODIMP Medium::Resize(LONG64 aLogicalSize, IProgress **aProgress)
-{
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::resize(LONG64 aLogicalSize,
+                       ComPtr<IProgress> &aProgress)
+{
     HRESULT rc = S_OK;
     ComObjPtr<Progress> pProgress;
@@ -2993 +2760 @@
         MediumLockList *pMediumLockList(new MediumLockList());
         alock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */ ,
-                                  true /* fMediumLockWrite */,
-                                  NULL,
-                                  *pMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */ ,
+                                    true /* fMediumLockWrite */,
+                                    NULL,
+                                    *pMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -3012 +2779 @@
             throw setError(rc,
                            tr("Failed to lock media when compacting '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -3037 +2804 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
-            pProgress.queryInterfaceTo(aProgress);
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
     else if (pTask != NULL)
@@ -3048 +2815 @@
 }
 
-STDMETHODIMP Medium::Reset(IProgress **aProgress)
-{
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Medium::reset(ComPtr<IProgress> &aProgress)
+{
     HRESULT rc = S_OK;
     ComObjPtr<Progress> pProgress;
@@ -3073 +2835 @@
                            m->strLocationFull.c_str());
 
-        rc = canClose();
+        rc = i_canClose();
         if (FAILED(rc))
             throw rc;
@@ -3080 +2842 @@
         MediumLockList *pMediumLockList(new MediumLockList());
         multilock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  true /* fMediumLockWrite */,
-                                  NULL,
-                                  *pMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    true /* fMediumLockWrite */,
+                                    NULL,
+                                    *pMediumLockList);
         multilock.acquire();
         if (FAILED(rc))
@@ -3099 +2861 @@
             throw setError(rc,
                            tr("Failed to lock media when resetting '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -3121 +2883 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
-            pProgress.queryInterfaceTo(aProgress);
+            pProgress.queryInterfaceTo(aProgress.asOutParam());
     }
     else if (pTask != NULL)
@@ -3144 +2906 @@
  * @return
  */
-const ComObjPtr<Medium>& Medium::getParent() const
+const ComObjPtr<Medium>& Medium::i_getParent() const
 {
     return m->pParent;
@@ -3153 +2915 @@
  * @return
  */
-const MediaList& Medium::getChildren() const
+const MediaList& Medium::i_getChildren() const
 {
     return m->llChildren;
@@ -3162 +2924 @@
  * @return
  */
-const Guid& Medium::getId() const
+const Guid& Medium::i_getId() const
 {
     return m->id;
@@ -3171 +2933 @@
  * @return
  */
-MediumState_T Medium::getState() const
+MediumState_T Medium::i_getState() const
 {
     return m->state;
@@ -3180 +2942 @@
  * @return
  */
-MediumVariant_T Medium::getVariant() const
+MediumVariant_T Medium::i_getVariant() const
 {
     return m->variant;
@@ -3189 +2951 @@
  * @return
  */
-bool Medium::isHostDrive() const
+bool Medium::i_isHostDrive() const
 {
     return m->hostDrive;
@@ -3198 +2960 @@
  * @return
  */
-const Utf8Str& Medium::getLocationFull() const
+const Utf8Str& Medium::i_getLocationFull() const
 {
     return m->strLocationFull;
@@ -3207 +2969 @@
  * @return
  */
-const Utf8Str& Medium::getFormat() const
+const Utf8Str& Medium::i_getFormat() const
 {
     return m->strFormat;
@@ -3216 +2978 @@
  * @return
  */
-const ComObjPtr<MediumFormat>& Medium::getMediumFormat() const
+const ComObjPtr<MediumFormat>& Medium::i_getMediumFormat() const
 {
     return m->formatObj;
@@ -3226 +2988 @@
  * @return
  */
-bool Medium::isMediumFormatFile() const
+bool Medium::i_isMediumFormatFile() const
 {
     if (    m->formatObj
@@ -3239 +3001 @@
  * @return
  */
-uint64_t Medium::getSize() const
+uint64_t Medium::i_getSize() const
 {
     return m->size;
@@ -3248 +3010 @@
  * @return
  */
-DeviceType_T Medium::getDeviceType() const
+DeviceType_T Medium::i_getDeviceType() const
 {
     return m->devType;
@@ -3257 +3019 @@
  * @return
  */
-MediumType_T Medium::getType() const
+MediumType_T Medium::i_getType() const
 {
     return m->type;
@@ -3267 +3029 @@
  * @note Must be called from under this object's read or write lock.
  */
-Utf8Str Medium::getName()
+Utf8Str Medium::i_getName()
 {
     Utf8Str name = RTPathFilename(m->strLocationFull.c_str());
@@ -3290 +3052 @@
  * @return true if the registry was added; false if the given id was already on the list.
  */
-bool Medium::addRegistry(const Guid& id, bool fRecurse)
+bool Medium::i_addRegistry(const Guid& id, bool fRecurse)
 {
     AutoCaller autoCaller(this);
@@ -3333 +3095 @@
         {
             Medium *pChild = *it;
-            fAdd |= pChild->addRegistry(id, true);
+            fAdd |= pChild->i_addRegistry(id, true);
         }
     }
@@ -3350 +3112 @@
  * @return
  */
-bool Medium::removeRegistry(const Guid& id, bool fRecurse)
+bool Medium::i_removeRegistry(const Guid& id, bool fRecurse)
 {
     AutoCaller autoCaller(this);
@@ -3382 +3144 @@
         {
             Medium *pChild = *it;
-            fRemove |= pChild->removeRegistry(id, true);
+            fRemove |= pChild->i_removeRegistry(id, true);
         }
     }
@@ -3397 +3159 @@
  * @return
  */
-bool Medium::isInRegistry(const Guid& id)
+bool Medium::i_isInRegistry(const Guid& id)
 {
     for (GuidList::const_iterator it = m->llRegistryIDs.begin();
@@ -3435 +3197 @@
  * @return true if uuid was set.
  */
-bool Medium::getFirstRegistryMachineId(Guid &uuid) const
+bool Medium::i_getFirstRegistryMachineId(Guid &uuid) const
 {
     if (m->llRegistryIDs.size())
@@ -3448 +3210 @@
  * Marks all the registries in which this medium is registered as modified.
  */
-void Medium::markRegistriesModified()
+void Medium::i_markRegistriesModified()
 {
     AutoCaller autoCaller(this);
@@ -3479 +3241 @@
  * @param aSnapshotId   Snapshot ID; when non-empty, adds a snapshot attachment.
  */
-HRESULT Medium::addBackReference(const Guid &aMachineId,
-                                 const Guid &aSnapshotId /*= Guid::Empty*/)
+HRESULT Medium::i_addBackReference(const Guid &aMachineId,
+                                   const Guid &aSnapshotId /*= Guid::Empty*/)
 {
     AssertReturn(aMachineId.isValid(), E_FAIL);
@@ -3500 +3262 @@
 
         default:
-            return setStateError();
+            return i_setStateError();
     }
 
@@ -3551 +3313 @@
         {
 #ifdef DEBUG
-            dumpBackRefs();
+            i_dumpBackRefs();
 #endif
             return setError(VBOX_E_OBJECT_IN_USE,
@@ -3578 +3340 @@
  *                      attachment.
  */
-HRESULT Medium::removeBackReference(const Guid &aMachineId,
-                                    const Guid &aSnapshotId /*= Guid::Empty*/)
+HRESULT Medium::i_removeBackReference(const Guid &aMachineId,
+                                      const Guid &aSnapshotId /*= Guid::Empty*/)
 {
     AssertReturn(aMachineId.isValid(), E_FAIL);
@@ -3620 +3382 @@
  * @return
  */
-const Guid* Medium::getFirstMachineBackrefId() const
+const Guid* Medium::i_getFirstMachineBackrefId() const
 {
     if (!m->backRefs.size())
@@ -3636 +3398 @@
  * @return
  */
-const Guid* Medium::getAnyMachineBackref() const
+const Guid* Medium::i_getAnyMachineBackref() const
 {
     if (m->backRefs.size())
@@ -3648 +3410 @@
         // recurse for this child
         const Guid* puuid;
-        if ((puuid = pChild->getAnyMachineBackref()))
+        if ((puuid = pChild->i_getAnyMachineBackref()))
             return puuid;
     }
@@ -3655 +3417 @@
 }
 
-const Guid* Medium::getFirstMachineBackrefSnapshotId() const
+const Guid* Medium::i_getFirstMachineBackrefSnapshotId() const
 {
     if (!m->backRefs.size())
@@ -3667 +3429 @@
 }
 
-size_t Medium::getMachineBackRefCount() const
+size_t Medium::i_getMachineBackRefCount() const
 {
     return m->backRefs.size();
@@ -3677 +3439 @@
  * machine backreferences to the debug log.
  */
-void Medium::dumpBackRefs()
+void Medium::i_dumpBackRefs()
 {
     AutoCaller autoCaller(this);
@@ -3711 +3473 @@
  * @note Locks this object for writing.
  */
-HRESULT Medium::updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath)
+HRESULT Medium::i_updatePath(const Utf8Str &strOldPath, const Utf8Str &strNewPath)
 {
     AssertReturn(!strOldPath.isEmpty(), E_FAIL);
@@ -3752 +3514 @@
  * @note Locks medium tree for reading.
  */
-ComObjPtr<Medium> Medium::getBase(uint32_t *aLevel /*= NULL*/)
+ComObjPtr<Medium> Medium::i_getBase(uint32_t *aLevel /*= NULL*/)
 {
     ComObjPtr<Medium> pBase;
@@ -3794 +3556 @@
  * @note Locks this object and medium tree for reading.
  */
-bool Medium::isReadOnly()
+bool Medium::i_isReadOnly()
 {
     AutoCaller autoCaller(this);
@@ -3808 +3570 @@
         case MediumType_Normal:
         {
-            if (getChildren().size() != 0)
+            if (i_getChildren().size() != 0)
                 return true;
 
@@ -3839 +3601 @@
  * @return
  */
-void Medium::updateId(const Guid &id)
+void Medium::i_updateId(const Guid &id)
 {
     unconst(m->id) = id;
@@ -3853 +3615 @@
  * @note Locks this object, medium tree and children for reading.
  */
-HRESULT Medium::saveSettings(settings::Medium &data,
-                             const Utf8Str &strHardDiskFolder)
+HRESULT Medium::i_saveSettings(settings::Medium &data,
+                               const Utf8Str &strHardDiskFolder)
 {
     AutoCaller autoCaller(this);
@@ -3923 +3685 @@
 
     /* save all children */
-    for (MediaList::const_iterator it = getChildren().begin();
-         it != getChildren().end();
+    for (MediaList::const_iterator it = i_getChildren().begin();
+         it != i_getChildren().end();
          ++it)
     {
         settings::Medium med;
-        HRESULT rc = (*it)->saveSettings(med, strHardDiskFolder);
+        HRESULT rc = (*it)->i_saveSettings(med, strHardDiskFolder);
         AssertComRCReturnRC(rc);
         data.llChildren.push_back(med);
@@ -3948 +3710 @@
  * @param mediumLockList    Where to store the resulting list.
  */
-HRESULT Medium::createMediumLockList(bool fFailIfInaccessible,
-                                     bool fMediumLockWrite,
-                                     Medium *pToBeParent,
-                                     MediumLockList &mediumLockList)
+HRESULT Medium::i_createMediumLockList(bool fFailIfInaccessible,
+                                       bool fMediumLockWrite,
+                                       Medium *pToBeParent,
+                                       MediumLockList &mediumLockList)
 {
     Assert(!m->pVirtualBox->getMediaTreeLockHandle().isWriteLockOnCurrentThread());
@@ -3965 +3727 @@
     {
         AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        ComAssertRet(getParent().isNull(), E_FAIL);
-        ComAssertRet(getChildren().size() == 0, E_FAIL);
+        ComAssertRet(i_getParent().isNull(), E_FAIL);
+        ComAssertRet(i_getChildren().size() == 0, E_FAIL);
     }
 
@@ -3980 +3742 @@
          * with getting the medium state. Lock lists are not created for
          * fun, and thus getting the medium status is no luxury. */
-        MediumState_T mediumState = pMedium->getState();
+        MediumState_T mediumState = pMedium->i_getState();
         if (mediumState == MediumState_Inaccessible)
         {
             alock.release();
-            rc = pMedium->queryInfo(false /* fSetImageId */, false /* fSetParentId */);
+            rc = pMedium->i_queryInfo(false /* fSetImageId */, false /* fSetParentId */);
             alock.acquire();
             if (FAILED(rc)) return rc;
 
-            mediumState = pMedium->getState();
+            mediumState = pMedium->i_getState();
             if (mediumState == MediumState_Inaccessible)
             {
@@ -4018 +3780 @@
             mediumLockList.Prepend(pMedium, false);
 
-        pMedium = pMedium->getParent();
+        pMedium = pMedium->i_getParent();
         if (pMedium.isNull() && pToBeParent)
         {
@@ -4058 +3820 @@
  * @note Locks this object and @a aTarget for writing.
  */
-HRESULT Medium::createDiffStorage(ComObjPtr<Medium> &aTarget,
-                                  MediumVariant_T aVariant,
-                                  MediumLockList *aMediumLockList,
-                                  ComObjPtr<Progress> *aProgress,
-                                  bool aWait)
+HRESULT Medium::i_createDiffStorage(ComObjPtr<Medium> &aTarget,
+                                    MediumVariant_T aVariant,
+                                    MediumLockList *aMediumLockList,
+                                    ComObjPtr<Progress> *aProgress,
+                                    bool aWait)
 {
     AssertReturn(!aTarget.isNull(), E_FAIL);
@@ -4088 +3850 @@
 
         if (aTarget->m->state != MediumState_NotCreated)
-            throw aTarget->setStateError();
+            throw aTarget->i_setStateError();
 
         /* Check that the medium is not attached to the current state of
@@ -4153 +3915 @@
     {
         if (aWait)
-            rc = runNow(pTask);
+            rc = i_runNow(pTask);
         else
-            rc = startThread(pTask);
+            rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc) && aProgress != NULL)
@@ -4169 +3931 @@
  * Returns a preferred format for differencing media.
  */
-Utf8Str Medium::getPreferredDiffFormat()
+Utf8Str Medium::i_getPreferredDiffFormat()
 {
     AutoCaller autoCaller(this);
@@ -4199 +3961 @@
  * @return
  */
-HRESULT Medium::close(AutoCaller &autoCaller)
+HRESULT Medium::i_close(AutoCaller &autoCaller)
 {
     // we're accessing parent/child and backrefs, so lock the tree first, then ourselves
@@ -4206 +3968 @@
                                   COMMA_LOCKVAL_SRC_POS);
 
-    LogFlowFunc(("ENTER for %s\n", getLocationFull().c_str()));
+    LogFlowFunc(("ENTER for %s\n", i_getLocationFull().c_str()));
 
     bool wasCreated = true;
@@ -4219 +3981 @@
             break;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 
@@ -4228 +3990 @@
 
     // perform extra media-dependent close checks
-    HRESULT rc = canClose();
+    HRESULT rc = i_canClose();
     if (FAILED(rc)) return rc;
 
@@ -4236 +3998 @@
         // uninitialization (to keep the media registry consistent on
         // failure to do so)
-        rc = unregisterWithVirtualBox();
+        rc = i_unregisterWithVirtualBox();
         if (FAILED(rc)) return rc;
 
         multilock.release();
-        markRegistriesModified();
+        i_markRegistriesModified();
         // Release the AutoCalleri now, as otherwise uninit() will simply hang.
         // Needs to be done before saving the registry, as otherwise there
@@ -4288 +4050 @@
  *       writing.
  */
-HRESULT Medium::deleteStorage(ComObjPtr<Progress> *aProgress,
+HRESULT Medium::i_deleteStorage(ComObjPtr<Progress> *aProgress,
                               bool aWait)
 {
@@ -4306 +4068 @@
                                       this->lockHandle()
                                       COMMA_LOCKVAL_SRC_POS);
-        LogFlowThisFunc(("aWait=%RTbool locationFull=%s\n", aWait, getLocationFull().c_str() ));
+        LogFlowThisFunc(("aWait=%RTbool locationFull=%s\n", aWait, i_getLocationFull().c_str() ));
 
         if (    !(m->formatObj->i_getCapabilities() & (   MediumFormatCapabilities_CreateDynamic
@@ -4329 +4091 @@
                 break;
             default:
-                throw setStateError();
+                throw i_setStateError();
         }
 
@@ -4345 +4107 @@
             }
 #ifdef DEBUG
-            dumpBackRefs();
+            i_dumpBackRefs();
 #endif
             throw setError(VBOX_E_OBJECT_IN_USE,
@@ -4354 +4116 @@
         }
 
-        rc = canClose();
+        rc = i_canClose();
         if (FAILED(rc))
             throw rc;
@@ -4361 +4123 @@
         if (m->state != MediumState_Deleting)
         {
-            rc = markForDeletion();
+            rc = i_markForDeletion();
             if (FAILED(rc))
                 throw rc;
@@ -4369 +4131 @@
         MediumLockList *pMediumLockList(new MediumLockList());
         multilock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  true /* fMediumLockWrite */,
-                                  NULL,
-                                  *pMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    true /* fMediumLockWrite */,
+                                    NULL,
+                                    *pMediumLockList);
         multilock.acquire();
         if (FAILED(rc))
@@ -4388 +4150 @@
             throw setError(rc,
                            tr("Failed to lock media when deleting '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -4395 +4157 @@
          * which would have been broken if unregisterWithVirtualBox() failed
          * after we successfully deleted the storage) */
-        rc = unregisterWithVirtualBox();
+        rc = i_unregisterWithVirtualBox();
         if (FAILED(rc))
             throw rc;
         // no longer need lock
         multilock.release();
-        markRegistriesModified();
+        i_markRegistriesModified();
 
         if (aProgress != NULL)
@@ -4432 +4194 @@
     {
         if (aWait)
-            rc = runNow(pTask);
+            rc = i_runNow(pTask);
         else
-            rc = startThread(pTask);
+            rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc) && aProgress != NULL)
@@ -4452 +4214 @@
          * for deletion when the error was thrown above. */
         ErrorInfoKeeper eik;
-        unmarkForDeletion();
+        i_unmarkForDeletion();
     }
 
@@ -4463 +4225 @@
  * @note Caller must hold the write lock on this medium!
  */
-HRESULT Medium::markForDeletion()
+HRESULT Medium::i_markForDeletion()
 {
     ComAssertRet(isWriteLockOnCurrentThread(), E_FAIL);
@@ -4474 +4236 @@
             return S_OK;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 }
@@ -4483 +4245 @@
  * @note Caller must hold the write lock on this medium!
  */
-HRESULT Medium::unmarkForDeletion()
+HRESULT Medium::i_unmarkForDeletion()
 {
     ComAssertRet(isWriteLockOnCurrentThread(), E_FAIL);
@@ -4492 +4254 @@
             return S_OK;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 }
@@ -4501 +4263 @@
  * @note Caller must hold the write lock on this medium!
  */
-HRESULT Medium::markLockedForDeletion()
+HRESULT Medium::i_markLockedForDeletion()
 {
     ComAssertRet(isWriteLockOnCurrentThread(), E_FAIL);
@@ -4512 +4274 @@
     }
     else
-        return setStateError();
+        return i_setStateError();
 }
 
@@ -4520 +4282 @@
  * @note Caller must hold the write lock on this medium!
  */
-HRESULT Medium::unmarkLockedForDeletion()
+HRESULT Medium::i_unmarkLockedForDeletion()
 {
     ComAssertRet(isWriteLockOnCurrentThread(), E_FAIL);
@@ -4531 +4293 @@
     }
     else
-        return setStateError();
+        return i_setStateError();
 }
 
@@ -4549 +4311 @@
  * @param fMergeForward    Resulting preferred merge direction (out).
  */
-HRESULT Medium::queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
-                                             bool &fMergeForward)
+HRESULT Medium::i_queryPreferredMergeDirection(const ComObjPtr<Medium> &pOther,
+                                               bool &fMergeForward)
 {
     AssertReturn(pOther != NULL, E_FAIL);
@@ -4570 +4332 @@
 
         /* more sanity checking and figuring out the current merge direction */
-        ComObjPtr<Medium> pMedium = getParent();
+        ComObjPtr<Medium> pMedium = i_getParent();
         while (!pMedium.isNull() && pMedium != pOther)
-            pMedium = pMedium->getParent();
+            pMedium = pMedium->i_getParent();
         if (pMedium == pOther)
             fThisParent = false;
         else
         {
-            pMedium = pOther->getParent();
+            pMedium = pOther->i_getParent();
             while (!pMedium.isNull() && pMedium != this)
-                pMedium = pMedium->getParent();
+                pMedium = pMedium->i_getParent();
             if (pMedium == this)
                 fThisParent = true;
@@ -4587 +4349 @@
                 {
                     AutoReadLock alock(pOther COMMA_LOCKVAL_SRC_POS);
-                    tgtLoc = pOther->getLocationFull();
+                    tgtLoc = pOther->i_getLocationFull();
                 }
 
@@ -4609 +4371 @@
         uint64_t cbMediumOther = 0;
 
-        if (isMediumFormatFile() && pOther->isMediumFormatFile())
-        {
-            vrc = RTFileQuerySize(this->getLocationFull().c_str(), &cbMediumThis);
+        if (i_isMediumFormatFile() && pOther->i_isMediumFormatFile())
+        {
+            vrc = RTFileQuerySize(this->i_getLocationFull().c_str(), &cbMediumThis);
             if (RT_SUCCESS(vrc))
             {
-                vrc = RTFileQuerySize(pOther->getLocationFull().c_str(),
+                vrc = RTFileQuerySize(pOther->i_getLocationFull().c_str(),
                                       &cbMediumOther);
             }
@@ -4668 +4430 @@
  *       intermediate media for writing.
  */
-HRESULT Medium::prepareMergeTo(const ComObjPtr<Medium> &pTarget,
-                               const Guid *aMachineId,
-                               const Guid *aSnapshotId,
-                               bool fLockMedia,
-                               bool &fMergeForward,
-                               ComObjPtr<Medium> &pParentForTarget,
-                               MediumLockList * &aChildrenToReparent,
-                               MediumLockList * &aMediumLockList)
+HRESULT Medium::i_prepareMergeTo(const ComObjPtr<Medium> &pTarget,
+                                 const Guid *aMachineId,
+                                 const Guid *aSnapshotId,
+                                 bool fLockMedia,
+                                 bool &fMergeForward,
+                                 ComObjPtr<Medium> &pParentForTarget,
+                                 MediumLockList * &aChildrenToReparent,
+                                 MediumLockList * &aMediumLockList)
 {
     AssertReturn(pTarget != NULL, E_FAIL);
@@ -4700 +4462 @@
 
         /* more sanity checking and figuring out the merge direction */
-        ComObjPtr<Medium> pMedium = getParent();
+        ComObjPtr<Medium> pMedium = i_getParent();
         while (!pMedium.isNull() && pMedium != pTarget)
-            pMedium = pMedium->getParent();
+            pMedium = pMedium->i_getParent();
         if (pMedium == pTarget)
             fMergeForward = false;
         else
         {
-            pMedium = pTarget->getParent();
+            pMedium = pTarget->i_getParent();
             while (!pMedium.isNull() && pMedium != this)
-                pMedium = pMedium->getParent();
+                pMedium = pMedium->i_getParent();
             if (pMedium == this)
                 fMergeForward = true;
@@ -4717 +4479 @@
                 {
                     AutoReadLock alock(pTarget COMMA_LOCKVAL_SRC_POS);
-                    tgtLoc = pTarget->getLocationFull();
+                    tgtLoc = pTarget->i_getLocationFull();
                 }
 
@@ -4731 +4493 @@
         treeLock.release();
         if (fMergeForward)
-            rc = pTarget->createMediumLockList(true /* fFailIfInaccessible */,
-                                               true /* fMediumLockWrite */,
-                                               NULL,
-                                               *aMediumLockList);
+            rc = pTarget->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                                 true /* fMediumLockWrite */,
+                                                 NULL,
+                                                 *aMediumLockList);
         else
-            rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                      false /* fMediumLockWrite */,
-                                      NULL,
-                                      *aMediumLockList);
+            rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                        false /* fMediumLockWrite */,
+                                        NULL,
+                                        *aMediumLockList);
         treeLock.acquire();
         if (FAILED(rc))
@@ -4754 +4516 @@
                 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
                 if (m->state != MediumState_Created)
-                    throw setStateError();
+                    throw i_setStateError();
             }
             {
                 AutoReadLock alock(pTarget COMMA_LOCKVAL_SRC_POS);
                 if (pTarget->m->state != MediumState_Created)
-                    throw pTarget->setStateError();
+                    throw pTarget->i_setStateError();
             }
         }
@@ -4767 +4529 @@
         {
             AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-            if (getChildren().size() > 1)
+            if (i_getChildren().size() > 1)
             {
                 throw setError(VBOX_E_INVALID_OBJECT_STATE,
                                tr("Medium '%s' involved in the merge operation has more than one child medium (%d)"),
-                               m->strLocationFull.c_str(), getChildren().size());
+                               m->strLocationFull.c_str(), i_getChildren().size());
             }
             /* One backreference is only allowed if the machine ID is not empty
@@ -4780 +4542 @@
                     || m->backRefs.size() != 1
                     || aMachineId->isZero()
-                    || *getFirstMachineBackrefId() != *aMachineId
+                    || *i_getFirstMachineBackrefId() != *aMachineId
                     || (   (!aSnapshotId || !aSnapshotId->isZero())
-                        && *getFirstMachineBackrefSnapshotId() != *aSnapshotId)))
+                        && *i_getFirstMachineBackrefSnapshotId() != *aSnapshotId)))
                 throw setError(VBOX_E_OBJECT_IN_USE,
                                tr("Medium '%s' is attached to %d virtual machines"),
@@ -4798 +4560 @@
         {
             AutoReadLock alock(pTarget COMMA_LOCKVAL_SRC_POS);
-            if (pTarget->getChildren().size() > 1)
+            if (pTarget->i_getChildren().size() > 1)
             {
                 throw setError(VBOX_E_OBJECT_IN_USE,
                                tr("Medium '%s' involved in the merge operation has more than one child medium (%d)"),
                                pTarget->m->strLocationFull.c_str(),
-                               pTarget->getChildren().size());
+                               pTarget->i_getChildren().size());
             }
             if (pTarget->m->type == MediumType_Immutable)
@@ -4815 +4577 @@
         }
         ComObjPtr<Medium> pLast(fMergeForward ? (Medium *)pTarget : this);
-        ComObjPtr<Medium> pLastIntermediate = pLast->getParent();
+        ComObjPtr<Medium> pLastIntermediate = pLast->i_getParent();
         for (pLast = pLastIntermediate;
              !pLast.isNull() && pLast != pTarget && pLast != this;
-             pLast = pLast->getParent())
+             pLast = pLast->i_getParent())
         {
             AutoReadLock alock(pLast COMMA_LOCKVAL_SRC_POS);
-            if (pLast->getChildren().size() > 1)
+            if (pLast->i_getChildren().size() > 1)
             {
                 throw setError(VBOX_E_OBJECT_IN_USE,
                                tr("Medium '%s' involved in the merge operation has more than one child medium (%d)"),
                                pLast->m->strLocationFull.c_str(),
-                               pLast->getChildren().size());
+                               pLast->i_getChildren().size());
             }
             if (pLast->m->backRefs.size() != 0)
@@ -4842 +4604 @@
             if (m->state == MediumState_Created)
             {
-                rc = markForDeletion();
+                rc = i_markForDeletion();
                 if (FAILED(rc))
                     throw rc;
@@ -4849 +4611 @@
             {
                 if (fLockMedia)
-                    throw setStateError();
+                    throw i_setStateError();
                 else if (   m->state == MediumState_LockedWrite
                          || m->state == MediumState_LockedRead)
@@ -4856 +4618 @@
                      * others to have done so. */
                     if (m->preLockState == MediumState_Created)
-                        markLockedForDeletion();
+                        i_markLockedForDeletion();
                     else if (m->preLockState != MediumState_Deleting)
-                        throw setStateError();
+                        throw i_setStateError();
                 }
                 else
-                    throw setStateError();
+                    throw i_setStateError();
             }
         }
@@ -4868 +4630 @@
         {
             /* we will need parent to reparent target */
-            pParentForTarget = getParent();
+            pParentForTarget = i_getParent();
         }
         else
@@ -4874 +4636 @@
             /* we will need to reparent children of the source */
             aChildrenToReparent = new MediumLockList();
-            for (MediaList::const_iterator it = getChildren().begin();
-                 it != getChildren().end();
+            for (MediaList::const_iterator it = i_getChildren().begin();
+                 it != i_getChildren().end();
                  ++it)
             {
@@ -4892 +4654 @@
         for (pLast = pLastIntermediate;
              !pLast.isNull() && pLast != pTarget && pLast != this;
-             pLast = pLast->getParent())
+             pLast = pLast->i_getParent())
         {
             AutoWriteLock alock(pLast COMMA_LOCKVAL_SRC_POS);
             if (pLast->m->state == MediumState_Created)
             {
-                rc = pLast->markForDeletion();
+                rc = pLast->i_markForDeletion();
                 if (FAILED(rc))
                     throw rc;
             }
             else
-                throw pLast->setStateError();
+                throw pLast->i_setStateError();
         }
 
@@ -4938 +4700 @@
                 throw setError(rc,
                                tr("Failed to lock media when merging to '%s'"),
-                               pTarget->getLocationFull().c_str());
+                               pTarget->i_getLocationFull().c_str());
             }
         }
@@ -5037 +4799 @@
  *       for writing.
  */
-HRESULT Medium::mergeTo(const ComObjPtr<Medium> &pTarget,
-                        bool fMergeForward,
-                        const ComObjPtr<Medium> &pParentForTarget,
-                        MediumLockList *aChildrenToReparent,
-                        MediumLockList *aMediumLockList,
-                        ComObjPtr<Progress> *aProgress,
-                        bool aWait)
+HRESULT Medium::i_mergeTo(const ComObjPtr<Medium> &pTarget,
+                          bool fMergeForward,
+                          const ComObjPtr<Medium> &pParentForTarget,
+                          MediumLockList *aChildrenToReparent,
+                          MediumLockList *aMediumLockList,
+                          ComObjPtr<Progress> *aProgress,
+                          bool aWait)
 {
     AssertReturn(pTarget != NULL, E_FAIL);
@@ -5073 +4835 @@
                 {
                     AutoReadLock alock(pTarget COMMA_LOCKVAL_SRC_POS);
-                    tgtName = pTarget->getName();
+                    tgtName = pTarget->i_getName();
                 }
 
@@ -5082 +4844 @@
                                      static_cast<IMedium*>(this),
                                      BstrFmt(tr("Merging medium '%s' to '%s'"),
-                                             getName().c_str(),
+                                             i_getName().c_str(),
                                              tgtName.c_str()).raw(),
                                      TRUE /* aCancelable */);
@@ -5105 +4867 @@
     {
         if (aWait)
-            rc = runNow(pTask);
+            rc = i_runNow(pTask);
         else
-            rc = startThread(pTask);
+            rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc) && aProgress != NULL)
@@ -5129 +4891 @@
  * @note Locks the media from the chain for writing.
  */
-void Medium::cancelMergeTo(MediumLockList *aChildrenToReparent,
-                           MediumLockList *aMediumLockList)
+void Medium::i_cancelMergeTo(MediumLockList *aChildrenToReparent,
+                             MediumLockList *aMediumLockList)
 {
     AutoCaller autoCaller(this);
@@ -5153 +4915 @@
         if (pMedium->m->state == MediumState_Deleting)
         {
-            rc = pMedium->unmarkForDeletion();
+            rc = pMedium->i_unmarkForDeletion();
             AssertComRC(rc);
         }
@@ -5171 +4933 @@
  * parent.
  */
-HRESULT Medium::fixParentUuidOfChildren(MediumLockList *pChildrenToReparent)
+HRESULT Medium::i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent)
 {
     Assert(!isWriteLockOnCurrentThread());
     Assert(!m->pVirtualBox->getMediaTreeLockHandle().isWriteLockOnCurrentThread());
     MediumLockList mediumLockList;
-    HRESULT rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                      false /* fMediumLockWrite */,
-                                      this,
-                                      mediumLockList);
+    HRESULT rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                        false /* fMediumLockWrite */,
+                                        this,
+                                        mediumLockList);
     AssertComRCReturnRC(rc);
 
@@ -5185 +4947 @@
     {
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -5243 +5005 @@
                           tr("Could not update medium UUID references to parent '%s' (%s)"),
                           m->strLocationFull.c_str(),
-                          vdError(aVRC).c_str());
+                          i_vdError(aVRC).c_str());
         }
 
@@ -5267 +5029 @@
  * @note The source format is defined by the Medium instance.
  */
-HRESULT Medium::exportFile(const char *aFilename,
-                           const ComObjPtr<MediumFormat> &aFormat,
-                           MediumVariant_T aVariant,
-                           PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
-                           const ComObjPtr<Progress> &aProgress)
+HRESULT Medium::i_exportFile(const char *aFilename,
+                             const ComObjPtr<MediumFormat> &aFormat,
+                             MediumVariant_T aVariant,
+                             PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+                             const ComObjPtr<Progress> &aProgress)
 {
     AssertPtrReturn(aFilename, E_INVALIDARG);
@@ -5289 +5051 @@
         /* Build the source lock list. */
         MediumLockList *pSourceMediumLockList(new MediumLockList());
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  false /* fMediumLockWrite */,
-                                  NULL,
-                                  *pSourceMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    false /* fMediumLockWrite */,
+                                    NULL,
+                                    *pSourceMediumLockList);
         if (FAILED(rc))
         {
@@ -5305 +5067 @@
             throw setError(rc,
                            tr("Failed to lock source media '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -5320 +5082 @@
 
     if (SUCCEEDED(rc))
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
     else if (pTask != NULL)
         delete pTask;
@@ -5342 +5104 @@
  * @note The destination format is defined by the Medium instance.
  */
-HRESULT Medium::importFile(const char *aFilename,
-                           const ComObjPtr<MediumFormat> &aFormat,
-                           MediumVariant_T aVariant,
-                           PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
-                           const ComObjPtr<Medium> &aParent,
-                           const ComObjPtr<Progress> &aProgress)
+HRESULT Medium::i_importFile(const char *aFilename,
+                             const ComObjPtr<MediumFormat> &aFormat,
+                             MediumVariant_T aVariant,
+                             PVDINTERFACEIO aVDImageIOIf, void *aVDImageIOUser,
+                             const ComObjPtr<Medium> &aParent,
+                             const ComObjPtr<Progress> &aProgress)
 {
     AssertPtrReturn(aFilename, E_INVALIDARG);
@@ -5375 +5137 @@
         if (   m->state != MediumState_NotCreated
             && m->state != MediumState_Created)
-            throw setStateError();
+            throw i_setStateError();
 
         /* Build the target lock list. */
         MediumLockList *pTargetMediumLockList(new MediumLockList());
         alock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  true /* fMediumLockWrite */,
-                                  aParent,
-                                  *pTargetMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    true /* fMediumLockWrite */,
+                                    aParent,
+                                    *pTargetMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -5399 +5161 @@
             throw setError(rc,
                            tr("Failed to lock target media '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
 
@@ -5418 +5180 @@
 
     if (SUCCEEDED(rc))
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
     else if (pTask != NULL)
         delete pTask;
@@ -5442 +5204 @@
  * @return
  */
-HRESULT Medium::cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
-                          const ComObjPtr<Medium> &aParent, IProgress **aProgress,
-                          uint32_t idxSrcImageSame, uint32_t idxDstImageSame)
+HRESULT Medium::i_cloneToEx(const ComObjPtr<Medium> &aTarget, ULONG aVariant,
+                            const ComObjPtr<Medium> &aParent, IProgress **aProgress,
+                            uint32_t idxSrcImageSame, uint32_t idxDstImageSame)
 {
     CheckComArgNotNull(aTarget);
@@ -5474 +5236 @@
         if (    aTarget->m->state != MediumState_NotCreated
             &&  aTarget->m->state != MediumState_Created)
-            throw aTarget->setStateError();
+            throw aTarget->i_setStateError();
 
         /* Build the source lock list. */
         MediumLockList *pSourceMediumLockList(new MediumLockList());
         alock.release();
-        rc = createMediumLockList(true /* fFailIfInaccessible */,
-                                  false /* fMediumLockWrite */,
-                                  NULL,
-                                  *pSourceMediumLockList);
+        rc = i_createMediumLockList(true /* fFailIfInaccessible */,
+                                    false /* fMediumLockWrite */,
+                                    NULL,
+                                    *pSourceMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -5493 +5255 @@
         MediumLockList *pTargetMediumLockList(new MediumLockList());
         alock.release();
-        rc = aTarget->createMediumLockList(true /* fFailIfInaccessible */,
-                                           true /* fMediumLockWrite */,
-                                           aParent,
-                                           *pTargetMediumLockList);
+        rc = aTarget->i_createMediumLockList(true /* fFailIfInaccessible */,
+                                             true /* fMediumLockWrite */,
+                                             aParent,
+                                             *pTargetMediumLockList);
         alock.acquire();
         if (FAILED(rc))
@@ -5514 +5276 @@
             throw setError(rc,
                            tr("Failed to lock source media '%s'"),
-                           getLocationFull().c_str());
+                           i_getLocationFull().c_str());
         }
         alock.release();
@@ -5525 +5287 @@
             throw setError(rc,
                            tr("Failed to lock target media '%s'"),
-                           aTarget->getLocationFull().c_str());
+                           aTarget->i_getLocationFull().c_str());
         }
 
@@ -5558 +5320 @@
     if (SUCCEEDED(rc))
     {
-        rc = startThread(pTask);
+        rc = i_startThread(pTask);
 
         if (SUCCEEDED(rc))
@@ -5592 +5354 @@
  * @return
  */
-HRESULT Medium::queryInfo(bool fSetImageId, bool fSetParentId)
+HRESULT Medium::i_queryInfo(bool fSetImageId, bool fSetParentId)
 {
     Assert(!isWriteLockOnCurrentThread());
@@ -5702 +5464 @@
 
         PVBOXHDD hdd;
-        vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -5718 +5480 @@
             {
                 lastAccessError = Utf8StrFmt(tr("Could not open the medium '%s'%s"),
-                                             location.c_str(), vdError(vrc).c_str());
+                                             location.c_str(), i_vdError(vrc).c_str());
                 throw S_OK;
             }
@@ -5734 +5496 @@
                     {
                         lastAccessError = Utf8StrFmt(tr("Could not update the UUID of medium '%s'%s"),
-                                         location.c_str(), vdError(vrc).c_str());
+                                         location.c_str(), i_vdError(vrc).c_str());
                         throw S_OK;
                     }
@@ -5747 +5509 @@
                     {
                         lastAccessError = Utf8StrFmt(tr("Could not update the parent UUID of medium '%s'%s"),
-                                         location.c_str(), vdError(vrc).c_str());
+                                         location.c_str(), i_vdError(vrc).c_str());
                         throw S_OK;
                     }
@@ -5879 +5641 @@
 
                     if (m->pParent)
-                        deparent();
-                    setParent(pParent);
+                        i_deparent();
+                    i_setParent(pParent);
 
                     treeLock.release();
@@ -5918 +5680 @@
                         AutoReadLock parentLock(m->pParent COMMA_LOCKVAL_SRC_POS);
                         if (   !fRepairImageZeroParentUuid
-                            && m->pParent->getState() != MediumState_Inaccessible
-                            && m->pParent->getId() != parentId)
+                            && m->pParent->i_getState() != MediumState_Inaccessible
+                            && m->pParent->i_getId() != parentId)
                         {
                             /** @todo r=klaus this always refers to VirtualBox.xml as the medium registry, even for new VMs */
@@ -5925 +5687 @@
                                     tr("Parent UUID {%RTuuid} of the medium '%s' does not match UUID {%RTuuid} of its parent medium stored in the media registry ('%s')"),
                                     &parentId, location.c_str(),
-                                    m->pParent->getId().raw(),
+                                    m->pParent->i_getId().raw(),
                                     m->pVirtualBox->settingsFilePath().c_str());
                             parentLock.release();
@@ -5955 +5717 @@
         {
             lastAccessError = Utf8StrFmt(tr("Could not update and close the medium '%s'%s"),
-                                         location.c_str(), vdError(vrc).c_str());
+                                         location.c_str(), i_vdError(vrc).c_str());
             success = false;
             throw S_OK;
@@ -6013 +5775 @@
         {
             PVBOXHDD hdd;
-            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+            vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
             ComAssertRCThrow(vrc, E_FAIL);
 
@@ -6060 +5822 @@
  * @note Caller must hold the media tree write lock!
  */
-HRESULT Medium::canClose()
+HRESULT Medium::i_canClose()
 {
     Assert(m->pVirtualBox->getMediaTreeLockHandle().isWriteLockOnCurrentThread());
 
-    if (getChildren().size() != 0)
+    if (i_getChildren().size() != 0)
         return setError(VBOX_E_OBJECT_IN_USE,
                         tr("Cannot close medium '%s' because it has %d child media"),
-                        m->strLocationFull.c_str(), getChildren().size());
+                        m->strLocationFull.c_str(), i_getChildren().size());
 
     return S_OK;
@@ -6077 +5839 @@
  * @note Caller must have locked the media tree lock for writing!
  */
-HRESULT Medium::unregisterWithVirtualBox()
+HRESULT Medium::i_unregisterWithVirtualBox()
 {
     /* Note that we need to de-associate ourselves from the parent to let
@@ -6086 +5848 @@
 
     Medium *pParentBackup = m->pParent;
-    AssertReturn(getChildren().size() == 0, E_FAIL);
+    AssertReturn(i_getChildren().size() == 0, E_FAIL);
     if (m->pParent)
-        deparent();
+        i_deparent();
 
     HRESULT rc = m->pVirtualBox->unregisterMedium(this);
@@ -6107 +5869 @@
  * Like SetProperty but do not trigger a settings store. Only for internal use!
  */
-HRESULT Medium::setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue)
+HRESULT Medium::i_setPropertyDirect(const Utf8Str &aName, const Utf8Str &aValue)
 {
     AutoCaller autoCaller(this);
@@ -6120 +5882 @@
             break;
         default:
-            return setStateError();
+            return i_setStateError();
     }
 
@@ -6133 +5895 @@
  * @note Must be called from under this object's write or read lock.
  */
-HRESULT Medium::setStateError()
+HRESULT Medium::i_setStateError()
 {
     HRESULT rc = E_FAIL;
@@ -6222 +5984 @@
  * @note Must be called from under this object's write lock.
  */
-HRESULT Medium::setLocation(const Utf8Str &aLocation,
+HRESULT Medium::i_setLocation(const Utf8Str &aLocation,
                             const Utf8Str &aFormat /* = Utf8Str::Empty */)
 {
@@ -6334 +6096 @@
                 else
                 {
-                    HRESULT rc = setFormat(aFormat);
+                    HRESULT rc = i_setFormat(aFormat);
                     /* setFormat() must not fail since we've just used the backend so
                      * the format object must be there */
@@ -6341 +6103 @@
             }
             else if (   enmType == VDTYPE_INVALID
-                     || m->devType != convertToDeviceType(enmType))
+                     || m->devType != i_convertToDeviceType(enmType))
             {
                 /*
@@ -6355 +6117 @@
                 ComAssertRet(backendName != NULL && *backendName != '\0', E_FAIL);
 
-                HRESULT rc = setFormat(backendName);
+                HRESULT rc = i_setFormat(backendName);
                 RTStrFree(backendName);
 
@@ -6391 +6153 @@
  * @note Must be called from under this object's write lock.
  */
-HRESULT Medium::setFormat(const Utf8Str &aFormat)
+HRESULT Medium::i_setFormat(const Utf8Str &aFormat)
 {
     /* get the format object first */
@@ -6431 +6193 @@
  * Converts the Medium device type to the VD type.
  */
-VDTYPE Medium::convertDeviceType()
+VDTYPE Medium::i_convertDeviceType()
 {
     VDTYPE enmType;
@@ -6456 +6218 @@
  * Converts from the VD type to the medium type.
  */
-DeviceType_T Medium::convertToDeviceType(VDTYPE enmType)
+DeviceType_T Medium::i_convertToDeviceType(VDTYPE enmType)
 {
     DeviceType_T devType;
@@ -6479 +6241 @@
 
 /**
- * Returns the last error message collected by the vdErrorCall callback and
+ * Returns the last error message collected by the i_vdErrorCall callback and
  * resets it.
  *
@@ -6489 +6251 @@
  * format string is given @a aVRC as an argument.
  *
- * If there is no last error message collected by vdErrorCall or if it is a
+ * If there is no last error message collected by i_vdErrorCall or if it is a
  * null or empty string, then this function returns the following text:
  * <code>
@@ -6500 +6262 @@
  * @param aVRC  VBox error code to use when no error message is provided.
  */
-Utf8Str Medium::vdError(int aVRC)
+Utf8Str Medium::i_vdError(int aVRC)
 {
     Utf8Str error;
@@ -6529 +6291 @@
  */
 /*static*/
-DECLCALLBACK(void) Medium::vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
-                                       const char *pszFormat, va_list va)
+DECLCALLBACK(void) Medium::i_vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
+                                         const char *pszFormat, va_list va)
 {
     NOREF(pszFile); NOREF(iLine); NOREF(pszFunction); /* RT_SRC_POS_DECL */
@@ -6547 +6309 @@
 
 /* static */
-DECLCALLBACK(bool) Medium::vdConfigAreKeysValid(void *pvUser,
-                                                const char * /* pszzValid */)
+DECLCALLBACK(bool) Medium::i_vdConfigAreKeysValid(void *pvUser,
+                                                  const char * /* pszzValid */)
 {
     Medium *that = static_cast<Medium*>(pvUser);
@@ -6559 +6321 @@
 
 /* static */
-DECLCALLBACK(int) Medium::vdConfigQuerySize(void *pvUser,
-                                            const char *pszName,
-                                            size_t *pcbValue)
+DECLCALLBACK(int) Medium::i_vdConfigQuerySize(void *pvUser,
+                                              const char *pszName,
+                                              size_t *pcbValue)
 {
     AssertReturn(VALID_PTR(pcbValue), VERR_INVALID_POINTER);
@@ -6582 +6344 @@
 
 /* static */
-DECLCALLBACK(int) Medium::vdConfigQuery(void *pvUser,
-                                        const char *pszName,
-                                        char *pszValue,
-                                        size_t cchValue)
+DECLCALLBACK(int) Medium::i_vdConfigQuery(void *pvUser,
+                                          const char *pszName,
+                                          char *pszValue,
+                                          size_t cchValue)
 {
     AssertReturn(VALID_PTR(pszValue), VERR_INVALID_POINTER);
@@ -6609 +6371 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock)
+DECLCALLBACK(int) Medium::i_vdTcpSocketCreate(uint32_t fFlags, PVDSOCKET pSock)
 {
     PVDSOCKETINT pSocketInt = NULL;
@@ -6625 +6387 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpSocketDestroy(VDSOCKET Sock)
+DECLCALLBACK(int) Medium::i_vdTcpSocketDestroy(VDSOCKET Sock)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6637 +6399 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort)
+DECLCALLBACK(int) Medium::i_vdTcpClientConnect(VDSOCKET Sock, const char *pszAddress, uint32_t uPort)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6644 +6406 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpClientClose(VDSOCKET Sock)
+DECLCALLBACK(int) Medium::i_vdTcpClientClose(VDSOCKET Sock)
 {
     int rc = VINF_SUCCESS;
@@ -6654 +6416 @@
 }
 
-DECLCALLBACK(bool) Medium::vdTcpIsClientConnected(VDSOCKET Sock)
+DECLCALLBACK(bool) Medium::i_vdTcpIsClientConnected(VDSOCKET Sock)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6660 +6422 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies)
+DECLCALLBACK(int) Medium::i_vdTcpSelectOne(VDSOCKET Sock, RTMSINTERVAL cMillies)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6666 +6428 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
+DECLCALLBACK(int) Medium::i_vdTcpRead(VDSOCKET Sock, void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6672 +6434 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
+DECLCALLBACK(int) Medium::i_vdTcpWrite(VDSOCKET Sock, const void *pvBuffer, size_t cbBuffer)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6678 +6440 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf)
+DECLCALLBACK(int) Medium::i_vdTcpSgWrite(VDSOCKET Sock, PCRTSGBUF pSgBuf)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6684 +6446 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpFlush(VDSOCKET Sock)
+DECLCALLBACK(int) Medium::i_vdTcpFlush(VDSOCKET Sock)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6690 +6452 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable)
+DECLCALLBACK(int) Medium::i_vdTcpSetSendCoalescing(VDSOCKET Sock, bool fEnable)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6696 +6458 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr)
+DECLCALLBACK(int) Medium::i_vdTcpGetLocalAddress(VDSOCKET Sock, PRTNETADDR pAddr)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6702 +6464 @@
 }
 
-DECLCALLBACK(int) Medium::vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr)
+DECLCALLBACK(int) Medium::i_vdTcpGetPeerAddress(VDSOCKET Sock, PRTNETADDR pAddr)
 {
     PVDSOCKETINT pSocketInt = (PVDSOCKETINT)Sock;
@@ -6716 +6478 @@
  *       other threads asynchronously waiting for it.
  */
-HRESULT Medium::startThread(Medium::Task *pTask)
+HRESULT Medium::i_startThread(Medium::Task *pTask)
 {
 #ifdef VBOX_WITH_MAIN_LOCK_VALIDATION
@@ -6754 +6516 @@
  *       complete the progress object in this case.
  */
-HRESULT Medium::runNow(Medium::Task *pTask)
+HRESULT Medium::i_runNow(Medium::Task *pTask)
 {
 #ifdef VBOX_WITH_MAIN_LOCK_VALIDATION
@@ -6778 +6540 @@
  * @return
  */
-HRESULT Medium::taskCreateBaseHandler(Medium::CreateBaseTask &task)
+HRESULT Medium::i_taskCreateBaseHandler(Medium::CreateBaseTask &task)
 {
     HRESULT rc = S_OK;
@@ -6811 +6573 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -6844 +6606 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not create the medium storage unit '%s'%s"),
-                               location.c_str(), vdError(vrc).c_str());
+                               location.c_str(), i_vdError(vrc).c_str());
 
             size = VDGetFileSize(hdd, 0);
@@ -6882 +6644 @@
 
         thisLock.release();
-        markRegistriesModified();
+        i_markRegistriesModified();
         if (task.isAsync())
         {
@@ -6914 +6676 @@
  * @return
  */
-HRESULT Medium::taskCreateDiffHandler(Medium::CreateDiffTask &task)
+HRESULT Medium::i_taskCreateDiffHandler(Medium::CreateDiffTask &task)
 {
     HRESULT rcTmp = S_OK;
@@ -6952 +6714 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -6992 +6754 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
 
@@ -7016 +6778 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                 tr("Could not create the differencing medium storage unit '%s'%s"),
-                                targetLocation.c_str(), vdError(vrc).c_str());
+                                targetLocation.c_str(), i_vdError(vrc).c_str());
 
             size = VDGetFileSize(hdd, VD_LAST_IMAGE);
@@ -7046 +6808 @@
             * potential race! */
         /* diffs for immutable media are auto-reset by default */
-        pTarget->m->autoReset = (getBase()->m->type == MediumType_Immutable);
+        pTarget->m->autoReset = (i_getBase()->m->type == MediumType_Immutable);
 
         /* register with mVirtualBox as the last step and move to
@@ -7057 +6819 @@
         if (FAILED(mrc))
             /* break the parent association on failure to register */
-            deparent();
+            i_deparent();
     }
 
@@ -7087 +6849 @@
 
     mediaLock.release();
-    markRegistriesModified();
+    i_markRegistriesModified();
     if (task.isAsync())
     {
@@ -7112 +6874 @@
  * @return
  */
-HRESULT Medium::taskMergeHandler(Medium::MergeTask &task)
+HRESULT Medium::i_taskMergeHandler(Medium::MergeTask &task)
 {
     HRESULT rcTmp = S_OK;
@@ -7121 +6883 @@
     {
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7249 +7011 @@
                              m->strLocationFull.c_str(),
                              pTarget->m->strLocationFull.c_str(),
-                             vdError(aVRC).c_str());
+                             i_vdError(aVRC).c_str());
         }
 
@@ -7276 +7038 @@
             /* then, reparent it and disconnect the deleted branch at
              * both ends (chain->parent() is source's parent) */
-            pTarget->deparent();
+            pTarget->i_deparent();
             pTarget->m->pParent = task.mParentForTarget;
             if (pTarget->m->pParent)
             {
                 pTarget->m->pParent->m->llChildren.push_back(pTarget);
-                deparent();
+                i_deparent();
             }
 
@@ -7292 +7054 @@
         else
         {
-            Assert(pTarget->getChildren().size() == 1);
-            Medium *targetChild = pTarget->getChildren().front();
+            Assert(pTarget->i_getChildren().size() == 1);
+            Medium *targetChild = pTarget->i_getChildren().front();
 
             /* disconnect the deleted branch at the elder end */
-            targetChild->deparent();
+            targetChild->i_deparent();
 
             /* reparent source's children and disconnect the deleted
@@ -7314 +7076 @@
                     AutoWriteLock childLock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-                    pMedium->deparent();  // removes pMedium from source
-                    pMedium->setParent(pTarget);
+                    pMedium->i_deparent();  // removes pMedium from source
+                    pMedium->i_setParent(pTarget);
                 }
             }
@@ -7359 +7121 @@
             if (pMedium == this)
             {
-                Assert(getChildren().size() == 0);
+                Assert(i_getChildren().size() == 0);
                 Assert(m->backRefs.size() == 0);
                 task.mMediumCaller.release();
@@ -7375 +7137 @@
     }
 
-    markRegistriesModified();
+    i_markRegistriesModified();
     if (task.isAsync())
     {
@@ -7397 +7159 @@
          * don't own the merge chain, so release it in this case. */
         if (task.isAsync())
-            cancelMergeTo(task.mpChildrenToReparent, task.mpMediumLockList);
+            i_cancelMergeTo(task.mpChildrenToReparent, task.mpMediumLockList);
     }
 
@@ -7412 +7174 @@
  * @return
  */
-HRESULT Medium::taskCloneHandler(Medium::CloneTask &task)
+HRESULT Medium::i_taskCloneHandler(Medium::CloneTask &task)
 {
     HRESULT rcTmp = S_OK;
@@ -7447 +7209 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7478 +7240 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
 
@@ -7503 +7265 @@
 
             PVBOXHDD targetHdd;
-            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
+            vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &targetHdd);
             ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7547 +7309 @@
                                        tr("Could not open the medium storage unit '%s'%s"),
                                        pMedium->m->strLocationFull.c_str(),
-                                       vdError(vrc).c_str());
+                                       i_vdError(vrc).c_str());
                 }
 
@@ -7588 +7350 @@
                     throw setError(VBOX_E_FILE_ERROR,
                                    tr("Could not create the clone medium '%s'%s"),
-                                   targetLocation.c_str(), vdError(vrc).c_str());
+                                   targetLocation.c_str(), i_vdError(vrc).c_str());
 
                 size = VDGetFileSize(targetHdd, VD_LAST_IMAGE);
@@ -7638 +7400 @@
             if (FAILED(mrc))
                 /* break parent association on failure to register */
-                pTarget->deparent();     // removes target from parent
+                pTarget->i_deparent();     // removes target from parent
         }
         else
@@ -7680 +7442 @@
     {
         // save the settings
-        markRegistriesModified();
+        i_markRegistriesModified();
         /* collect multiple errors */
         eik.restore();
@@ -7708 +7470 @@
  * @return
  */
-HRESULT Medium::taskDeleteHandler(Medium::DeleteTask &task)
+HRESULT Medium::i_taskDeleteHandler(Medium::DeleteTask &task)
 {
     NOREF(task);
@@ -7720 +7482 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7743 +7505 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not delete the medium storage unit '%s'%s"),
-                               location.c_str(), vdError(vrc).c_str());
+                               location.c_str(), i_vdError(vrc).c_str());
 
         }
@@ -7774 +7536 @@
  * @return
  */
-HRESULT Medium::taskResetHandler(Medium::ResetTask &task)
+HRESULT Medium::i_taskResetHandler(Medium::ResetTask &task)
 {
     HRESULT rc = S_OK;
@@ -7792 +7554 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7839 +7601 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
 
                 /* Done when we hit the media which should be reset */
@@ -7851 +7613 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not delete the medium storage unit '%s'%s"),
-                               location.c_str(), vdError(vrc).c_str());
+                               location.c_str(), i_vdError(vrc).c_str());
 
             /* next, create it again */
@@ -7862 +7624 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not open the medium storage unit '%s'%s"),
-                               parentLocation.c_str(), vdError(vrc).c_str());
+                               parentLocation.c_str(), i_vdError(vrc).c_str());
 
             vrc = VDCreateDiff(hdd,
@@ -7878 +7640 @@
                 throw setError(VBOX_E_FILE_ERROR,
                                tr("Could not create the differencing medium storage unit '%s'%s"),
-                               location.c_str(), vdError(vrc).c_str());
+                               location.c_str(), i_vdError(vrc).c_str());
 
             size = VDGetFileSize(hdd, VD_LAST_IMAGE);
@@ -7911 +7673 @@
  * @return
  */
-HRESULT Medium::taskCompactHandler(Medium::CompactTask &task)
+HRESULT Medium::i_taskCompactHandler(Medium::CompactTask &task)
 {
     HRESULT rc = S_OK;
@@ -7923 +7685 @@
     {
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -7962 +7724 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
 
@@ -7987 +7749 @@
                                    tr("Could not compact medium '%s'%s"),
                                    location.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
         }
@@ -8008 +7770 @@
  * @return
  */
-HRESULT Medium::taskResizeHandler(Medium::ResizeTask &task)
+HRESULT Medium::i_taskResizeHandler(Medium::ResizeTask &task)
 {
     HRESULT rc = S_OK;
@@ -8021 +7783 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -8060 +7822 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
 
@@ -8086 +7848 @@
                                    tr("Could not resize medium '%s'%s"),
                                    location.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
             size = VDGetFileSize(hdd, VD_LAST_IMAGE);
@@ -8120 +7882 @@
  * @return
  */
-HRESULT Medium::taskExportHandler(Medium::ExportTask &task)
+HRESULT Medium::i_taskExportHandler(Medium::ExportTask &task)
 {
     HRESULT rc = S_OK;
@@ -8132 +7894 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -8163 +7925 @@
                                    tr("Could not open the medium storage unit '%s'%s"),
                                    pMedium->m->strLocationFull.c_str(),
-                                   vdError(vrc).c_str());
+                                   i_vdError(vrc).c_str());
             }
 
@@ -8184 +7946 @@
 
             PVBOXHDD targetHdd;
-            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
+            vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &targetHdd);
             ComAssertRCThrow(vrc, E_FAIL);
 
@@ -8205 +7967 @@
                     throw setError(VBOX_E_FILE_ERROR,
                                    tr("Could not create the clone medium '%s'%s"),
-                                   targetLocation.c_str(), vdError(vrc).c_str());
+                                   targetLocation.c_str(), i_vdError(vrc).c_str());
             }
             catch (HRESULT aRC) { rc = aRC; }
@@ -8237 +7999 @@
  * @return
  */
-HRESULT Medium::taskImportHandler(Medium::ImportTask &task)
+HRESULT Medium::i_taskImportHandler(Medium::ImportTask &task)
 {
     HRESULT rcTmp = S_OK;
@@ -8272 +8034 @@
 
         PVBOXHDD hdd;
-        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
+        int vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
         ComAssertRCThrow(vrc, E_FAIL);
 
@@ -8287 +8049 @@
                                tr("Could not open the medium storage unit '%s'%s"),
                                task.mFilename.c_str(),
-                               vdError(vrc).c_str());
+                               i_vdError(vrc).c_str());
 
             Utf8Str targetFormat(m->strFormat);
@@ -8310 +8072 @@
 
             PVBOXHDD targetHdd;
-            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
+            vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &targetHdd);
             ComAssertRCThrow(vrc, E_FAIL);
 
@@ -8354 +8116 @@
                                        tr("Could not open the medium storage unit '%s'%s"),
                                        pMedium->m->strLocationFull.c_str(),
-                                       vdError(vrc).c_str());
+                                       i_vdError(vrc).c_str());
                 }
 
@@ -8374 +8136 @@
                     throw setError(VBOX_E_FILE_ERROR,
                                    tr("Could not create the clone medium '%s'%s"),
-                                   targetLocation.c_str(), vdError(vrc).c_str());
+                                   targetLocation.c_str(), i_vdError(vrc).c_str());
 
                 size = VDGetFileSize(targetHdd, VD_LAST_IMAGE);
@@ -8423 +8185 @@
             if (FAILED(mrc))
                 /* break parent association on failure to register */
-                this->deparent();     // removes target from parent
+                this->i_deparent();     // removes target from parent
         }
         else
@@ -8462 +8224 @@
     {
         // save the settings
-        markRegistriesModified();
+        i_markRegistriesModified();
         /* collect multiple errors */
         eik.restore();

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

@@ -96 +96 @@
     {
         AutoReadLock alock(mMedium COMMA_LOCKVAL_SRC_POS);
-        state = mMedium->getState();
+        state = mMedium->i_getState();
     }
     switch (state)

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

@@ -1101 +1101 @@
         AutoReadLock local_alock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-        used += (ULONG)(pMedium->getSize() / _1M);
+        used += (ULONG)(pMedium->i_getSize() / _1M);
     }
 

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

@@ -400 +400 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (aPath != m->bd->strPath)
-    {
-        HRESULT rc = i_checkSetPath(aPath);
+    com::Utf8Str strPath = aPath;
+
+    /* we treat empty as null when e.g. saving to XML, do the same here */
+    if (!strPath.isEmpty())
+        strPath = "";
+
+    if (strPath != m->bd->strPath)
+    {
+        HRESULT rc = i_checkSetPath(strPath);
         if (FAILED(rc)) return rc;
 
         m->bd.backup();
-        m->bd->strPath = aPath;
+        m->bd->strPath = strPath;
 
         m->fModified = true;

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

@@ -1048 +1048 @@
         if (pMedium) // can be NULL for non-harddisk
         {
-            rc = pMedium->addBackReference(mData->mUuid, mSnapshotId);
+            rc = pMedium->i_addBackReference(mData->mUuid, mSnapshotId);
             AssertComRC(rc);
         }
@@ -1782 +1782 @@
             ++ulTotalWeight;         // assume one MB weight for each differencing hard disk to manage
             Assert(pAttach->getMedium());
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->getMedium()->getName().c_str()));
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->getMedium()->i_getName().c_str()));
         }
     }
@@ -1970 +1970 @@
             if (    !pMedium.isNull()
                  && pAttach->getType() == DeviceType_HardDisk
-                 && !pMedium->getParent().isNull()
-                 && pMedium->getChildren().size() == 0
+                 && !pMedium->i_getParent().isNull()
+                 && pMedium->i_getChildren().size() == 0
                )
             {
-                LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->getName().c_str()));
+                LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->i_getName().c_str()));
 
                 llDiffAttachmentsToDelete.push_back(pAttach);
@@ -2012 +2012 @@
             AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-            LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->getName().c_str()));
+            LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
 
             // Normally we "detach" the medium by removing the attachment object
@@ -2028 +2028 @@
                 mMediaData.backedUpData()->mAttachments.remove(pAttach);
             // then clean up backrefs
-            pMedium->removeBackReference(mData->mUuid);
+            pMedium->i_removeBackReference(mData->mUuid);
 
             llDiffsToDelete.push_back(pMedium);
@@ -2054 +2054 @@
         {
             ComObjPtr<Medium> &pMedium = *it;
-            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->getName().c_str()));
-
-            HRESULT rc2 = pMedium->deleteStorage(NULL /* aProgress */,
-                                                 true /* aWait */);
+            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
+
+            HRESULT rc2 = pMedium->i_deleteStorage(NULL /* aProgress */,
+                                                   true /* aWait */);
             // ignore errors here because we cannot roll back after saveSettings() above
             if (SUCCEEDED(rc2))
@@ -2169 +2169 @@
                         mUserData->s.strName.c_str(),
                         childrenCount);
+
     if (pSnapshot == mData->mCurrentSnapshot && childrenCount >= 1)
         return setError(VBOX_E_INVALID_OBJECT_STATE,
@@ -2175 +2176 @@
                         mUserData->s.strName.c_str());
 
+
     /* If the snapshot being deleted is the current one, ensure current
      * settings are committed and saved.
@@ -2218 +2220 @@
             AutoReadLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
 
-            MediumType_T type = pHD->getType();
+            MediumType_T type = pHD->i_getType();
             // writethrough and shareable images are unaffected by snapshots,
             // so do nothing for them
@@ -2227 +2229 @@
                 // normal or immutable media need attention
                 ++ulOpCount;
-                ulTotalWeight += (ULONG)(pHD->getSize() / _1M);
+                ulTotalWeight += (ULONG)(pHD->i_getSize() / _1M);
             }
-            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pHD->getName().c_str()));
+            LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pHD->i_getName().c_str()));
         }
     }
@@ -2445 +2447 @@
                 // unaffected by snapshots, skip them
                 AutoReadLock medlock(pHD COMMA_LOCKVAL_SRC_POS);
-                MediumType_T type = pHD->getType();
+                MediumType_T type = pHD->i_getType();
                 if (   type == MediumType_Writethrough
                     || type == MediumType_Shareable
@@ -2453 +2455 @@
 
 #ifdef DEBUG
-            pHD->dumpBackRefs();
+            pHD->i_dumpBackRefs();
 #endif
 
@@ -2525 +2527 @@
                 // base disk. Here we need then to update the attachment that
                 // refers to the child and have it point to the parent instead
-                Assert(pHD->getChildren().size() == 1);
-
-                ComObjPtr<Medium> pReplaceHD = pHD->getChildren().front();
+                Assert(pHD->i_getChildren().size() == 1);
+
+                ComObjPtr<Medium> pReplaceHD = pHD->i_getChildren().front();
 
                 ComAssertThrow(pReplaceHD == pSource, E_FAIL);
@@ -2535 +2537 @@
             Guid replaceSnapshotId;
 
-            const Guid *pReplaceMachineId = pSource->getFirstMachineBackrefId();
+            const Guid *pReplaceMachineId = pSource->i_getFirstMachineBackrefId();
             // minimal sanity checking
             Assert(!pReplaceMachineId || *pReplaceMachineId == mData->mUuid);
@@ -2541 +2543 @@
                 replaceMachineId = *pReplaceMachineId;
 
-            const Guid *pSnapshotId = pSource->getFirstMachineBackrefSnapshotId();
+            const Guid *pSnapshotId = pSource->i_getFirstMachineBackrefSnapshotId();
             if (pSnapshotId)
                 replaceSnapshotId = *pSnapshotId;
@@ -2551 +2553 @@
                 // with the snapshot until the merge was successful.
                 HRESULT rc2 = S_OK;
-                rc2 = pSource->removeBackReference(replaceMachineId, replaceSnapshotId);
+                rc2 = pSource->i_removeBackReference(replaceMachineId, replaceSnapshotId);
                 AssertComRC(rc2);
 
@@ -2608 +2610 @@
                     throw rc;
 
-                if(pTarget_local->isMediumFormatFile())
+                if(pTarget_local->i_isMediumFormatFile())
                 {
-                    int vrc = RTFsQuerySerial(pTarget_local->getLocationFull().c_str(), &pu32Serial);
+                    int vrc = RTFsQuerySerial(pTarget_local->i_getLocationFull().c_str(), &pu32Serial);
                     if (RT_FAILURE(vrc))
                     {
                         rc = setError(E_FAIL,
                                       tr(" Unable to merge storage '%s'. Can't get storage UID "),
-                                      pTarget_local->getLocationFull().c_str());
+                                      pTarget_local->i_getLocationFull().c_str());
                         throw rc;
                     }
@@ -2624 +2626 @@
                     neededStorageFreeSpace.insert(std::make_pair(pu32Serial,diskSize));
                     /* linking storage UID with snapshot path, it is a helper container (just for easy finding needed path) */
-                    serialMapToStoragePath.insert(std::make_pair(pu32Serial,pTarget_local->getLocationFull().c_str()));
+                    serialMapToStoragePath.insert(std::make_pair(pu32Serial,pTarget_local->i_getLocationFull().c_str()));
                 }
 
@@ -2729 +2731 @@
             {
                 AutoReadLock alock(pMedium COMMA_LOCKVAL_SRC_POS);
-                ulWeight = (ULONG)(pMedium->getSize() / _1M);
+                ulWeight = (ULONG)(pMedium->i_getSize() / _1M);
             }
 
             aTask.pProgress->SetNextOperation(BstrFmt(tr("Merging differencing image '%s'"),
-                                              pMedium->getName().c_str()).raw(),
+                                              pMedium->i_getName().c_str()).raw(),
                                               ulWeight);
 
@@ -2745 +2747 @@
 
                 Assert(   !it->mfMergeForward
-                       || pMedium->getChildren().size() == 0);
+                       || pMedium->i_getChildren().size() == 0);
 
                 /* Delete the differencing hard disk (has no children). Two
@@ -2752 +2754 @@
                  * In both cases leave the image in place. If it's the first
                  * exception the user can delete it later if he wants. */
-                if (!pMedium->getParent().isNull())
+                if (!pMedium->i_getParent().isNull())
                 {
-                    Assert(pMedium->getState() == MediumState_Deleting);
+                    Assert(pMedium->i_getState() == MediumState_Deleting);
                     /* No need to hold the lock any longer. */
                     mLock.release();
-                    rc = pMedium->deleteStorage(&aTask.pProgress,
-                                                true /* aWait */);
+                    rc = pMedium->i_deleteStorage(&aTask.pProgress,
+                                                  true /* aWait */);
                     if (FAILED(rc))
                         throw rc;
@@ -2791 +2793 @@
                 {
                     // normal medium merge, in the direction decided earlier
-                    rc = it->mpSource->mergeTo(it->mpTarget,
-                                               it->mfMergeForward,
-                                               it->mpParentForTarget,
-                                               it->mpChildrenToReparent,
-                                               it->mpMediumLockList,
-                                               &aTask.pProgress,
-                                               true /* aWait */);
+                    rc = it->mpSource->i_mergeTo(it->mpTarget,
+                                                 it->mfMergeForward,
+                                                 it->mpParentForTarget,
+                                                 it->mpChildrenToReparent,
+                                                 it->mpMediumLockList,
+                                                 &aTask.pProgress,
+                                                 true /* aWait */);
                 }
 
@@ -2809 +2811 @@
                 {
                     AutoReadLock mlock(it->mpSource COMMA_LOCKVAL_SRC_POS);
-                    if (!it->mpSource->isMediumFormatFile())
+                    if (!it->mpSource->i_isMediumFormatFile())
                         // Diff medium not backed by a file - cannot get status so
                         // be pessimistic.
                         throw rc;
-                    const Utf8Str &loc = it->mpSource->getLocationFull();
+                    const Utf8Str &loc = it->mpSource->i_getLocationFull();
                     // Source medium is still there, so merge failed early.
                     if (RTFileExists(loc.c_str()))
@@ -2848 +2850 @@
                 pAtt = findAttachment(pSnapMachine->mMediaData->mAttachments,
                                       it->mpTarget);
-                it->mpTarget->removeBackReference(machineId, snapshotId);
+                it->mpTarget->i_removeBackReference(machineId, snapshotId);
             }
             else
@@ -2872 +2874 @@
                     AutoWriteLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
                     pAtt->updateMedium(it->mpTarget);
-                    it->mpTarget->addBackReference(pMachine->mData->mUuid, childSnapshotId);
+                    it->mpTarget->i_addBackReference(pMachine->mData->mUuid, childSnapshotId);
                 }
                 else
@@ -2882 +2884 @@
                     // Needs a bit of special treatment due to this difference.
                     if (it->mfNeedsOnlineMerge)
-                        it->mpTarget->addBackReference(pMachine->mData->mUuid, childSnapshotId);
+                        it->mpTarget->i_addBackReference(pMachine->mData->mUuid, childSnapshotId);
                 }
             }
@@ -3021 +3023 @@
 
     // Medium must not be writethrough/shareable/readonly at this point
-    MediumType_T type = aHD->getType();
+    MediumType_T type = aHD->i_getType();
     AssertReturn(   type != MediumType_Writethrough
                  && type != MediumType_Shareable
@@ -3030 +3032 @@
     fNeedsOnlineMerge = false;
 
-    if (aHD->getChildren().size() == 0)
+    if (aHD->i_getChildren().size() == 0)
     {
         /* This technically is no merge, set those values nevertheless.
@@ -3038 +3040 @@
 
         /* special treatment of the last hard disk in the chain: */
-        if (aHD->getParent().isNull())
+        if (aHD->i_getParent().isNull())
         {
             /* lock only, to prevent any usage until the snapshot deletion
@@ -3048 +3050 @@
         /* the differencing hard disk w/o children will be deleted, protect it
          * from attaching to other VMs (this is why Deleting) */
-        return aHD->markForDeletion();
+        return aHD->i_markForDeletion();
    }
 
     /* not going multi-merge as it's too expensive */
-    if (aHD->getChildren().size() > 1)
+    if (aHD->i_getChildren().size() > 1)
         return setError(E_FAIL,
                         tr("Hard disk '%s' has more than one child hard disk (%d)"),
-                        aHD->getLocationFull().c_str(),
-                        aHD->getChildren().size());
-
-    ComObjPtr<Medium> pChild = aHD->getChildren().front();
+                        aHD->i_getLocationFull().c_str(),
+                        aHD->i_getChildren().size());
+
+    ComObjPtr<Medium> pChild = aHD->i_getChildren().front();
 
     AutoWriteLock childLock(pChild COMMA_LOCKVAL_SRC_POS);
 
     /* the rest is a normal merge setup */
-    if (aHD->getParent().isNull())
+    if (aHD->i_getParent().isNull())
     {
         /* base hard disk, backward merge */
-        const Guid *pMachineId1 = pChild->getFirstMachineBackrefId();
-        const Guid *pMachineId2 = aHD->getFirstMachineBackrefId();
+        const Guid *pMachineId1 = pChild->i_getFirstMachineBackrefId();
+        const Guid *pMachineId2 = aHD->i_getFirstMachineBackrefId();
         if (pMachineId1 && pMachineId2 && *pMachineId1 != *pMachineId2)
         {
@@ -3087 +3089 @@
         childLock.release();
         alock.release();
-        HRESULT rc = aHD->queryPreferredMergeDirection(pChild, fMergeForward);
+        HRESULT rc = aHD->i_queryPreferredMergeDirection(pChild, fMergeForward);
         alock.acquire();
         childLock.acquire();
@@ -3111 +3113 @@
     childLock.release();
     alock.release();
-    rc = aSource->prepareMergeTo(aTarget, &aMachineId, &aSnapshotId,
+    rc = aSource->i_prepareMergeTo(aTarget, &aMachineId, &aSnapshotId,
                                  !fOnlineMergePossible /* fLockMedia */,
                                  aMergeForward, aParentForTarget,
@@ -3221 +3223 @@
                 if (FAILED(rc))
                 {
-                    aSource->cancelMergeTo(aChildrenToReparent, aMediumLockList);
+                    aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
                     rc = setError(rc,
                                   tr("Cannot lock hard disk '%s' for a live merge"),
-                                  aHD->getLocationFull().c_str());
+                                  aHD->i_getLocationFull().c_str());
                 }
                 else
@@ -3235 +3237 @@
             else
             {
-                aSource->cancelMergeTo(aChildrenToReparent, aMediumLockList);
+                aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
                 rc = setError(rc,
                               tr("Failed to construct lock list for a live merge of hard disk '%s'"),
-                              aHD->getLocationFull().c_str());
+                              aHD->i_getLocationFull().c_str());
             }
 
@@ -3261 +3263 @@
                     // blindly apply this, only needed for medium objects which
                     // would be deleted as part of the merge
-                    pMedium->unmarkLockedForDeletion();
+                    pMedium->i_unmarkLockedForDeletion();
                 }
             }
@@ -3268 +3270 @@
         else
         {
-            aSource->cancelMergeTo(aChildrenToReparent, aMediumLockList);
+            aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
             rc = setError(rc,
                           tr("Cannot lock hard disk '%s' for an offline merge"),
-                          aHD->getLocationFull().c_str());
+                          aHD->i_getLocationFull().c_str());
         }
     }
@@ -3307 +3309 @@
         AutoMultiWriteLock2 mLock(&mParent->getMediaTreeLockHandle(), aHD->lockHandle() COMMA_LOCKVAL_SRC_POS);
 
-        Assert(aHD->getChildren().size() == 0);
-
-        if (aHD->getParent().isNull())
+        Assert(aHD->i_getChildren().size() == 0);
+
+        if (aHD->i_getParent().isNull())
         {
             Assert(!aHDLockToken.isNull());
@@ -3320 +3322 @@
         else
         {
-            HRESULT rc = aHD->unmarkForDeletion();
+            HRESULT rc = aHD->i_unmarkForDeletion();
             AssertComRC(rc);
         }
@@ -3330 +3332 @@
             // Online merge uses the medium lock list of the VM, so give
             // an empty list to cancelMergeTo so that it works as designed.
-            aSource->cancelMergeTo(aChildrenToReparent, new MediumLockList());
+            aSource->i_cancelMergeTo(aChildrenToReparent, new MediumLockList());
 
             // clean up the VM medium lock list ourselves
@@ -3345 +3347 @@
                 ComObjPtr<Medium> pMedium = it->GetMedium();
                 AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-                if (pMedium->getState() == MediumState_Deleting)
-                    pMedium->unmarkForDeletion();
+                if (pMedium->i_getState() == MediumState_Deleting)
+                    pMedium->i_unmarkForDeletion();
                 else
                 {
                     // blindly apply this, only needed for medium objects which
                     // would be deleted as part of the merge
-                    pMedium->unmarkLockedForDeletion();
+                    pMedium->i_unmarkLockedForDeletion();
                 }
                 mediumLock.release();
@@ -3360 +3362 @@
         else
         {
-            aSource->cancelMergeTo(aChildrenToReparent, aMediumLockList);
+            aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
         }
     }
@@ -3367 +3369 @@
     {
         // reattach the source media to the snapshot
-        HRESULT rc = aSource->addBackReference(aMachineId, aSnapshotId);
+        HRESULT rc = aSource->i_addBackReference(aMachineId, aSnapshotId);
         AssertComRC(rc);
     }
@@ -3512 +3514 @@
         // then, reparent it and disconnect the deleted branch at
         // both ends (chain->parent() is source's parent)
-        pDeleteRec->mpTarget->deparent();
-        pDeleteRec->mpTarget->setParent(pDeleteRec->mpParentForTarget);
+        pDeleteRec->mpTarget->i_deparent();
+        pDeleteRec->mpTarget->i_setParent(pDeleteRec->mpParentForTarget);
         if (pDeleteRec->mpParentForTarget)
-            pDeleteRec->mpSource->deparent();
+            pDeleteRec->mpSource->i_deparent();
 
         // then, register again
@@ -3523 +3525 @@
     else
     {
-        Assert(pDeleteRec->mpTarget->getChildren().size() == 1);
-        targetChild = pDeleteRec->mpTarget->getChildren().front();
+        Assert(pDeleteRec->mpTarget->i_getChildren().size() == 1);
+        targetChild = pDeleteRec->mpTarget->i_getChildren().front();
 
         // disconnect the deleted branch at the elder end
-        targetChild->deparent();
+        targetChild->i_deparent();
 
         // Update parent UUIDs of the source's children, reparent them and
@@ -3540 +3542 @@
             // need manual fixing via VBoxManage to adjust the parent UUID.
             treeLock.release();
-            pDeleteRec->mpTarget->fixParentUuidOfChildren(pDeleteRec->mpChildrenToReparent);
+            pDeleteRec->mpTarget->i_fixParentUuidOfChildren(pDeleteRec->mpChildrenToReparent);
             // The childen are still write locked, unlock them now and don't
             // rely on the destructor doing it very late.
@@ -3558 +3560 @@
                 AutoWriteLock childLock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-                pMedium->deparent();  // removes pMedium from source
-                pMedium->setParent(pDeleteRec->mpTarget);
+                pMedium->i_deparent();  // removes pMedium from source
+                pMedium->i_setParent(pDeleteRec->mpTarget);
             }
         }
@@ -3584 +3586 @@
         /* The target and all images not merged (readonly) are skipped */
         if (   pMedium == pDeleteRec->mpTarget
-            || pMedium->getState() == MediumState_LockedRead)
+            || pMedium->i_getState() == MediumState_LockedRead)
         {
             ++it;
@@ -3607 +3609 @@
             if (pMedium == pDeleteRec->mpSource)
             {
-                Assert(pDeleteRec->mpSource->getChildren().size() == 0);
-                Assert(pDeleteRec->mpSource->getFirstMachineBackrefId() == NULL);
+                Assert(pDeleteRec->mpSource->i_getChildren().size() == 0);
+                Assert(pDeleteRec->mpSource->i_getFirstMachineBackrefId() == NULL);
             }
 

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

@@ -177 +177 @@
         if (m.fWrite)
         {
-            HRESULT rc = m.pMedium->unlockWrite(NULL);
+            HRESULT rc = m.pMedium->i_unlockWrite(NULL);
             AssertComRC(rc);
         }
         else
         {
-            HRESULT rc = m.pMedium->unlockRead(NULL);
+            HRESULT rc = m.pMedium->i_unlockRead(NULL);
             AssertComRC(rc);
         }

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

@@ -69 +69 @@
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
 #include "EventImpl.h"
+// #include "VBoxEvents.h"
 #ifdef VBOX_WITH_EXTPACK
 # include "ExtPackManagerImpl.h"
@@ -2235 +2236 @@
         int rc = decryptSetting(&strPlaintext, bstrCipher);
         if (RT_SUCCESS(rc))
-            pMedium->setPropertyDirect("InitiatorSecret", strPlaintext);
+            pMedium->i_setPropertyDirect("InitiatorSecret", strPlaintext);
         else
             return rc;
@@ -2442 +2443 @@
         {
             ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
+            pMedium->i_dumpBackRefs();
         }
     }
@@ -2452 +2453 @@
         {
             ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
+            pMedium->i_dumpBackRefs();
         }
     }
@@ -3523 +3524 @@
         AutoWriteLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
 
-        Utf8Str strLocationFull = pHD->getLocationFull();
+        Utf8Str strLocationFull = pHD->i_getLocationFull();
 
         if (0 == RTPathCompare(strLocationFull.c_str(), strLocation.c_str()))
@@ -3604 +3605 @@
         Medium *pMedium = *it;
         AutoReadLock imageLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        const Utf8Str &strLocationFull = pMedium->getLocationFull();
+        const Utf8Str &strLocationFull = pMedium->i_getLocationFull();
 
         found =     (    aId
-                      && pMedium->getId() == *aId)
+                      && pMedium->i_getId() == *aId)
                  || (    !aLocation.isEmpty()
                       && RTPathCompare(location.c_str(),
@@ -3613 +3614 @@
         if (found)
         {
-            if (pMedium->getDeviceType() != mediumType)
+            if (pMedium->i_getDeviceType() != mediumType)
             {
                 if (mediumType == DeviceType_DVD)
@@ -3927 +3928 @@
         AutoReadLock mlock(pMediumFound COMMA_LOCKVAL_SRC_POS);
 
-        Utf8Str strLocFound = pMediumFound->getLocationFull();
-        Guid idFound = pMediumFound->getId();
+        Utf8Str strLocFound = pMediumFound->i_getLocationFull();
+        Guid idFound = pMediumFound->i_getId();
 
         if (    (RTPathCompare(strLocFound.c_str(), aLocation.c_str()) == 0)
@@ -4033 +4034 @@
     {
         Medium *pMedium = *it;
-        pMedium->markRegistriesModified();
+        pMedium->i_markRegistriesModified();
     }
 
@@ -4106 +4107 @@
             {
                 const Data::PendingMachineRename &pmr = *it2;
-                HRESULT rc = pMedium->updatePath(pmr.strConfigDirOld,
-                                                 pmr.strConfigDirNew);
+                HRESULT rc = pMedium->i_updatePath(pmr.strConfigDirOld,
+                                                   pmr.strConfigDirNew);
                 if (SUCCEEDED(rc))
                 {
@@ -4178 +4179 @@
             AutoReadLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-            if (pMedium->isInRegistry(uuidRegistry))
+            if (pMedium->i_isInRegistry(uuidRegistry))
             {
                 settings::Medium med;
-                rc = pMedium->saveSettings(med, strMachineFolder);     // this recurses into child hard disks
+                rc = pMedium->i_saveSettings(med, strMachineFolder);     // this recurses into child hard disks
                 if (FAILED(rc)) throw rc;
                 llTarget.push_back(med);
@@ -4404 +4405 @@
     {
         AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        id = pMedium->getId();
-        strLocationFull = pMedium->getLocationFull();
-        pParent = pMedium->getParent();
+        id = pMedium->i_getId();
+        strLocationFull = pMedium->i_getLocationFull();
+        pParent = pMedium->i_getParent();
     }
 
@@ -4478 +4479 @@
     {
         AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        id = pMedium->getId();
-        pParent = pMedium->getParent();
-        devType = pMedium->getDeviceType();
+        id = pMedium->i_getId();
+        pParent = pMedium->i_getParent();
+        devType = pMedium->i_getDeviceType();
     }
 
@@ -4525 +4526 @@
     // list before their parents
 
-    const MediaList &llChildren = pMedium->getChildren();
+    const MediaList &llChildren = pMedium->i_getChildren();
     for (MediaList::const_iterator it = llChildren.begin();
          it != llChildren.end();
@@ -4534 +4535 @@
     }
 
-    Log(("Pushing medium %RTuuid\n", pMedium->getId().raw()));
+    Log(("Pushing medium %RTuuid\n", pMedium->i_getId().raw()));
     llMedia.push_back(pMedium);
 }
@@ -4571 +4572 @@
             AutoReadLock medlock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-            if (pMedium->isInRegistry(uuidMachine))
+            if (pMedium->i_isInRegistry(uuidMachine))
                 // recursively with children first
                 pushMediumToListWithChildren(llMedia2Close, pMedium);
@@ -4582 +4583 @@
     {
         ComObjPtr<Medium> pMedium = *it;
-        Log(("Closing medium %RTuuid\n", pMedium->getId().raw()));
+        Log(("Closing medium %RTuuid\n", pMedium->i_getId().raw()));
         AutoCaller mac(pMedium);
-        pMedium->close(mac);
+        pMedium->i_close(mac);
     }
 
@@ -4632 +4633 @@
             AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
 
-            if (pMedium->removeRegistry(id, true /* fRecurse */))
+            if (pMedium->i_removeRegistry(id, true /* fRecurse */))
             {
                 // machine ID was found in base medium's registry list:
                 // move this base image and all its children to another registry then
                 // 1) first, find a better registry to add things to
-                const Guid *puuidBetter = pMedium->getAnyMachineBackref();
+                const Guid *puuidBetter = pMedium->i_getAnyMachineBackref();
                 if (puuidBetter)
                 {
                     // 2) better registry found: then use that
-                    pMedium->addRegistry(*puuidBetter, true /* fRecurse */);
+                    pMedium->i_addRegistry(*puuidBetter, true /* fRecurse */);
                     // 3) and make sure the registry is saved below
                     mlock.release();

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

@@ -113 +113 @@
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Snapshot, ISnapshot)
 
-NS_DECL_CLASSINFO(Medium)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Medium, IMedium)
-
 NS_DECL_CLASSINFO(MediumAttachment)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MediumAttachment, IMediumAttachment)