Changeset 13580 in vbox for trunk/src/VBox/Main/include

Timestamp:

Oct 27, 2008 2:04:18 PM (16 years ago)

Author:

vboxsync

Message:

Ported s2 branch (r37120:38456).

Location:

trunk/src/VBox/Main/include

Files:

• AutoLock.h (modified) (4 diffs)
• ConsoleImpl.h (modified) (2 diffs)
• DVDDriveImpl.h (modified) (6 diffs)
• DVDImageImpl.h (deleted)
• FloppyDriveImpl.h (modified) (6 diffs)
• FloppyImageImpl.h (deleted)
• GuestOSTypeImpl.h (modified) (1 diff)
• HardDisk2Impl.h (added)
• HardDiskAttachmentImpl.h (modified) (2 diffs)
• HardDiskFormatImpl.h (added)
• HardDiskImpl.h (deleted)
• MachineImpl.h (modified) (18 diffs)
• MediumImpl.h (added)
• ProgressImpl.h (modified) (14 diffs)
• SnapshotImpl.h (modified) (1 diff)
• SystemPropertiesImpl.h (modified) (5 diffs)
• VirtualBoxBase.h (modified) (45 diffs)
• VirtualBoxImpl.h (modified) (10 diffs)
• VirtualBoxXMLUtil.h (modified) (1 diff)

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

@@ -647 +647 @@
 
     /**
+     * Same as #leave() but checks if the current thread actally owns the lock
+     * and only proceeds in this case. As a result, as opposed to #leave(),
+     * doesn't assert when called with no lock being held.
+     */
+    void maybeLeave()
+    {
+        if (isWriteLockOnCurrentThread())
+            leave();
+    }
+
+    /**
+     * Same as #enter() but checks if the current thread actally owns the lock
+     * and only proceeds if not. As a result, as opposed to #enter(), doesn't
+     * assert when called with the lock already being held.
+     */
+    void maybeEnter()
+    {
+        if (!isWriteLockOnCurrentThread())
+            enter();
+    }
+
+    /**
      * Causes the current thread to restore the write lock level after the
      * #leave() call. This call will indefinitely block if another thread has
@@ -663 +685 @@
         }
     }
+
+    /**
+     * Attaches another handle to this auto lock instance.
+     *
+     * The previous object's lock is completely released before the new one is
+     * acquired. The lock level of the new handle will be the same. This
+     * also means that if the lock was not acquired at all before #attach(), it
+     * will not be acquired on the new handle too.
+     *
+     * @param aHandle   New handle to attach.
+     */
+    void attach (LockHandle *aHandle)
+    {
+        /* detect simple self-reattachment */
+        if (mHandle != aHandle)
+        {
+            uint32_t lockLevel = mLockLevel;
+
+            /* perform the destructor part */
+            if (mHandle)
+            {
+                if (mGlobalLockLevel)
+                {
+                    mGlobalLockLevel -= mLockLevel;
+                    mLockLevel = 0;
+                    for (; mGlobalLockLevel; -- mGlobalLockLevel)
+                        mHandle->lockWrite();
+                }
+
+                AssertMsg (mLockLevel <= 1, ("Lock level > 1: %d\n", mLockLevel));
+                for (; mLockLevel; -- mLockLevel)
+                    mHandle->unlockWrite();
+            }
+
+            mHandle = aHandle;
+            mLockLevel = lockLevel;
+
+            if (mHandle)
+                for (; lockLevel; -- lockLevel)
+                    mHandle->lockWrite();
+        }
+    }
+
+    /** @see attach (LockHandle *) */
+    void attach (LockHandle &aHandle) { attach (&aHandle); }
+
+    /** @see attach (LockHandle *) */
+    void attach (const Lockable &aLockable) { attach (aLockable.lockHandle()); }
+
+    /** @see attach (LockHandle *) */
+    void attach (const Lockable *aLockable)
+    { attach (aLockable ? aLockable->lockHandle() : NULL); }
+
+    /** Verbose equivalent to <tt>attach (NULL)</tt>. */
+    void detach() { attach ((LockHandle *) NULL); }
 
     /** Returns @c true if this instance manages a null semaphore handle. */
@@ -916 +993 @@
         }
     }
+
+    /**
+     * Attaches another handle to this auto lock instance.
+     *
+     * The previous object's lock is completely released before the new one is
+     * acquired. The lock level of the new handle will be the same. This also
+     * means that if the lock was not acquired at all before #attach(), it will
+     * not be acquired on the new handle too.
+     *
+     * @param aHandle   New handle to attach.
+     */
+    void attach (LockHandle *aHandle)
+    {
+        /* detect simple self-reattachment */
+        if (mHandle != aHandle)
+        {
+            uint32_t lockLevel = mLockLevel;
+            if (mHandle)
+                for (; mLockLevel; -- mLockLevel)
+                    mHandle->unlockRead();
+            mHandle = aHandle;
+            mLockLevel = lockLevel;
+            if (mHandle)
+                for (; lockLevel; -- lockLevel)
+                    mHandle->lockRead();
+        }
+    }
+
+    /** @see attach (LockHandle *) */
+    void attach (LockHandle &aHandle) { attach (&aHandle); }
+
+    /** @see attach (LockHandle *) */
+    void attach (const Lockable &aLockable) { attach (aLockable.lockHandle()); }
+
+    /** @see attach (LockHandle *) */
+    void attach (const Lockable *aLockable)
+    { attach (aLockable ? aLockable->lockHandle() : NULL); }
+
+    /** Verbose equivalent to <tt>attach (NULL)</tt>. */
+    void detach() { attach ((LockHandle *) NULL); }
 
     /** Returns @c true if this instance manages a null semaphore handle. */
@@ -1158 +1275 @@
             mLocks [-- i].leave();
         while (i != 0);
+    }
+
+    /**
+    * Calls AutoWriteLock::maybeLeave() methods for all managed semaphore
+    * handles in reverse to the order they were passed to the constructor.
+     */
+    void maybeLeave()
+    {
+        AssertReturnVoid (ELEMENTS (mLocks) > 0);
+        size_t i = ELEMENTS (mLocks);
+        do
+            mLocks [-- i].maybeLeave();
+        while (i != 0);
+    }
+
+    /**
+     * Calls AutoWriteLock::maybeEnter() methods for all managed semaphore
+     * handles in order they were passed to the constructor.
+     */
+    void maybeEnter()
+    {
+        size_t i = 0;
+        while (i < ELEMENTS (mLocks))
+            mLocks [i ++].maybeEnter();
     }
 

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

@@ +1 @@
+/* $Id$ */
+
 /** @file
  *
@@ -5 +7 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -27 +27 @@
 #include "VirtualBoxBase.h"
 
+#include "MediumImpl.h"
+
 class Machine;
 
@@ -39 +41 @@
     struct Data
     {
-        Data() {
-            mDriveState = DriveState_NotMounted;
+        Data()
+        {
+            mState = DriveState_NotMounted;
             mPassthrough = false;
         }
@@ -47 +50 @@
         {
             return this == &that ||
-                   (mDriveState == that.mDriveState &&
-                    mDVDImage.equalsTo (that.mDVDImage) &&
+                   (mState == that.mState &&
+                    mImage.equalsTo (that.mImage) &&
                     mHostDrive.equalsTo (that.mHostDrive));
         }
 
-        ComPtr <IDVDImage> mDVDImage;
+        ComObjPtr <DVDImage2> mImage;
         ComPtr <IHostDVDDrive> mHostDrive;
-        DriveState_T mDriveState;
+        DriveState_T mState;
         BOOL mPassthrough;
     };
@@ -83 +86 @@
 
     // IDVDDrive properties
-    STDMETHOD(COMGETTER(State)) (DriveState_T *aDriveState);
+    STDMETHOD(COMGETTER(State)) (DriveState_T *aState);
     STDMETHOD(COMGETTER(Passthrough)) (BOOL *aPassthrough);
     STDMETHOD(COMSETTER(Passthrough)) (BOOL aPassthrough);
@@ -91 +94 @@
     STDMETHOD(CaptureHostDrive) (IHostDVDDrive *aHostDVDDrive);
     STDMETHOD(Unmount)();
-    STDMETHOD(GetImage) (IDVDImage **aDVDImage);
+    STDMETHOD(GetImage) (IDVDImage2 **aDVDImage);
     STDMETHOD(GetHostDrive) (IHostDVDDrive **aHostDVDDrive);
 

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -27 +27 @@
 #include "VirtualBoxBase.h"
 
+#include "MediumImpl.h"
+
 class Machine;
 
@@ -42 +44 @@
         {
             mEnabled    = true;
-            mDriveState = DriveState_NotMounted;
+            mState = DriveState_NotMounted;
         }
 
@@ -48 +50 @@
         {
             return this == &that ||
-                   (mDriveState == that.mDriveState &&
-                    mFloppyImage.equalsTo (that.mFloppyImage) &&
+                   (mState == that.mState &&
+                    mImage.equalsTo (that.mImage) &&
                     mHostDrive.equalsTo (that.mHostDrive));
         }
 
         BOOL mEnabled;
-        ComPtr <IFloppyImage> mFloppyImage;
+        ComObjPtr <FloppyImage2> mImage;
         ComPtr <IHostFloppyDrive> mHostDrive;
-        DriveState_T mDriveState;
+        DriveState_T mState;
     };
 
@@ -86 +88 @@
     STDMETHOD(COMGETTER(Enabled)) (BOOL *aEnabled);
     STDMETHOD(COMSETTER(Enabled)) (BOOL aEnabled);
-    STDMETHOD(COMGETTER(State)) (DriveState_T *aDriveState);
+    STDMETHOD(COMGETTER(State)) (DriveState_T *aState);
 
     // IFloppyDrive methods
@@ -92 +94 @@
     STDMETHOD(CaptureHostDrive) (IHostFloppyDrive *aHostFloppyDrive);
     STDMETHOD(Unmount)();
-    STDMETHOD(GetImage) (IFloppyImage **aFloppyImage);
+    STDMETHOD(GetImage) (IFloppyImage2 **aFloppyImage);
     STDMETHOD(GetHostDrive) (IHostFloppyDrive **aHostFloppyDrive);
 

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

@@ -36 +36 @@
 public:
 
-    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (DVDImage)
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (GuestOSType)
 
     DECLARE_NOT_AGGREGATABLE(GuestOSType)

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

@@ -24 +24 @@
 
 #include "VirtualBoxBase.h"
-#include "Collection.h"
 
-#include "HardDiskImpl.h"
+#include "HardDisk2Impl.h"
 
-class ATL_NO_VTABLE HardDiskAttachment :
-    public VirtualBoxSupportErrorInfoImpl <HardDiskAttachment, IHardDiskAttachment>,
-    public VirtualBoxSupportTranslation <HardDiskAttachment>,
-    public VirtualBoxBase,
-    public IHardDiskAttachment
+class ATL_NO_VTABLE HardDisk2Attachment :
+    public VirtualBoxBaseNEXT,
+    public com::SupportErrorInfoImpl <HardDisk2Attachment, IHardDisk2Attachment>,
+    public VirtualBoxSupportTranslation <HardDisk2Attachment>,
+    public IHardDisk2Attachment
 {
 public:
 
-    DECLARE_EMPTY_CTOR_DTOR (HardDiskAttachment)
+    /** Equality predicate for stdc++. */
+    struct EqualsTo
+        : public std::unary_function <ComObjPtr <HardDisk2Attachment>, bool>
+    {
+        explicit EqualsTo (StorageBus_T aBus, LONG aChannel, LONG aDevice)
+            : bus (aBus), channel (aChannel), device (aDevice) {}
 
-    DECLARE_NOT_AGGREGATABLE(HardDiskAttachment)
+        bool operator() (const argument_type &aThat) const
+        {
+            return aThat->bus() == bus && aThat->channel() == channel &&
+                   aThat->device() == device;
+        }
+
+        const StorageBus_T bus;
+        const LONG channel;
+        const LONG device;
+    };
+
+    /** Hard disk reference predicate for stdc++. */
+    struct RefersTo
+        : public std::unary_function <ComObjPtr <HardDisk2Attachment>, bool>
+    {
+        explicit RefersTo (HardDisk2 *aHardDisk) : hardDisk (aHardDisk) {}
+
+        bool operator() (const argument_type &aThat) const
+        {
+            return aThat->hardDisk().equalsTo (hardDisk);
+        }
+
+        const ComObjPtr <HardDisk2> hardDisk;
+    };
+
+    DECLARE_NOT_AGGREGATABLE(HardDisk2Attachment)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP(HardDiskAttachment)
+    BEGIN_COM_MAP (HardDisk2Attachment)
         COM_INTERFACE_ENTRY(ISupportErrorInfo)
-        COM_INTERFACE_ENTRY(IHardDiskAttachment)
+        COM_INTERFACE_ENTRY(IHardDisk2Attachment)
     END_COM_MAP()
 
@@ -53 +82 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init (HardDisk *aHD, StorageBus_T aBus, LONG aChannel, LONG aDevice, BOOL aDirty);
+    HRESULT init (HardDisk2 *aHD, StorageBus_T aBus, LONG aChannel,
+                  LONG aDevice, bool aImplicit = false);
+    void uninit();
 
-    // IHardDiskAttachment properties
-    STDMETHOD(COMGETTER(HardDisk))   (IHardDisk **aHardDisk);
+    // IHardDisk2Attachment properties
+    STDMETHOD(COMGETTER(HardDisk))   (IHardDisk2 **aHardDisk);
     STDMETHOD(COMGETTER(Bus))        (StorageBus_T *aBus);
     STDMETHOD(COMGETTER(Channel))    (LONG *aChannel);
     STDMETHOD(COMGETTER(Device))     (LONG *aDevice);
 
-    // public methods for internal purposes only
-    // (ensure there is a caller and a read or write lock before calling them!)
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
 
-    BOOL isDirty() const { return mDirty; }
-    void setDirty (BOOL aDirty) { mDirty = aDirty; }
+    bool isImplicit() const { return m.implicit; }
+    void setImplicit (bool aImplicit) { m.implicit = aImplicit; }
 
-    const ComObjPtr <HardDisk> &hardDisk() const { return mHardDisk; }
-    StorageBus_T bus() const { return mBus; }
-    LONG channel() const { return mChannel; }
-    LONG device() const { return mDevice; }
+    const ComObjPtr <HardDisk2> &hardDisk() const { return m.hardDisk; }
+    StorageBus_T bus() const { return m.bus; }
+    LONG channel() const { return m.channel; }
+    LONG device() const { return m.device; }
 
-    void updateHardDisk (const ComObjPtr <HardDisk> &aHardDisk, BOOL aDirty)
+    /** Must be called from under this object's write lock.  */
+    void updateHardDisk (const ComObjPtr <HardDisk2> &aHardDisk, bool aImplicit)
     {
-        mHardDisk = aHardDisk;
-        mDirty = aDirty;
+        m.hardDisk = aHardDisk;
+        m.implicit = aImplicit;
     }
 
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"HardDiskAttachment"; }
+    /** For com::SupportErrorInfoImpl. */
+    static const char *ComponentName() { return "HardDisk2Attachment"; }
 
 private:
 
-    BOOL mDirty;
-    ComObjPtr <HardDisk> mHardDisk;
-    StorageBus_T mBus;
-    LONG mChannel;
-    LONG mDevice;
+    struct Data
+    {
+        Data() : bus (StorageBus_Null), channel (0), device (0)
+               , implicit (false) {}
+
+        /// @todo NEWMEDIA shouldn't it be constant too? It'd be nice to get
+        /// rid of locks at all in this simple readonly structure-like interface
+        ComObjPtr <HardDisk2> hardDisk;
+        const StorageBus_T bus;
+        const LONG channel;
+        const LONG device;
+
+        bool implicit : 1;
+    };
+
+    Data m;
 };
 
-COM_DECL_READONLY_ENUM_AND_COLLECTION (HardDiskAttachment)
-
 #endif // ____H_HARDDISKATTACHMENTIMPL

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

@@ -87 +87 @@
 public:
 
+    enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
+
     /**
      *  Internal machine data.
@@ -273 +275 @@
      *
      *  The usage policy is the same as for HWData, but a separate structure
-     *  is necessarym because hard disk data requires different procedures when
+     *  is necessary because hard disk data requires different procedures when
      *  taking or discarding snapshots, etc.
      *
@@ -285 +287 @@
         bool operator== (const HDData &that) const;
 
-        typedef std::list <ComObjPtr <HardDiskAttachment> > HDAttachmentList;
-        HDAttachmentList mHDAttachments;
-
-        /**
-         *  Right after Machine::fixupHardDisks(true): |true| if hard disks
-         *  were actually changed, |false| otherwise
-         */
-        bool mHDAttachmentsChanged;
+        typedef std::list <ComObjPtr <HardDisk2Attachment> > AttachmentList;
+        AttachmentList mAttachments;
     };
 
@@ -497 +493 @@
     STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
     STDMETHOD(COMSETTER(SnapshotFolder))(INPTR BSTR aSavedStateFolder);
-    STDMETHOD(COMGETTER(HardDiskAttachments))(IHardDiskAttachmentCollection **attachments);
+    STDMETHOD(COMGETTER(HardDisk2Attachments))(ComSafeArrayOut (IHardDisk2Attachment *, aAttachments));
     STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
     STDMETHOD(COMGETTER(DVDDrive))(IDVDDrive **dvdDrive);
@@ -526 +522 @@
     STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
     STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
-    STDMETHOD(AttachHardDisk)(INPTR GUIDPARAM aId, StorageBus_T aBus, LONG aChannel, LONG aDevice);
-    STDMETHOD(GetHardDisk)(StorageBus_T aBus, LONG aChannel, LONG aDevice, IHardDisk **aHardDisk);
-    STDMETHOD(DetachHardDisk) (StorageBus_T aBus, LONG aChannel, LONG aDevice);
+    STDMETHOD(AttachHardDisk2) (INPTR GUIDPARAM aId, StorageBus_T aBus,
+                                LONG aChannel, LONG aDevice);
+    STDMETHOD(GetHardDisk2) (StorageBus_T aBus, LONG aChannel, LONG aDevice,
+                             IHardDisk2 **aHardDisk);
+    STDMETHOD(DetachHardDisk2) (StorageBus_T aBus, LONG aChannel, LONG aDevice);
     STDMETHOD(GetSerialPort) (ULONG slot, ISerialPort **port);
     STDMETHOD(GetParallelPort) (ULONG slot, IParallelPort **port);
@@ -555 +553 @@
     // public methods only for internal purposes
 
+    InstanceType type() const { return mType; }
+
     /// @todo (dmik) add lock and make non-inlined after revising classes
     //  that use it. Note: they should enter Machine lock to keep the returned
@@ -560 +560 @@
     bool isRegistered() { return !!mData->mRegistered; }
 
-    /**
-     *  Returns the VirtualBox object this machine belongs to.
-     *
-     *  @note This method doesn't check this object's readiness as it is
-     *  intended to be used only by Machine children where it is guaranteed
-     *  that this object still exists in memory.
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+
+    /**
+     * Returns the VirtualBox object this machine belongs to.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after doing addCaller() manually.
      */
     const ComObjPtr <VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
 
     /**
-     *  Returns this machine's name.
-     *
-     *  @note This method doesn't check this object's readiness as it is
-     *  intended to be used only after adding a caller to this object (that
-     *  guarantees that the object is ready or at least limited).
-     */
-    const Guid &uuid() const { return mData->mUuid; }
-
-    /**
-     *  Returns this machine's full settings file path.
-     *
-     *  @note This method doesn't lock this object or check its readiness as
-     *  it is intended to be used only after adding a caller to this object
-     *  (that guarantees that the object is ready) and locking it for reading.
+     * Returns this machine ID.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after adding a caller manually.
+     */
+    const Guid &id() const { return mData->mUuid; }
+
+    /**
+     * Returns the snapshot ID this machine represents or an empty UUID if this
+     * instance is not SnapshotMachine.
+     *
+     * @note This method doesn't check this object's readiness. Intended to be
+     * used by ready Machine children (whose readiness is bound to the parent's
+     * one) or after adding a caller manually.
+     */
+    inline const Guid &snapshotId() const;
+
+    /**
+     * Returns this machine's full settings file path.
+     *
+     * @note This method doesn't lock this object or check its readiness.
+     * Intended to be used only after doing addCaller() manually and locking it
+     * for reading.
      */
     const Bstr &settingsFileFull() const { return mData->mConfigFileFull; }
 
     /**
-     *  Returns this machine's name.
-     *
-     *  @note This method doesn't lock this object or check its readiness as
-     *  it is intended to be used only after adding a caller to this object
-     *  (that guarantees that the object is ready) and locking it for reading.
+     * Returns this machine name.
+     *
+     * @note This method doesn't lock this object or check its readiness.
+     * Intended to be used only after doing addCaller() manually and locking it
+     * for reading.
      */
     const Bstr &name() const { return mUserData->mName; }
@@ -613 +626 @@
 
     void getLogFolder (Utf8Str &aLogFolder);
-
-    bool isDVDImageUsed (const Guid &aId, ResourceUsage_T aUsage);
-    bool isFloppyImageUsed (const Guid &aId, ResourceUsage_T aUsage);
 
     HRESULT openSession (IInternalSessionControl *aControl);
@@ -658 +668 @@
 protected:
 
-    enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
-
     HRESULT registeredInit();
 
@@ -669 +677 @@
     void uninitDataAndChildObjects();
 
-    void ensureNoStateDependencies (AutoWriteLock &aLock);
+    void ensureNoStateDependencies();
 
     virtual HRESULT setMachineState (MachineState_T aMachineState);
@@ -693 +701 @@
                           bool aSetError = false);
 
-    HRESULT findHardDiskAttachment (const ComObjPtr <HardDisk> &aHd,
-                                    ComObjPtr <Machine> *aMachine,
-                                    ComObjPtr <Snapshot> *aSnapshot,
-                                    ComObjPtr <HardDiskAttachment> *aHda);
-
-    HRESULT prepareSaveSettings (bool &aRenamed, bool &aNew);
-    HRESULT saveSettings (bool aMarkCurStateAsModified = true,
-                          bool aInformCallbacksAnyway = false);
-
     enum
     {
-        // ops for #saveSnapshotSettings()
+        /* flags for #saveSettings() */
+        SaveS_ResetCurStateModified = 0x01,
+        SaveS_InformCallbacksAnyway = 0x02,
+        /* ops for #saveSnapshotSettings() */
         SaveSS_NoOp = 0x00, SaveSS_AddOp = 0x01,
         SaveSS_UpdateAttrsOp = 0x02, SaveSS_UpdateAllOp = 0x03,
         SaveSS_OpMask = 0xF,
-        // flags for #saveSnapshotSettings()
-        SaveSS_UpdateCurStateModified = 0x40,
-        SaveSS_UpdateCurrentId = 0x80,
-        // flags for #saveStateSettings()
+        /* flags for #saveSnapshotSettings() */
+        SaveSS_CurStateModified = 0x40,
+        SaveSS_CurrentId = 0x80,
+        /* flags for #saveStateSettings() */
         SaveSTS_CurStateModified = 0x20,
         SaveSTS_StateFilePath = 0x40,
@@ -717 +719 @@
     };
 
+    HRESULT prepareSaveSettings (bool &aRenamed, bool &aNew);
+    HRESULT saveSettings (int aFlags = 0);
+
     HRESULT saveSnapshotSettings (Snapshot *aSnapshot, int aOpFlags);
     HRESULT saveSnapshotSettingsWorker (settings::Key &aMachineNode,
@@ -727 +732 @@
     HRESULT saveStateSettings (int aFlags);
 
-    HRESULT wipeOutImmutableDiffs();
-
-    HRESULT fixupHardDisks (bool aCommit);
-
-    HRESULT createSnapshotDiffs (const Guid *aSnapshotId,
-                                 const Bstr &aFolder,
-                                 const ComObjPtr <Progress> &aProgress,
+    HRESULT createImplicitDiffs (const Bstr &aFolder,
+                                 ComObjPtr <Progress> &aProgress,
                                  bool aOnline);
-    HRESULT deleteSnapshotDiffs (const ComObjPtr <Snapshot> &aSnapshot);
+    HRESULT deleteImplicitDiffs();
+
+    void fixupHardDisks2 (bool aCommit, bool aOnline = false);
 
     HRESULT lockConfig();
@@ -751 +753 @@
     bool isReallyModified (bool aIgnoreUserData = false);
     void rollback (bool aNotify);
-    HRESULT commit();
+    void commit();
     void copyFrom (Machine *aThat);
 
@@ -905 +907 @@
     };
 
-    struct Uninit {
+    struct Uninit
+    {
         enum Reason { Unexpected, Abnormal, Normal };
     };
@@ -1004 +1007 @@
     HRESULT onSnapshotChange (Snapshot *aSnapshot);
 
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+
+    const Guid &snapshotId() const { return mSnapshotId; }
+
 private:
 
@@ -1010 +1018 @@
     friend class Snapshot;
 };
+
+// third party methods that depend on SnapshotMachine definiton
+
+inline const Guid &Machine::snapshotId() const
+{
+    return mType != IsSnapshotMachine ? Guid::Empty :
+                    static_cast <const SnapshotMachine *> (this)->snapshotId();
+}
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1028 +1044 @@
 }
 
-COM_DECL_READONLY_ENUM_AND_COLLECTION (Machine)
-
 #endif // ____H_MACHINEIMPL

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

@@ +1 @@
+/* $Id$ */
 /** @file
  *
@@ -5 +6 @@
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -26 +27 @@
 #include "Collection.h"
 
+#include <VBox/com/SupportErrorInfo.h>
+
 #include <iprt/semaphore.h>
 
@@ -34 +37 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+/**
+ * Base component class for progress objects.
+ */
 class ATL_NO_VTABLE ProgressBase :
-    public VirtualBoxSupportErrorInfoImpl <ProgressBase, IProgress>,
+    public VirtualBoxBaseNEXT,
+    public com::SupportErrorInfoBase,
     public VirtualBoxSupportTranslation <ProgressBase>,
-    public VirtualBoxBase,
     public IProgress
 {
 protected:
 
-    BEGIN_COM_MAP(ProgressBase)
-        COM_INTERFACE_ENTRY(ISupportErrorInfo)
-        COM_INTERFACE_ENTRY(IProgress)
-    END_COM_MAP()
+    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (ProgressBase)
+
+    DECLARE_EMPTY_CTOR_DTOR (ProgressBase)
 
     HRESULT FinalConstruct();
 
-    // public initializer/uninitializer for internal purposes only
-    HRESULT protectedInit (
+    // protected initializer/uninitializer for internal purposes only
+    HRESULT protectedInit (AutoInitSpan &aAutoInitSpan,
 #if !defined (VBOX_COM_INPROC)
                   VirtualBox *aParent,
@@ -56 +61 @@
                   IUnknown *aInitiator,
                   const BSTR aDescription, GUIDPARAMOUT aId = NULL);
-    HRESULT protectedInit();
-    void protectedUninit (AutoWriteLock &alock);
+    HRESULT protectedInit (AutoInitSpan &aAutoInitSpan);
+    void protectedUninit (AutoUninitSpan &aAutoUninitSpan);
 
 public:
@@ -80 +85 @@
     // public methods only for internal purposes
 
-    Guid id() { AutoWriteLock alock (this); return mId; }
-    BOOL completed() { AutoWriteLock alock (this); return mCompleted; }
-    HRESULT resultCode() { AutoWriteLock alock (this); return mResultCode; }
-
-    // for VirtualBoxSupportErrorInfoImpl
-    static const wchar_t *getComponentName() { return L"Progress"; }
+    static HRESULT setErrorInfoOnThread (IProgress *aProgress);
+
+    // unsafe inline public methods for internal purposes only (ensure there is
+    // a caller and a read lock before calling them!)
+
+    BOOL completed() const { return mCompleted; }
+    HRESULT resultCode() const { return mResultCode; }
 
 protected:
 
 #if !defined (VBOX_COM_INPROC)
-    /** weak parent */
-    ComObjPtr <VirtualBox, ComWeakRef> mParent;
-#endif
-    ComPtr <IUnknown> mInitiator;
-
-    Guid mId;
-    Bstr mDescription;
-
-    // the fields below are to be initalized by subclasses
+    /** Weak parent. */
+    const ComObjPtr <VirtualBox, ComWeakRef> mParent;
+#endif
+
+    const ComPtr <IUnknown> mInitiator;
+
+    const Guid mId;
+    const Bstr mDescription;
+
+    /* The fields below are to be properly initalized by subclasses */
 
     BOOL mCompleted;
@@ -114 +121 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+/**
+ * Normal progress object.
+ */
 class ATL_NO_VTABLE Progress :
-    public VirtualBoxSupportTranslation <Progress>,
-    public ProgressBase
+    public com::SupportErrorInfoDerived <ProgressBase, Progress, IProgress>,
+    public VirtualBoxSupportTranslation <Progress>
 {
 
 public:
 
-    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(Progress)
-
-    DECLARE_NOT_AGGREGATABLE(Progress)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (Progress)
+
+    DECLARE_NOT_AGGREGATABLE (Progress)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP(Progress)
-        COM_INTERFACE_ENTRY(ISupportErrorInfo)
-        COM_INTERFACE_ENTRY(IProgress)
+    BEGIN_COM_MAP (Progress)
+        COM_INTERFACE_ENTRY (ISupportErrorInfo)
+        COM_INTERFACE_ENTRY (IProgress)
     END_COM_MAP()
 
@@ -185 +195 @@
                                 const Bstr &aComponent, const Bstr &aText);
 
+    /** For com::SupportErrorInfoImpl. */
+    static const char *ComponentName() { return "Progress"; }
+
 private:
 
@@ -194 +207 @@
 
 /**
- *  The CombinedProgress class allows to combine several progress objects
- *  to a single progress component. This single progress component will treat
- *  all operations of individual progress objects as a single sequence of
- *  operations, that follow each other in the same order as progress objects are
- *  passed to the #init() method.
- *
- *  Individual progress objects are sequentially combined so that this progress
- *  object:
+ * The CombinedProgress class allows to combine several progress objects to a
+ * single progress component. This single progress component will treat all
+ * operations of individual progress objects as a single sequence of operations
+ * that follow each other in the same order as progress objects are passed to
+ * the #init() method.
+ *
+ * Individual progress objects are sequentially combined so that this progress
+ * object:
  *
  *  -   is cancelable only if all progresses are cancelable.
@@ -222 +235 @@
  *      progress, normalized to 100%.
  *
- *  @note
- *      It's the respoisibility of the combined progress object creator
- *      to complete individual progresses in the right order: if, let's say,
- *      the last progress is completed before all previous ones,
- *      #WaitForCompletion(-1) will most likely give 100% CPU load because it
- *      will be in a loop calling a method that returns immediately.
+ * @note It's the respoisibility of the combined progress object creator to
+ *       complete individual progresses in the right order: if, let's say, the
+ *       last progress is completed before all previous ones,
+ *       #WaitForCompletion(-1) will most likely give 100% CPU load because it
+ *       will be in a loop calling a method that returns immediately.
  */
 class ATL_NO_VTABLE CombinedProgress :
-    public VirtualBoxSupportTranslation <CombinedProgress>,
-    public ProgressBase
+    public com::SupportErrorInfoDerived <ProgressBase, CombinedProgress, IProgress>,
+    public VirtualBoxSupportTranslation <CombinedProgress>
 {
 
 public:
 
-    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(CombinedProgress)
-
-    DECLARE_NOT_AGGREGATABLE(CombinedProgress)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (CombinedProgress)
+
+    DECLARE_NOT_AGGREGATABLE (CombinedProgress)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP(CombinedProgress)
-        COM_INTERFACE_ENTRY(ISupportErrorInfo)
-        COM_INTERFACE_ENTRY(IProgress)
+    BEGIN_COM_MAP (CombinedProgress)
+        COM_INTERFACE_ENTRY (ISupportErrorInfo)
+        COM_INTERFACE_ENTRY (IProgress)
     END_COM_MAP()
 
@@ -261 +273 @@
                   const BSTR aDescription,
                   IProgress *aProgress1, IProgress *aProgress2,
-                  GUIDPARAMOUT aId = NULL)
-    {
-        AutoWriteLock alock (this);
-        ComAssertRet (!isReady(), E_UNEXPECTED);
-
-        mProgresses.resize (2);
-        mProgresses [0] = aProgress1;
-        mProgresses [1] = aProgress2;
-
-        return protectedInit (
-#if !defined (VBOX_COM_INPROC)
-                              aParent,
-#endif
-                              aInitiator, aDescription, aId);
-    }
-
+                  GUIDPARAMOUT aId = NULL);
+
+    /**
+     * Initializes the combined progress object given the first and the last
+     * normal progress object from the list.
+     *
+     * @param aParent       See ProgressBase::init().
+     * @param aInitiator    See ProgressBase::init().
+     * @param aDescription  See ProgressBase::init().
+     * @param aFirstProgress Iterator of the first normal progress object.
+     * @param aSecondProgress Iterator of the last normal progress object.
+     * @param aId           See ProgressBase::init().
+     */
     template <typename InputIterator>
     HRESULT init (
@@ -287 +296 @@
                   GUIDPARAMOUT aId = NULL)
     {
-        AutoWriteLock alock (this);
-        ComAssertRet (!isReady(), E_UNEXPECTED);
+        /* Enclose the state transition NotReady->InInit->Ready */
+        AutoInitSpan autoInitSpan (this);
+        AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
 
         mProgresses = ProgressVector (aFirstProgress, aLastProgress);
 
-        return protectedInit (
-#if !defined (VBOX_COM_INPROC)
-                              aParent,
-#endif
-                              aInitiator, aDescription, aId);
+        HRESULT rc = protectedInit (autoInitSpan,
+#if !defined (VBOX_COM_INPROC)
+                                    aParent,
+#endif
+                                    aInitiator, aDescription, aId);
+
+        /* Confirm a successful initialization when it's the case */
+        if (SUCCEEDED (rc))
+            autoInitSpan.setSucceeded();
+
+        return rc;
     }
 
 protected:
 
-    HRESULT protectedInit (
+    HRESULT protectedInit (AutoInitSpan &aAutoInitSpan,
 #if !defined (VBOX_COM_INPROC)
                            VirtualBox *aParent,
@@ -329 +345 @@
     // public methods only for internal purposes
 
+    /** For com::SupportErrorInfoImpl. */
+    static const char *ComponentName() { return "CombinedProgress"; }
+
 private:
 
@@ -342 +361 @@
 COM_DECL_READONLY_ENUM_AND_COLLECTION_AS (Progress, IProgress)
 
-#endif // ____H_PROGRESSIMPL
+#endif /* ____H_PROGRESSIMPL */

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

@@ -113 +113 @@
     ComObjPtr <Snapshot> findChildOrSelf (INPTR BSTR aName);
 
-    bool isDVDImageUsed (const Guid &aId);
-    bool isFloppyImageUsed (const Guid &aId);
-
     void updateSavedStatePaths (const char *aOldPath, const char *aNewPath);
 

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

@@ -26 +26 @@
 
 #include "VirtualBoxBase.h"
+#include "HardDiskFormatImpl.h"
+
+#include <VBox/com/array.h>
+
+#include <list>
 
 class VirtualBox;
@@ -66 +71 @@
     STDMETHOD(COMGETTER(ParallelPortCount) (ULONG *count));
     STDMETHOD(COMGETTER(MaxBootPosition) (ULONG *aMaxBootPosition));
-    STDMETHOD(COMGETTER(DefaultVDIFolder)) (BSTR *aDefaultVDIFolder);
-    STDMETHOD(COMSETTER(DefaultVDIFolder)) (INPTR BSTR aDefaultVDIFolder);
     STDMETHOD(COMGETTER(DefaultMachineFolder)) (BSTR *aDefaultMachineFolder);
     STDMETHOD(COMSETTER(DefaultMachineFolder)) (INPTR BSTR aDefaultMachineFolder);
+    STDMETHOD(COMGETTER(DefaultHardDiskFolder)) (BSTR *aDefaultHardDiskFolder);
+    STDMETHOD(COMSETTER(DefaultHardDiskFolder)) (INPTR BSTR aDefaultHardDiskFolder);
+    STDMETHOD(COMGETTER(HardDiskFormats)) (ComSafeArrayOut (IHardDiskFormat *, aHardDiskFormats));
     STDMETHOD(COMGETTER(RemoteDisplayAuthLibrary)) (BSTR *aRemoteDisplayAuthLibrary);
     STDMETHOD(COMSETTER(RemoteDisplayAuthLibrary)) (INPTR BSTR aRemoteDisplayAuthLibrary);
@@ -84 +90 @@
     HRESULT saveSettings (settings::Key &aGlobal);
 
-    /** Default VDI path (as is, not full). Not thread safe (use object lock). */
-    const Bstr &defaultVDIFolder() { return mDefaultVDIFolder; }
-    /** Default Machine path (full). Not thread safe (use object lock). */
-    const Bstr &defaultVDIFolderFull() { return mDefaultVDIFolderFull; }
     /** Default Machine path (as is, not full). Not thread safe (use object lock). */
     const Bstr &defaultMachineFolder() { return mDefaultMachineFolder; }
     /** Default Machine path (full). Not thread safe (use object lock). */
     const Bstr &defaultMachineFolderFull() { return mDefaultMachineFolderFull; }
+    /** Default hard disk path (as is, not full). Not thread safe (use object lock). */
+    const Bstr &defaultHardDiskFolder() { return mDefaultHardDiskFolder; }
+    /** Default hard disk path (full). Not thread safe (use object lock). */
+    const Bstr &defaultHardDiskFolderFull() { return mDefaultHardDiskFolderFull; }
 
     // for VirtualBoxSupportErrorInfoImpl
@@ -98 +104 @@
 private:
 
-    HRESULT setDefaultVDIFolder (const BSTR aPath);
+    typedef std::list <ComObjPtr <HardDiskFormat> > HardDiskFormatList;
+
     HRESULT setDefaultMachineFolder (const BSTR aPath);
+    HRESULT setDefaultHardDiskFolder (const BSTR aPath);
     HRESULT setRemoteDisplayAuthLibrary (const BSTR aPath);
     HRESULT setWebServiceAuthLibrary (const BSTR aPath);
@@ -105 +113 @@
     ComObjPtr <VirtualBox, ComWeakRef> mParent;
 
-    Bstr mDefaultVDIFolder;
-    Bstr mDefaultVDIFolderFull;
     Bstr mDefaultMachineFolder;
     Bstr mDefaultMachineFolderFull;
+    Bstr mDefaultHardDiskFolder;
+    Bstr mDefaultHardDiskFolderFull;
+
+    HardDiskFormatList mHardDiskFormats;
+
     Bstr mRemoteDisplayAuthLibrary;
     Bstr mWebServiceAuthLibrary;

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

@@ -48 +48 @@
 #include <atlcom.h>
 
-//  use a special version of the singleton class factory,
-//  see KB811591 in msdn for more info.
+/* use a special version of the singleton class factory,
+ * see KB811591 in msdn for more info. */
 
 #undef DECLARE_CLASSFACTORY_SINGLETON
@@ -120 +120 @@
 };
 
-#endif // !defined (VBOX_WITH_XPCOM)
+#endif /* !defined (VBOX_WITH_XPCOM) */
 
 // macros
@@ -434 +434 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-class ATL_NO_VTABLE VirtualBoxBaseNEXT_base
-#if !defined (VBOX_WITH_XPCOM)
-    : public CComObjectRootEx <CComMultiThreadModel>
-#else
-    : public CComObjectRootEx
-#endif
-    , public Lockable
+/**
+ * Abstract base class for all component classes implementing COM
+ * interfaces of the VirtualBox COM library.
+ *
+ * Declares functionality that should be available in all components.
+ *
+ * Note that this class is always subclassed using the virtual keyword so
+ * that only one instance of its VTBL and data is present in each derived class
+ * even in case if VirtualBoxBaseProto appears more than once among base classes
+ * of the particular component as a result of multiple inheritance.
+ *
+ * This makes it possible to have intermediate base classes used by several
+ * components that implement some common interface fuctionality but still let
+ * the final component classe choose what VirtualBoxBase variant it wants to
+ * use.
+ *
+ * Among the basic functionality implemented by this class is the primary object
+ * state that indicates if the object is ready to serve the calls, and if not,
+ * what stage it is currently at. Here is the pirmary state diagram:
+ *
+ *              +-------------------------------------------------------+
+ *              |                                                       |
+ *              |         (InitFailed) -----------------------+         |
+ *              |              ^                              |         |
+ *              v              |                              v         |
+ *  [*] ---> NotReady ----> (InInit) -----> Ready -----> (InUninit) ----+
+ *                     ^       |      ^       |               ^
+ *                     |       v      |       v               |
+ *                     |    Limited   |  (MayUninit) --> (WillUninit)
+ *                     |       |      |       |
+ *                     +-------+      +-------+
+ *
+ * The object is fully operational only when its state is Ready. The Limited
+ * state means that only some vital part of the object is operational, and it
+ * requires some sort of reinitialization to become fully operational. The
+ * NotReady state means the object is basically dead: it either was not yet
+ * initialized after creation at all, or was uninitialized and is waiting to be
+ * destroyed when the last reference to it is released. All other states are
+ * transitional.
+ *
+ * The NotReady->InInit->Ready, NotReady->InInit->Limited and
+ * NotReady->InInit->InitFailed transition is done by the AutoInitSpan smart
+ * class.
+ *
+ * The Limited->InInit->Ready, Limited->InInit->Limited and
+ * Limited->InInit->InitFailed transition is done by the AutoReinitSpan smart
+ * class.
+ *
+ * The Ready->InUninit->NotReady, InitFailed->InUninit->NotReady and
+ * WillUninit->InUninit->NotReady transitions are done by the AutoUninitSpan
+ * smart class.
+ *
+ * The Ready->MayUninit->Ready and Ready->MayUninit->WillUninit transitions are
+ * done by the AutoMayUninitSpan smart class.
+ *
+ * In order to maintain the primary state integrity and declared functionality
+ * all subclasses must:
+ *
+ * 1) Use the above Auto*Span classes to perform state transitions. See the
+ *    individual class doescriptions for details.
+ *
+ * 2) All public methods of subclasses (i.e. all methods that can be called
+ *    directly, not only from within other methods of the subclass) must have a
+ *    standard prolog as described in the AutoCaller and AutoLimitedCaller
+ *    documentation. Alternatively, they must use addCaller()/releaseCaller()
+ *    directly (and therefire have both the prolog and the epilog), but this is
+ *    not recommended.
+ */
+class ATL_NO_VTABLE VirtualBoxBaseProto : public Lockable
 {
 public:
 
-    enum State { NotReady, Ready, InInit, InUninit, InitFailed, Limited };
+    enum State { NotReady, Ready, InInit, InUninit, InitFailed, Limited,
+                 MayUninit, WillUninit };
 
 protected:
 
-    VirtualBoxBaseNEXT_base();
-    virtual ~VirtualBoxBaseNEXT_base();
+    VirtualBoxBaseProto();
+    virtual ~VirtualBoxBaseProto();
 
 public:
@@ -457 +520 @@
 
     /**
-     *  Virtual unintialization method.
-     *  Must be called by all implementations (COM classes) when the last
-     *  reference to the object is released, before calling the destructor.
-     *  Also, this method is called automatically by the uninit() method of the
-     *  parent of this object, when this object is a dependent child of a class
-     *  derived from VirtualBoxBaseWithChildren (@sa
-     *  VirtualBoxBaseWithChildren::addDependentChild).
+     * Unintialization method.
+     *
+     * Must be called by all final implementations (component classes) when the
+     * last reference to the object is released, before calling the destructor.
+     *
+     * This method is also automatically called by the uninit() method of this
+     * object's parent if this object is a dependent child of a class derived
+     * from VirtualBoxBaseWithChildren (see
+     * VirtualBoxBaseWithChildren::addDependentChild).
+     *
+     * @note Never call this method the AutoCaller scope or after the
+     *       #addCaller() call not paired by #releaseCaller() because it is a
+     *       guaranteed deadlock. See AutoUninitSpan for details.
      */
     virtual void uninit() {}
@@ -471 +540 @@
 
     /**
-     *  Adds a limited caller. This method is equivalent to doing
-     *  <tt>addCaller (aState, true)</tt>, but it is preferred because
-     *  provides better self-descriptiveness. See #addCaller() for more info.
+     * Adds a limited caller. This method is equivalent to doing
+     * <tt>addCaller (aState, true)</tt>, but it is preferred because provides
+     * better self-descriptiveness. See #addCaller() for more info.
      */
     HRESULT addLimitedCaller (State *aState = NULL)
@@ -481 +550 @@
 
     /**
-     *  Smart class that automatically increases the number of callers of the
-     *  given VirtualBoxBase object when an instance is constructed and decreases
-     *  it back when the created instance goes out of scope (i.e. gets destroyed).
-     *
-     *  If #rc() returns a failure after the instance creation, it means that
-     *  the managed VirtualBoxBase object is not Ready, or in any other invalid
-     *  state, so that the caller must not use the object and can return this
-     *  failed result code to the upper level.
-     *
-     *  See VirtualBoxBase::addCaller(), VirtualBoxBase::addLimitedCaller() and
-     *  VirtualBoxBase::releaseCaller() for more details about object callers.
-     *
-     *  @param aLimited |false| if this template should use
+     * Smart class that automatically increases the number of callers of the
+     * given VirtualBoxBase object when an instance is constructed and decreases
+     * it back when the created instance goes out of scope (i.e. gets destroyed).
+     *
+     * If #rc() returns a failure after the instance creation, it means that
+     * the managed VirtualBoxBase object is not Ready, or in any other invalid
+     * state, so that the caller must not use the object and can return this
+     * failed result code to the upper level.
+     *
+     * See VirtualBoxBase::addCaller(), VirtualBoxBase::addLimitedCaller() and
+     * VirtualBoxBase::releaseCaller() for more details about object callers.
+     *
+     * @param aLimited  |false| if this template should use
      *                  VirtualiBoxBase::addCaller() calls to add callers, or
      *                  |true| if VirtualiBoxBase::addLimitedCaller() should be
      *                  used.
      *
-     *  @note It is preferrable to use the AutoCaller and AutoLimitedCaller
-     *        classes than specify the @a aLimited argument, for better
-     *        self-descriptiveness.
+     * @note It is preferrable to use the AutoCaller and AutoLimitedCaller
+     *       classes than specify the @a aLimited argument, for better
+     *       self-descriptiveness.
      */
     template <bool aLimited>
@@ -508 +577 @@
 
         /**
-         *  Increases the number of callers of the given object
-         *  by calling VirtualBoxBase::addCaller().
+         * Increases the number of callers of the given object by calling
+         * VirtualBoxBase::addCaller().
          *
-         *  @param aObj     Object to add a caller to. If NULL, this
+         * @param aObj      Object to add a caller to. If NULL, this
          *                  instance is effectively turned to no-op (where
          *                  rc() will return S_OK and state() will be
          *                  NotReady).
          */
-        AutoCallerBase (VirtualBoxBaseNEXT_base *aObj)
+        AutoCallerBase (VirtualBoxBaseProto *aObj)
             : mObj (aObj)
             , mRC (S_OK)
@@ -526 +595 @@
 
         /**
-         *  If the number of callers was successfully increased,
-         *  decreases it using VirtualBoxBase::releaseCaller(), otherwise
-         *  does nothing.
+         * If the number of callers was successfully increased, decreases it
+         * using VirtualBoxBase::releaseCaller(), otherwise does nothing.
          */
         ~AutoCallerBase()
@@ -537 +605 @@
 
         /**
-         *  Stores the result code returned by VirtualBoxBase::addCaller()
-         *  after instance creation or after the last #add() call. A successful
-         *  result code means the number of callers was successfully increased.
+         * Stores the result code returned by VirtualBoxBase::addCaller() after
+         * instance creation or after the last #add() call. A successful result
+         * code means the number of callers was successfully increased.
          */
         HRESULT rc() const { return mRC; }
 
         /**
-         *  Returns |true| if |SUCCEEDED (rc())| is |true|, for convenience.
-         *  |true| means the number of callers was successfully increased.
+         * Returns |true| if |SUCCEEDED (rc())| is |true|, for convenience.
+         * |true| means the number of callers was successfully increased.
          */
         bool isOk() const { return SUCCEEDED (mRC); }
 
         /**
-         *  Stores the object state returned by VirtualBoxBase::addCaller()
-         *  after instance creation or after the last #add() call.
+         * Stores the object state returned by VirtualBoxBase::addCaller() after
+         * instance creation or after the last #add() call.
          */
         State state() const { return mState; }
 
         /**
-         *  Temporarily decreases the number of callers of the managed object.
-         *  May only be called if #isOk() returns |true|. Note that #rc() will
-         *  return E_FAIL after this method succeeds.
+         * Temporarily decreases the number of callers of the managed object.
+         * May only be called if #isOk() returns |true|. Note that #rc() will
+         * return E_FAIL after this method succeeds.
          */
         void release()
@@ -572 +640 @@
 
         /**
-         *  Restores the number of callers decreased by #release(). May only
-         *  be called after #release().
+         * Restores the number of callers decreased by #release(). May only be
+         * called after #release().
          */
         void add()
@@ -582 +650 @@
         }
 
+        /**
+         * Attaches another object to this caller instance.
+         * The previous object's caller is released before the new one is added.
+         *
+         * @param aObj  New object to attach, may be @c NULL.
+         */
+        void attach (VirtualBoxBaseProto *aObj)
+        {
+            /* detect simple self-reattachment */
+            if (mObj != aObj)
+            {
+                if (mObj && SUCCEEDED (mRC))
+                    release();
+                mObj = aObj;
+                add();
+            }
+        }
+
+        /** Verbose equivalent to <tt>attach (NULL)</tt>. */
+        void detach() { attach (NULL); }
+
     private:
 
@@ -587 +676 @@
         DECLARE_CLS_NEW_DELETE_NOOP (AutoCallerBase)
 
-        VirtualBoxBaseNEXT_base *mObj;
+        VirtualBoxBaseProto *mObj;
         HRESULT mRC;
         State mState;
@@ -593 +682 @@
 
     /**
-     *  Smart class that automatically increases the number of normal
-     *  (non-limited) callers of the given VirtualBoxBase object when an
-     *  instance is constructed and decreases it back when the created instance
-     *  goes out of scope (i.e. gets destroyed).
-     *
-     *  A typical usage pattern to declare a normal method of some object
-     *  (i.e. a method that is valid only when the object provides its
-     *  full functionality) is:
-     *  <code>
-     *  STDMETHODIMP Component::Foo()
-     *  {
-     *      AutoCaller autoCaller (this);
-     *      CheckComRCReturnRC (autoCaller.rc());
-     *      ...
-     *  </code>
-     *
-     *  Using this class is equivalent to using the AutoCallerBase template
-     *  with the @a aLimited argument set to |false|, but this class is
-     *  preferred because provides better self-descriptiveness.
-     *
-     *  See AutoCallerBase for more information about auto caller functionality.
+     * Smart class that automatically increases the number of normal
+     * (non-limited) callers of the given VirtualBoxBase object when an instance
+     * is constructed and decreases it back when the created instance goes out
+     * of scope (i.e. gets destroyed).
+     *
+     * A typical usage pattern to declare a normal method of some object (i.e. a
+     * method that is valid only when the object provides its full
+     * functionality) is:
+     * <code>
+     * STDMETHODIMP Component::Foo()
+     * {
+     *     AutoCaller autoCaller (this);
+     *     CheckComRCReturnRC (autoCaller.rc());
+     *     ...
+     * </code>
+     *
+     * Using this class is equivalent to using the AutoCallerBase template with
+     * the @a aLimited argument set to |false|, but this class is preferred
+     * because provides better self-descriptiveness.
+     *
+     * See AutoCallerBase for more information about auto caller functionality.
      */
     typedef AutoCallerBase <false> AutoCaller;
 
     /**
-     *  Smart class that automatically increases the number of limited callers
-     *  of the given VirtualBoxBase object when an instance is constructed and
-     *  decreases it back when the created instance goes out of scope (i.e.
-     *  gets destroyed).
-     *
-     *  A typical usage pattern to declare a limited method of some object
-     *  (i.e. a method that is valid even if the object doesn't provide its
-     *  full functionality) is:
-     *  <code>
-     *  STDMETHODIMP Component::Bar()
-     *  {
-     *      AutoLimitedCaller autoCaller (this);
-     *      CheckComRCReturnRC (autoCaller.rc());
-     *      ...
-     *  </code>
-     *
-     *  Using this class is equivalent to using the AutoCallerBase template
-     *  with the @a aLimited argument set to |true|, but this class is
-     *  preferred because provides better self-descriptiveness.
-     *
-     *  See AutoCallerBase for more information about auto caller functionality.
+     * Smart class that automatically increases the number of limited callers of
+     * the given VirtualBoxBase object when an instance is constructed and
+     * decreases it back when the created instance goes out of scope (i.e. gets
+     * destroyed).
+     *
+     * A typical usage pattern to declare a limited method of some object (i.e.
+     * a method that is valid even if the object doesn't provide its full
+     * functionality) is:
+     * <code>
+     * STDMETHODIMP Component::Bar()
+     * {
+     *     AutoLimitedCaller autoCaller (this);
+     *     CheckComRCReturnRC (autoCaller.rc());
+     *     ...
+     * </code>
+     *
+     * Using this class is equivalent to using the AutoCallerBase template with
+     * the @a aLimited argument set to |true|, but this class is preferred
+     * because provides better self-descriptiveness.
+     *
+     * See AutoCallerBase for more information about auto caller functionality.
      */
     typedef AutoCallerBase <true> AutoLimitedCaller;
@@ -645 +734 @@
 
     /**
-     *  Smart class to enclose the state transition NotReady->InInit->Ready.
-     *
-     *  Instances must be created at the beginning of init() methods of
-     *  VirtualBoxBase subclasses as a stack-based variable using |this| pointer
-     *  as the argument. When this variable is created it automatically places
-     *  the object to the InInit state.
-     *
-     *  When the created variable goes out of scope (i.e. gets destroyed),
-     *  depending on the success status of this initialization span, it either
-     *  places the object to the Ready state or calls the object's
-     *  VirtualBoxBase::uninit() method which is supposed to place the object
-     *  back to the NotReady state using the AutoUninitSpan class.
-     *
-     *  The initial success status of the initialization span is determined by
-     *  the @a aSuccess argument of the AutoInitSpan constructor (|false| by
-     *  default). Inside the initialization span, the success status can be set
-     *  to |true| using #setSucceeded() or to |false| using #setFailed(). Please
-     *  don't forget to set the correct success status before letting the
-     *  AutoInitSpan variable go out of scope (for example, by performing an
-     *  early return from the init() method)!
-     *
-     *  Note that if an instance of this class gets constructed when the
-     *  object is in the state other than NotReady, #isOk() returns |false| and
-     *  methods of this class do nothing: the state transition is not performed.
-     *
-     *  A typical usage pattern is:
-     *  <code>
-     *  HRESULT Component::init()
-     *  {
-     *      AutoInitSpan autoInitSpan (this);
-     *      AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
-     *      ...
-     *      if (FAILED (rc))
-     *          return rc;
-     *      ...
-     *      if (SUCCEEDED (rc))
-     *          autoInitSpan.setSucceeded();
-     *      return rc;
-     *  }
-     *  </code>
-     *
-     *  @note Never create instances of this class outside init() methods of
-     *  VirtualBoxBase subclasses and never pass anything other than |this| as
-     *  the argument to the constructor!
+     * Smart class to enclose the state transition NotReady->InInit->Ready.
+     *
+     * The purpose of this span is to protect object initialization.
+     *
+     * Instances must be created as a stack-based variable taking |this| pointer
+     * as the argument at the beginning of init() methods of VirtualBoxBase
+     * subclasses. When this variable is created it automatically places the
+     * object to the InInit state.
+     *
+     * When the created variable goes out of scope (i.e. gets destroyed) then,
+     * depending on the result status of this initialization span, it either
+     * places the object to Ready or Limited state or calls the object's
+     * VirtualBoxBase::uninit() method which is supposed to place the object
+     * back to the NotReady state using the AutoUninitSpan class.
+     *
+     * The initial result status of the initialization span is determined by the
+     * @a aResult argument of the AutoInitSpan constructor (Result::Failed by
+     * default). Inside the initialization span, the success status can be set
+     * to Result::Succeeded using #setSucceeded(), to to Result::Limited using
+     * #setLimited() or to Result::Failed using #setFailed(). Please don't
+     * forget to set the correct success status before getting the AutoInitSpan
+     * variable destryed (for example, by performing an early return from
+     * the init() method)!
+     *
+     * Note that if an instance of this class gets constructed when the object
+     * is in the state other than NotReady, #isOk() returns |false| and methods
+     * of this class do nothing: the state transition is not performed.
+     *
+     * A typical usage pattern is:
+     * <code>
+     * HRESULT Component::init()
+     * {
+     *     AutoInitSpan autoInitSpan (this);
+     *     AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
+     *     ...
+     *     if (FAILED (rc))
+     *         return rc;
+     *     ...
+     *     if (SUCCEEDED (rc))
+     *         autoInitSpan.setSucceeded();
+     *     return rc;
+     * }
+     * </code>
+     *
+     * @note Never create instances of this class outside init() methods of
+     *       VirtualBoxBase subclasses and never pass anything other than |this|
+     *       as the argument to the constructor!
      */
     class AutoInitSpan
@@ -694 +786 @@
     public:
 
-        enum Status { Failed = 0x0, Succeeded = 0x1, Limited = 0x2 };
-
-        AutoInitSpan (VirtualBoxBaseNEXT_base *aObj, Status aStatus = Failed);
+        enum Result { Failed = 0x0, Succeeded = 0x1, Limited = 0x2 };
+
+        AutoInitSpan (VirtualBoxBaseProto *aObj, Result aResult = Failed);
         ~AutoInitSpan();
 
         /**
-         *  Returns |true| if this instance has been created at the right moment
-         *  (when the object was in the NotReady state) and |false| otherwise.
+         * Returns |true| if this instance has been created at the right moment
+         * (when the object was in the NotReady state) and |false| otherwise.
          */
         bool isOk() const { return mOk; }
 
         /**
-         *  Sets the initialization status to Succeeded to indicates successful
-         *  initialization. The AutoInitSpan destructor will place the managed
-         *  VirtualBoxBase object to the Ready state.
+         * Sets the initialization status to Succeeded to indicates successful
+         * initialization. The AutoInitSpan destructor will place the managed
+         * VirtualBoxBase object to the Ready state.
          */
-        void setSucceeded() { mStatus = Succeeded; }
+        void setSucceeded() { mResult = Succeeded; }
 
         /**
-         *  Sets the initialization status to Succeeded to indicate limited
-         *  (partly successful) initialization. The AutoInitSpan destructor will
-         *  place the managed VirtualBoxBase object to the Limited state.
+         * Sets the initialization status to Succeeded to indicate limited
+         * (partly successful) initialization. The AutoInitSpan destructor will
+         * place the managed VirtualBoxBase object to the Limited state.
          */
-        void setLimited() { mStatus = Limited; }
+        void setLimited() { mResult = Limited; }
 
         /**
-         *  Sets the initialization status to Failure to indicates failed
-         *  initialization. The AutoInitSpan destructor will place the managed
-         *  VirtualBoxBase object to the InitFailed state and will automatically
-         *  call its uninit() method which is supposed to place the object back
-         *  to the NotReady state using AutoUninitSpan.
+         * Sets the initialization status to Failure to indicates failed
+         * initialization. The AutoInitSpan destructor will place the managed
+         * VirtualBoxBase object to the InitFailed state and will automatically
+         * call its uninit() method which is supposed to place the object back
+         * to the NotReady state using AutoUninitSpan.
          */
-        void setFailed() { mStatus = Failed; }
-
-        /** Returns the current initialization status. */
-        Status status() { return mStatus; }
+        void setFailed() { mResult = Failed; }
+
+        /** Returns the current initialization result. */
+        Result result() { return mResult; }
 
     private:
@@ -736 +828 @@
         DECLARE_CLS_NEW_DELETE_NOOP (AutoInitSpan)
 
-        VirtualBoxBaseNEXT_base *mObj;
-        Status mStatus : 3; // must be at least total number of bits + 1 (sign)
+        VirtualBoxBaseProto *mObj;
+        Result mResult : 3; // must be at least total number of bits + 1 (sign)
         bool mOk : 1;
     };
 
     /**
-     *  Smart class to enclose the state transition Limited->InInit->Ready.
-     *
-     *  Instances must be created at the beginning of methods of VirtualBoxBase
-     *  subclasses that try to re-initialize the object to bring it to the
-     *  Ready state (full functionality) after partial initialization
-     *  (limited functionality)>, as a stack-based variable using |this| pointer
-     *  as the argument. When this variable is created it automatically places
-     *  the object to the InInit state.
-     *
-     *  When the created variable goes out of scope (i.e. gets destroyed),
-     *  depending on the success status of this initialization span, it either
-     *  places the object to the Ready state or brings it back to the Limited
-     *  state.
-     *
-     *  The initial success status of the re-initialization span is |false|.
-     *  In order to make it successful, #setSucceeded() must be called before
-     *  the instance is destroyed.
-     *
-     *  Note that if an instance of this class gets constructed when the
-     *  object is in the state other than Limited, #isOk() returns |false| and
-     *  methods of this class do nothing: the state transition is not performed.
-     *
-     *  A typical usage pattern is:
-     *  <code>
-     *  HRESULT Component::reinit()
-     *  {
-     *      AutoReadySpan autoReadySpan (this);
-     *      AssertReturn (autoReadySpan.isOk(), E_UNEXPECTED);
-     *      ...
-     *      if (FAILED (rc))
-     *          return rc;
-     *      ...
-     *      if (SUCCEEDED (rc))
-     *          autoReadySpan.setSucceeded();
-     *      return rc;
-     *  }
-     *  </code>
-     *
-     *  @note Never create instances of this class outside re-initialization
-     *  methods of VirtualBoxBase subclasses and never pass anything other than
-     *  |this| as the argument to the constructor!
-     */
-    class AutoReadySpan
+     * Smart class to enclose the state transition Limited->InInit->Ready.
+     *
+     * The purpose of this span is to protect object re-initialization.
+     *
+     * Instances must be created as a stack-based variable taking |this| pointer
+     * as the argument at the beginning of methods of VirtualBoxBase
+     * subclasses that try to re-initialize the object to bring it to the Ready
+     * state (full functionality) after partial initialization (limited
+     * functionality). When this variable is created, it automatically places
+     * the object to the InInit state.
+     *
+     * When the created variable goes out of scope (i.e. gets destroyed),
+     * depending on the success status of this initialization span, it either
+     * places the object to the Ready state or brings it back to the Limited
+     * state.
+     *
+     * The initial success status of the re-initialization span is |false|. In
+     * order to make it successful, #setSucceeded() must be called before the
+     * instance is destroyed.
+     *
+     * Note that if an instance of this class gets constructed when the object
+     * is in the state other than Limited, #isOk() returns |false| and methods
+     * of this class do nothing: the state transition is not performed.
+     *
+     * A typical usage pattern is:
+     * <code>
+     * HRESULT Component::reinit()
+     * {
+     *     AutoReinitSpan autoReinitSpan (this);
+     *     AssertReturn (autoReinitSpan.isOk(), E_UNEXPECTED);
+     *     ...
+     *     if (FAILED (rc))
+     *         return rc;
+     *     ...
+     *     if (SUCCEEDED (rc))
+     *         autoReinitSpan.setSucceeded();
+     *     return rc;
+     * }
+     * </code>
+     *
+     * @note Never create instances of this class outside re-initialization
+     * methods of VirtualBoxBase subclasses and never pass anything other than
+     * |this| as the argument to the constructor!
+     */
+    class AutoReinitSpan
     {
     public:
 
-        AutoReadySpan (VirtualBoxBaseNEXT_base *aObj);
-        ~AutoReadySpan();
+        AutoReinitSpan (VirtualBoxBaseProto *aObj);
+        ~AutoReinitSpan();
 
         /**
-         *  Returns |true| if this instance has been created at the right moment
-         *  (when the object was in the Limited state) and |false| otherwise.
+         * Returns |true| if this instance has been created at the right moment
+         * (when the object was in the Limited state) and |false| otherwise.
          */
         bool isOk() const { return mOk; }
 
         /**
-         *  Sets the re-initialization status to Succeeded to indicates
-         *  successful re-initialization. The AutoReadySpan destructor will
-         *  place the managed VirtualBoxBase object to the Ready state.
+         * Sets the re-initialization status to Succeeded to indicates
+         * successful re-initialization. The AutoReinitSpan destructor will place
+         * the managed VirtualBoxBase object to the Ready state.
          */
         void setSucceeded() { mSucceeded = true; }
@@ -806 +900 @@
     private:
 
-        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoReadySpan)
-        DECLARE_CLS_NEW_DELETE_NOOP (AutoReadySpan)
-
-        VirtualBoxBaseNEXT_base *mObj;
+        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoReinitSpan)
+        DECLARE_CLS_NEW_DELETE_NOOP (AutoReinitSpan)
+
+        VirtualBoxBaseProto *mObj;
         bool mSucceeded : 1;
         bool mOk : 1;
@@ -815 +909 @@
 
     /**
-     *  Smart class to enclose the state transition Ready->InUnnit->NotReady or
-     *  InitFailed->InUnnit->NotReady.
-     *
-     *  Must be created at the beginning of uninit() methods of VirtualBoxBase
-     *  subclasses as a stack-based variable using |this| pointer as the argument.
-     *  When this variable is created it automatically places the object to the
-     *  InUninit state, unless it is already in the NotReady state as indicated
-     *  by #uninitDone() returning |true|. In the latter case, the uninit()
-     *  method must immediately return because there should be nothing to
-     *  uninitialize.
-     *
-     *  When this variable goes out of scope (i.e. gets destroyed), it places
-     *  the object to the NotReady state.
-     *
-     *  A typical usage pattern is:
-     *  <code>
-     *  void Component::uninit()
-     *  {
-     *      AutoUninitSpan autoUninitSpan (this);
-     *      if (autoUninitSpan.uninitDone())
-     *          retrun;
-     *      ...
-     *  </code>
-     *
-     *  @note Never create instances of this class outside uninit() methods and
-     *  never pass anything other than |this| as the argument to the constructor!
+     * Smart class to enclose the state transition Ready->InUnnit->NotReady,
+     * InitFailed->InUnnit->NotReady or WillUninit->InUnnit->NotReady.
+     *
+     * The purpose of this span is to protect object uninitialization.
+     *
+     * Instances must be created as a stack-based variable taking |this| pointer
+     * as the argument at the beginning of uninit() methods of VirtualBoxBase
+     * subclasses. When this variable is created it automatically places the
+     * object to the InUninit state, unless it is already in the NotReady state
+     * as indicated by #uninitDone() returning |true|. In the latter case, the
+     * uninit() method must immediately return because there should be nothing
+     * to uninitialize.
+     *
+     * When this variable goes out of scope (i.e. gets destroyed), it places the
+     * object to NotReady state.
+     *
+     * A typical usage pattern is:
+     * <code>
+     * void Component::uninit()
+     * {
+     *     AutoUninitSpan autoUninitSpan (this);
+     *     if (autoUninitSpan.uninitDone())
+     *         retrun;
+     *     ...
+     * }
+     * </code>
+     *
+     * @note The constructor of this class blocks the current thread execution
+     *       until the number of callers added to the object using #addCaller()
+     *       or AutoCaller drops to zero. For this reason, it is forbidden to
+     *       create instances of this class (or call uninit()) within the
+     *       AutoCaller or #addCaller() scope because it is a guaranteed
+     *       deadlock.
+     *
+     * @note Never create instances of this class outside uninit() methods and
+     *       never pass anything other than |this| as the argument to the
+     *       constructor!
      */
     class AutoUninitSpan
@@ -846 +951 @@
     public:
 
-        AutoUninitSpan (VirtualBoxBaseNEXT_base *aObj);
+        AutoUninitSpan (VirtualBoxBaseProto *aObj);
         ~AutoUninitSpan();
 
@@ -860 +965 @@
         DECLARE_CLS_NEW_DELETE_NOOP (AutoUninitSpan)
 
-        VirtualBoxBaseNEXT_base *mObj;
+        VirtualBoxBaseProto *mObj;
         bool mInitFailed : 1;
         bool mUninitDone : 1;
+    };
+
+    /**
+     * Smart class to enclose the state transition Ready->MayUninit->NotReady or
+     * Ready->MayUninit->WillUninit.
+     *
+     * The purpose of this span is to safely check if unintialization is
+     * possible at the given moment and seamlessly perform it if so.
+     *
+     * Instances must be created as a stack-based variable taking |this| pointer
+     * as the argument at the beginning of methods of VirtualBoxBase
+     * subclasses that want to uninitialize the object if a necessary set of
+     * criteria is met and leave it Ready otherwise.
+     *
+     * When this variable is created it automatically places the object to the
+     * MayUninit state if it is Ready, does nothing but returns |true| in
+     * response to #alreadyInProgress() if it is already in MayUninit, or
+     * returns a failure in response to #rc() in any other case. The example
+     * below shows how the user must react in latter two cases.
+     *
+     * When this variable goes out of scope (i.e. gets destroyed), it places the
+     * object back to Ready state unless #acceptUninit() is called in which case
+     * the object is placed to WillUninit state and uninit() is immediately
+     * called after that.
+     *
+     * A typical usage pattern is:
+     * <code>
+     * void Component::uninit()
+     * {
+     *     AutoMayUninitSpan mayUninitSpan (this);
+     *     CheckComRCReturnRC (mayUninitSpan.rc());
+     *     if (mayUninitSpan.alreadyInProgress())
+     *          return S_OK;
+     *     ...
+     *     if (FAILED (rc))
+     *         return rc; // will go back to Ready
+     *     ...
+     *     if (SUCCEEDED (rc))
+     *         mayUninitSpan.acceptUninit(); // will call uninit()
+     *     return rc;
+     * }
+     * </code>
+     *
+     * @note The constructor of this class blocks the current thread execution
+     *       until the number of callers added to the object using #addCaller()
+     *       or AutoCaller drops to zero. For this reason, it is forbidden to
+     *       create instances of this class (or call uninit()) within the
+     *       AutoCaller or #addCaller() scope because it is a guaranteed
+     *       deadlock.
+     */
+    class AutoMayUninitSpan
+    {
+    public:
+
+        AutoMayUninitSpan (VirtualBoxBaseProto *aObj);
+        ~AutoMayUninitSpan();
+
+        /**
+         * Returns a failure if the AutoMayUninitSpan variable was constructed
+         * at an improper time. If there is a failure, do nothing but return
+         * it to the caller.
+         */
+        HRESULT rc() { return mRC; }
+
+        /**
+         * Returns |true| if AutoMayUninitSpan is already in progress on some
+         * other thread. If it's the case, do nothing but return S_OK to
+         * the caller.
+         */
+        bool alreadyInProgress() { return mAlreadyInProgress; }
+
+        /*
+         * Accepts uninitialization and causes the destructor to go to
+         * WillUninit state and call uninit() afterwards.
+         */
+        void acceptUninit() { mAcceptUninit = true; }
+
+    private:
+
+        DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoMayUninitSpan)
+        DECLARE_CLS_NEW_DELETE_NOOP (AutoMayUninitSpan)
+
+        VirtualBoxBaseProto *mObj;
+
+        HRESULT mRC;
+        bool mAlreadyInProgress : 1;
+        bool mAcceptUninit : 1;
     };
 
@@ -888 +1080 @@
     /** Total number of active calls to this object */
     unsigned mCallers;
-    /** Semaphore posted when the number of callers drops to zero */
+    /** Posted when the number of callers drops to zero */
     RTSEMEVENT mZeroCallersSem;
-    /** Semaphore posted when the object goes from InInit some other state */
-    RTSEMEVENTMULTI mInitDoneSem;
-    /** Number of threads waiting for mInitDoneSem */
-    unsigned mInitDoneSemUsers;
+    /** Posted when the object goes from InInit/InUninit to some other state */
+    RTSEMEVENTMULTI mInitUninitSem;
+    /** Number of threads waiting for mInitUninitDoneSem */
+    unsigned mInitUninitWaiters;
 
     /** Protects access to state related data members */
@@ -901 +1093 @@
     mutable RWLockHandle *mObjectLock;
 };
+
+////////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -918 +1112 @@
  */
 #define VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(C) \
-    virtual HRESULT addCaller (VirtualBoxBaseNEXT_base::State *aState = NULL, \
+    virtual HRESULT addCaller (VirtualBoxBaseProto::State *aState = NULL, \
                                bool aLimited = false) \
     { \
-        VirtualBoxBaseNEXT_base::State state; \
-        HRESULT rc = VirtualBoxBaseNEXT_base::addCaller (&state, aLimited); \
+        VirtualBoxBaseProto::State state; \
+        HRESULT rc = VirtualBoxBaseProto::addCaller (&state, aLimited); \
         if (FAILED (rc)) \
         { \
-            if (state == VirtualBoxBaseNEXT_base::Limited) \
+            if (state == VirtualBoxBaseProto::Limited) \
                 rc = setError (rc, tr ("The object functonality is limited")); \
             else \
@@ -938 +1132 @@
 
 /// @todo (dmik) remove after we switch to VirtualBoxBaseNEXT completely
-class ATL_NO_VTABLE VirtualBoxBase : public VirtualBoxBaseNEXT_base
-//#if !defined (VBOX_WITH_XPCOM)
-//    : public CComObjectRootEx<CComMultiThreadModel>
-//#else
-//    : public CComObjectRootEx
-//#endif
+class ATL_NO_VTABLE VirtualBoxBase
+    : virtual public VirtualBoxBaseProto
+#if !defined (VBOX_WITH_XPCOM)
+    , public CComObjectRootEx <CComMultiThreadModel>
+#else
+    , public CComObjectRootEx
+#endif
 {
 
@@ -990 +1185 @@
  *  Temporary class to disable deprecated methods of VirtualBoxBase.
  *  Can be used as a base for components that are completely switched to
- *  the new locking scheme (VirtualBoxBaseNEXT_base).
+ *  the new locking scheme (VirtualBoxBaseProto).
  *
  *  @todo remove after we switch to VirtualBoxBaseNEXT completely.
@@ -1006 +1201 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-/** Helper for VirtualBoxSupportTranslation */
+/** Helper for VirtualBoxSupportTranslation. */
 class VirtualBoxSupportTranslationBase
 {
 protected:
-    static bool cutClassNameFrom__PRETTY_FUNCTION__ (char *prettyFunctionName);
+    static bool cutClassNameFrom__PRETTY_FUNCTION__ (char *aPrettyFunctionName);
 };
 
 /**
- *  This template implements the NLS string translation support for the
- *  given class by providing a #tr() function.
- *
- *  @param C    class that needs to support the string translation
- *
- *  @note
- *      Every class that wants to use the #tr() function in its own methods must
- *      inherit from this template, regardless of whether its base class (if any)
- *      inherits from it or not! Otherwise, the translation service will not
- *      work correctly. However, the declaration of the resulting class must
- *      contain the VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(<ClassName>) macro
- *      if one of its base classes also inherits from this template (to resolve
- *      the ambiguity of the #tr() function).
+ * The VirtualBoxSupportTranslation template implements the NLS string
+ * translation support for the given class.
+ *
+ * Translation support is provided by the static #tr() function. This function,
+ * given a string in UTF-8 encoding, looks up for a translation of the given
+ * string by calling the VirtualBoxBase::translate() global function which
+ * receives the name of the enclosing class ("context of translation") as the
+ * additional argument and returns a translated string based on the currently
+ * active language.
+ *
+ * @param C     Class that needs to support the string translation.
+ *
+ * @note Every class that wants to use the #tr() function in its own methods
+ *       must inherit from this template, regardless of whether its base class
+ *       (if any) inherits from it or not. Otherwise, the translation service
+ *       will not work correctly. However, the declaration of the derived
+ *       class must contain
+ *       the <tt>COM_SUPPORTTRANSLATION_OVERRIDE (<ClassName>)</tt> macro if one
+ *       of its base classes also inherits from this template (to resolve the
+ *       ambiguity of the #tr() function).
  */
 template <class C>
@@ -1034 +1236 @@
 
     /**
-     *  Translates the given text string according to the currently installed
-     *  translation table and current context, which is determined by the
-     *  class name. See VirtualBoxBase::translate() for more info.
-     *
-     *  @param sourceText   the string to translate
-     *  @param comment      the comment to the string (NULL means no comment)
-     *
-     *  @return
-     *      the translated version of the source string in UTF-8 encoding,
-     *      or the source string itself if the translation is not found in
-     *      the current context.
-     */
-    inline static const char *tr (const char *sourceText, const char *comment = 0)
-    {
-        return VirtualBoxBase::translate (getClassName(), sourceText, comment);
+     * Translates the given text string by calling VirtualBoxBase::translate()
+     * and passing the name of the C class as the first argument ("context of
+     * translation") See VirtualBoxBase::translate() for more info.
+     *
+     * @param aSourceText   String to translate.
+     * @param aComment      Comment to the string to resolve possible
+     *                      ambiguities (NULL means no comment).
+     *
+     * @return Translated version of the source string in UTF-8 encoding, or
+     *      the source string itself if the translation is not found in the
+     *      specifiecd context.
+     */
+    inline static const char *tr (const char *aSourceText,
+                                  const char *aComment = NULL)
+    {
+        return VirtualBoxBase::translate (className(), aSourceText, aComment);
     }
 
 protected:
 
-    static const char *getClassName()
+    static const char *className()
     {
         static char fn [sizeof (__PRETTY_FUNCTION__) + 1];
-        if (!className)
+        if (!sClassName)
         {
             strcpy (fn, __PRETTY_FUNCTION__);
             cutClassNameFrom__PRETTY_FUNCTION__ (fn);
-            className = fn;
+            sClassName = fn;
         }
-        return className;
+        return sClassName;
     }
 
 private:
 
-    static const char *className;
+    static const char *sClassName;
 };
 
 template <class C>
-const char *VirtualBoxSupportTranslation <C>::className = NULL;
+const char *VirtualBoxSupportTranslation <C>::sClassName = NULL;
 
 /**
- *  This macro must be invoked inside the public section of the declaration of
- *  the class inherited from the VirtualBoxSupportTranslation template, in case
- *  when one of its other base classes also inherits from that template. This is
- *  necessary to resolve the ambiguity of the #tr() function.
- *
- *  @param C    class that inherits from the VirtualBoxSupportTranslation template
- *              more than once (through its other base clases)
+ * This macro must be invoked inside the public section of the declaration of
+ * the class inherited from the VirtualBoxSupportTranslation template in case
+ * if one of its other base classes also inherits from that template. This is
+ * necessary to resolve the ambiguity of the #tr() function.
+ *
+ * @param C     Class that inherits the VirtualBoxSupportTranslation template
+ *              more than once (through its other base clases).
  */
 #define VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(C) \
-    inline static const char *tr (const char *sourceText, const char *comment = 0) \
+    inline static const char *tr (const char *aSourceText, \
+                                  const char *aComment = NULL) \
     { \
-        return VirtualBoxSupportTranslation <C>::tr (sourceText, comment); \
+        return VirtualBoxSupportTranslation <C>::tr (aSourceText, aComment); \
     }
 
 /**
- *  A dummy macro that is used to shut down Qt's lupdate tool warnings
- *  in some situations. This macro needs to be present inside (better at the
- *  very beginning) of the declaration of the class that inherits from
- *  VirtualBoxSupportTranslation template, to make lupdate happy.
+ * Dummy macro that is used to shut down Qt's lupdate tool warnings in some
+ * situations. This macro needs to be present inside (better at the very
+ * beginning) of the declaration of the class that inherits from
+ * VirtualBoxSupportTranslation template, to make lupdate happy.
  */
 #define Q_OBJECT
@@ -1101 +1305 @@
  *  Helper for the VirtualBoxSupportErrorInfoImpl template.
  */
+/// @todo switch to com::SupportErrorInfo* and remove
 class VirtualBoxSupportErrorInfoImplBase
 {
@@ -1110 +1315 @@
 
     /**
-     * The MultiResult class is a com::LWResult enhancement that also acts as a
+     * The MultiResult class is a com::FWResult enhancement that also acts as a
      * switch to turn on multi-error mode for #setError() or #setWarning()
      * calls.
@@ -1141 +1346 @@
      * doesn't return control return to the caller immediately after the first
      * error or warning but continues its execution, the functionality provided
-     * by the base com::LWResult class becomes very useful because it allows to
+     * by the base com::FWResult class becomes very useful because it allows to
      * preseve the error or the warning result code even if it is later assigned
-     * a S_OK value multiple times. See com::LWResult for details.
+     * a S_OK value multiple times. See com::FWResult for details.
      *
      * Here is the typical usage pattern:
@@ -1181 +1386 @@
      *       You cannot create them using new(). Although it is possible to copy
      *       instances of MultiResult or return them by value, please never do
-     *       that as it is breaks the class semantics (and will assert);
-     */
-    class MultiResult : public com::LWResult
+     *       that as it is breaks the class semantics (and will assert).
+     */
+    class MultiResult : public com::FWResult
     {
     public:
 
         /**
-         * @see com::LWResult::LWResult().
+         * @copydoc com::FWResult::FWResult().
          */
-        MultiResult (HRESULT aRC = E_FAIL) : LWResult (aRC) { init(); }
-
-        MultiResult (const MultiResult &aThat) : LWResult (aThat)
+        MultiResult (HRESULT aRC = E_FAIL) : FWResult (aRC) { init(); }
+
+        MultiResult (const MultiResult &aThat) : FWResult (aThat)
         {
             /* We need this copy constructor only for GCC that wants to have
@@ -1206 +1411 @@
         MultiResult &operator= (HRESULT aRC)
         {
-            com::LWResult::operator= (aRC);
+            com::FWResult::operator= (aRC);
             return *this;
         }
@@ -1217 +1422 @@
              * temporary and call the other constructor directly istead. */
             AssertFailed();
-            com::LWResult::operator= (aThat);
+            com::FWResult::operator= (aThat);
             return *this;
         }
@@ -1291 +1496 @@
  *      by the shortest form of #setError, for convenience.
  */
+/// @todo switch to com::SupportErrorInfo* and remove
 template <class C, class I>
 class ATL_NO_VTABLE VirtualBoxSupportErrorInfoImpl
@@ -1713 +1919 @@
 
 /**
- *
  * Base class to track VirtualBoxBaseNEXT chlidren of the component.
  *
@@ -1804 +2009 @@
 
     /**
+     * Equivalent to template <class C> void addDependentChild (C *aChild)
+     * but takes a ComObjPtr <C> argument.
+     */
+    template <class C>
+    void addDependentChild (const ComObjPtr <C> &aChild)
+    {
+        AssertReturnVoid (!aChild.isNull());
+        doAddDependentChild (ComPtr <IUnknown> (static_cast <C *> (aChild)), aChild);
+    }
+
+    /**
      * Removes the given child from the map of dependent children.
      *
-     * Make sure this method is called after the child has successfully entered
-     * AutoUninitSpan and outside the child lock.
+     * Typically called from from the child's uninit() method, from within the
+     * AutoUninitSpan scope. Make sure te child is not locked for reading or
+     * writing in this case.
      *
      * If called not from within the AutoUninitSpan scope,
@@ -1820 +2037 @@
     {
         AssertReturnVoid (aChild);
-        Assert (!aChild->isWriteLockOnCurrentThread());
         doRemoveDependentChild (ComPtr <IUnknown> (aChild));
+    }
+
+    /**
+     * Equivalent to template <class C> void removeDependentChild (C *aChild)
+     * but takes a ComObjPtr <C> argument.
+     */
+    template <class C>
+    void removeDependentChild (const ComObjPtr <C> &aChild)
+    {
+        AssertReturnVoid (!aChild.isNull());
+        doRemoveDependentChild (ComPtr <IUnknown> (static_cast <C *> (aChild)));
     }
 
@@ -1927 +2154 @@
     /**
      *  Returns an internal lock handle to lock the list of children
-     *  returned by #dependentChildren() using AutoWriteLock:
+     *  returned by #dependentChildren() using AutoReadLock/AutoWriteLock:
      *  <code>
-     *      AutoWriteLock alock (dependentChildrenLock());
+     *      AutoReadLock alock (dependentChildrenLock());
      *  </code>
+     *
+     *  This is necessary for example to access the list of children returned by
+     *  #dependentChildren().
      */
     RWLockHandle *dependentChildrenLock() const { return &mMapLock; }
@@ -2010 +2240 @@
  * This class is similar to VirtualBoxBaseWithChildren, with the exception that
  * all children must be of the same type. For this reason, it's not necessary to
- * use a map to store children, so a list is used instead.
- *
- * As opposed to VirtualBoxBaseWithChildren, children added by
+ * use a map to store children -- a list is used instead.
+ *
+ * Also, as opposed to VirtualBoxBaseWithChildren, children added by
  * #addDependentChild() are <b>strongly</b> referenced, so that they cannot be
- * externally deleted until #removeDependentChild() is called. For this
- * reason, strict rules of calling #removeDependentChild() don't apply to
- * instances of this class -- it can be called anywhere in the child's uninit()
- * implementation.
+ * deleted until #removeDependentChild() is called on them.
+ *
+ * See individual method descriptions for more information.
  *
  * @param C Type of child objects (must inherit VirtualBoxBase AND implementsome
@@ -2034 +2263 @@
     typedef std::list <ComObjPtr <C> > DependentChildren;
 
-    VirtualBoxBaseWithTypedChildrenNEXT() : mInUninit (false) {}
+    VirtualBoxBaseWithTypedChildrenNEXT() {}
 
     virtual ~VirtualBoxBaseWithTypedChildrenNEXT() {}
@@ -2041 +2270 @@
      * Adds the given child to the list of dependent children.
      *
-     * VirtualBoxBase::AutoCaller must be used on @a aChild to make sure it is
-     * not uninitialized during this method's call.
-     *
-     *  @param aChild   Child object to add (must inherit VirtualBoxBase AND
-     *                  implement some interface).
+     * Usually gets called from the child's init() method.
+     *
+     * @note Locks this object for writing.
+     *
+     * @note @a aChild (unless it is in InInit state) must be protected by
+     *       VirtualBoxBase::AutoCaller to make sure it is not uninitialized on
+     *       another thread during this method's call.
+     *
+     * @note If this method is called from under the child's read or write lock,
+     *       make sure the {parent, child} locking order is preserved by locking
+     *       the callee (this object) for writing before the child's lock.
+     *
+     * @param aChild    Child object to add.
      */
     void addDependentChild (C *aChild)
@@ -2051 +2288 @@
         AssertReturnVoid (aChild);
 
-        AutoWriteLock alock (mMapLock);
-        if (mInUninit)
+        AutoCaller autoCaller (this);
+
+        /* sanity */
+        AssertReturnVoid (autoCaller.state() == InInit ||
+                          autoCaller.state() == Ready ||
+                          autoCaller.state() == Limited);
+
+        AutoWriteLock alock (this);
+        mDependentChildren.push_back (aChild);
+    }
+
+    /**
+     * Removes the given child from the list of dependent children.
+     *
+     * Usually gets called from the child's uninit() method.
+     *
+     * Note that once this method returns, the callee (this object) is not
+     * guaranteed to be valid any more, so the caller must not call its
+     * other methods.
+     *
+     * @note Locks this object for writing.
+     *
+     * @note @a aChild (unless it is in InUninit state) must be protected by
+     *       VirtualBoxBase::AutoCaller to make sure it is not uninitialized on
+     *       another thread during this method's call.
+     *
+     * @note If this method is called from under the child's read or write lock,
+     *       make sure the {parent, child} locking order is preserved by locking
+     *       the callee (this object) for writing before the child's lock.
+     *
+     * @param aChild    Child object to remove.
+     */
+    void removeDependentChild (C *aChild)
+    {
+        AssertReturnVoid (aChild);
+
+        AutoCaller autoCaller (this);
+
+        /* return shortly; uninitDependentChildren() will do the job */
+        if (autoCaller.state() == InUninit)
             return;
 
-        mDependentChildren.push_back (aChild);
-    }
-
-    /**
-     * Removes the given child from the list of dependent children.
-     *
-     * VirtualBoxBase::AutoCaller must be used on @a aChild to make sure it is
-     * not uninitialized during this method's call.
-     *
-     *  @param aChild   the child object to remove (must inherit VirtualBoxBase
-     *                  AND implement some interface).
-     */
-    void removeDependentChild (C *aChild)
-    {
-        AssertReturnVoid (aChild);
-
-        AutoWriteLock alock (mMapLock);
-        if (mInUninit)
-            return;
-
+        AutoWriteLock alock (this);
         mDependentChildren.remove (aChild);
     }
@@ -2081 +2337 @@
 
     /**
-     * Returns an internal lock handle used to lock the list of children
-     * returned by #dependentChildren(). This lock is to be used by
-     * AutoWriteLock as follows:
-     * <code>
-     *      AutoWriteLock alock (dependentChildrenLock());
-     * </code>
-     */
-    RWLockHandle *dependentChildrenLock() const { return &mMapLock; }
-
-    /**
      * Returns the read-only list of all dependent children.
      *
-     * @note Access the returned list (iterate, get size etc.) only after doing
-     *       AutoWriteLock alock (dependentChildrenLock())!
+     * @note Access the returned list (iterate, get size etc.) only after
+     *       locking this object for reading or for writing!
      */
     const DependentChildren &dependentChildren() const { return mDependentChildren; }
 
-    void uninitDependentChildren();
+    /**
+     * Uninitializes all dependent children registered on this object with
+     * #addDependentChild().
+     *
+     * Must be called from within the VirtualBoxBaseProto::AutoUninitSpan (i.e.
+     * typically from this object's uninit() method) to uninitialize children
+     * before this object goes out of service and becomes unusable.
+     *
+     * Note that this method will call uninit() methods of child objects. If
+     * these methods need to call the parent object during uninitialization,
+     * #uninitDependentChildren() must be called before the relevant part of the
+     * parent is uninitialized, usually at the begnning of the parent
+     * uninitialization sequence.
+     *
+     * @note May lock this object through the called children.
+     */
+    void uninitDependentChildren()
+    {
+        AutoCaller autoCaller (this);
+
+        /* We cannot hold the write lock (necessary here to protect
+         * mDependentChildren) when uninitializing children because we want to
+         * avoid a possible deadlock where we could get stuck in child->uninit()
+         * blocked by AutoUninitSpan waiting for the number of child's callers
+         * to drop to zero, while some caller is stuck in our
+         * removeDependentChild() method waiting for the write lock.
+         *
+         * The only safe place to not lock and keep accessing our data members
+         * is the InUninit state (no active call to our object may exist on
+         * another thread when we are in InUinint, provided that all such calls
+         * use the AutoCaller class of course). InUinint is also used as a flag
+         * by removeDependentChild() that prevents touching mDependentChildren
+         * from outside. Therefore, we assert.
+         */
+        AssertReturnVoid (autoCaller.state() == InUninit);
+
+        if (mDependentChildren.size())
+        {
+            for (typename DependentChildren::iterator it = mDependentChildren.begin();
+                 it != mDependentChildren.end(); ++ it)
+            {
+                C *child = (*it);
+                Assert (child);
+
+                /* Note that if child->uninit() happens to be called on another
+                 * thread right before us and is not yet finished; the second
+                 * uninit() call will wait until the first one has done so
+                 * (thanks to AutoUninitSpan). */
+                if (child)
+                    child->uninit();
+            }
+
+            /* release all strong references we hold */
+            mDependentChildren.clear();
+        }
+    }
 
     /**
@@ -2104 +2405 @@
      * #addDependentChild(), without uninitializing them.
      *
-     * @note This method must be called from under the main object's lock.
+     * @note @a |this| (unless it is in InUninit state) must be protected by
+     *       VirtualBoxBase::AutoCaller to make sure it is not uninitialized on
+     *       another thread during this method's call.
+     *
+     * @note Locks this object for writing.
      */
     void removeDependentChildren()
     {
-        /// @todo why?..
-        AssertReturnVoid (isWriteLockOnCurrentThread());
-
-        AutoWriteLock alock (mMapLock);
+        AutoWriteLock alock (this);
         mDependentChildren.clear();
     }
@@ -2118 +2420 @@
 
     DependentChildren mDependentChildren;
-
-    bool mInUninit;
-
-    /* Protects the two fields above */
-    mutable RWLockHandle mMapLock;
 };
 

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

@@ -44 +44 @@
 class Machine;
 class SessionMachine;
-class HardDisk;
-class HVirtualDiskImage;
-class DVDImage;
-class FloppyImage;
+class HardDisk2;
+class DVDImage2;
+class FloppyImage2;
 class MachineCollection;
-class HardDiskCollection;
-class DVDImageCollection;
-class FloppyImageCollection;
 class GuestOSType;
 class GuestOSTypeCollection;
@@ -128 +124 @@
     STDMETHOD(COMGETTER(Host)) (IHost **aHost);
     STDMETHOD(COMGETTER(SystemProperties)) (ISystemProperties **aSystemProperties);
-    STDMETHOD(COMGETTER(Machines)) (IMachineCollection **aMachines);
     STDMETHOD(COMGETTER(Machines2)) (ComSafeArrayOut (IMachine *, aMachines));
-    STDMETHOD(COMGETTER(HardDisks)) (IHardDiskCollection **aHardDisks);
-    STDMETHOD(COMGETTER(DVDImages)) (IDVDImageCollection **aDVDImages);
-    STDMETHOD(COMGETTER(FloppyImages)) (IFloppyImageCollection **aFloppyImages);
+    STDMETHOD(COMGETTER(HardDisks2)) (ComSafeArrayOut (IHardDisk2 *, aHardDisks));
+    STDMETHOD(COMGETTER(DVDImages)) (ComSafeArrayOut (IDVDImage2 *, aDVDImages));
+    STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages));
     STDMETHOD(COMGETTER(ProgressOperations)) (IProgressCollection **aOperations);
     STDMETHOD(COMGETTER(GuestOSTypes)) (IGuestOSTypeCollection **aGuestOSTypes);
@@ -150 +145 @@
     STDMETHOD(UnregisterMachine) (INPTR GUIDPARAM aId, IMachine **aMachine);
 
-    STDMETHOD(CreateHardDisk) (HardDiskStorageType_T aStorageType, IHardDisk **aHardDisk);
-    STDMETHOD(OpenHardDisk) (INPTR BSTR aLocation, IHardDisk **aHardDisk);
-    STDMETHOD(OpenVirtualDiskImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage);
-    STDMETHOD(RegisterHardDisk) (IHardDisk *aHardDisk);
-    STDMETHOD(GetHardDisk) (INPTR GUIDPARAM aId, IHardDisk **aHardDisk);
-    STDMETHOD(FindHardDisk) (INPTR BSTR aLocation, IHardDisk **aHardDisk);
-    STDMETHOD(FindVirtualDiskImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage);
-    STDMETHOD(UnregisterHardDisk) (INPTR GUIDPARAM aId, IHardDisk **aHardDisk);
-
-    STDMETHOD(OpenDVDImage) (INPTR BSTR aFilePath, INPTR GUIDPARAM aId,
-                             IDVDImage **aDVDImage);
-    STDMETHOD(RegisterDVDImage) (IDVDImage *aDVDImage);
-    STDMETHOD(GetDVDImage) (INPTR GUIDPARAM aId, IDVDImage **aDVDImage);
-    STDMETHOD(FindDVDImage) (INPTR BSTR aFilePath, IDVDImage **aDVDImage);
-    STDMETHOD(GetDVDImageUsage) (INPTR GUIDPARAM aId,
-                                 ResourceUsage_T aUsage,
-                                 BSTR *aMachineIDs);
-    STDMETHOD(UnregisterDVDImage) (INPTR GUIDPARAM aId, IDVDImage **aDVDImage);
-
-    STDMETHOD(OpenFloppyImage) (INPTR BSTR aFilePath, INPTR GUIDPARAM aId,
-                                IFloppyImage **aFloppyImage);
-    STDMETHOD(RegisterFloppyImage) (IFloppyImage *aFloppyImage);
-    STDMETHOD(GetFloppyImage) (INPTR GUIDPARAM id, IFloppyImage **aFloppyImage);
-    STDMETHOD(FindFloppyImage) (INPTR BSTR aFilePath, IFloppyImage **aFloppyImage);
-    STDMETHOD(GetFloppyImageUsage) (INPTR GUIDPARAM aId,
-                                    ResourceUsage_T aUsage,
-                                    BSTR *aMachineIDs);
-    STDMETHOD(UnregisterFloppyImage) (INPTR GUIDPARAM aId, IFloppyImage **aFloppyImage);
+    STDMETHOD(CreateHardDisk2) (INPTR BSTR aFormat, INPTR BSTR aLocation,
+                                IHardDisk2 **aHardDisk);
+    STDMETHOD(OpenHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
+    STDMETHOD(GetHardDisk2) (INPTR GUIDPARAM aId, IHardDisk2 **aHardDisk);
+    STDMETHOD(FindHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
+
+    STDMETHOD(OpenDVDImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
+                             IDVDImage2 **aDVDImage);
+    STDMETHOD(GetDVDImage) (INPTR GUIDPARAM aId, IDVDImage2 **aDVDImage);
+    STDMETHOD(FindDVDImage) (INPTR BSTR aLocation, IDVDImage2 **aDVDImage);
+
+    STDMETHOD(OpenFloppyImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
+                                IFloppyImage2 **aFloppyImage);
+    STDMETHOD(GetFloppyImage) (INPTR GUIDPARAM aId, IFloppyImage2 **aFloppyImage);
+    STDMETHOD(FindFloppyImage) (INPTR BSTR aLocation, IFloppyImage2 **aFloppyImage);
 
     STDMETHOD(GetGuestOSType) (INPTR BSTR aId, IGuestOSType **aType);
@@ -241 +223 @@
     }
 
-    /// @todo (dmik) remove and make findMachine() public instead
-    //  after switching to VirtualBoxBaseNEXT
-    HRESULT getMachine (const Guid &aId, ComObjPtr <Machine> &aMachine,
-                        bool aSetError = false)
-    {
-        return findMachine (aId, aSetError, &aMachine);
-    }
-
-    /// @todo (dmik) remove and make findHardDisk() public instead
-    //  after switching to VirtualBoxBaseNEXT
-    HRESULT getHardDisk (const Guid &aId, ComObjPtr <HardDisk> &aHardDisk)
-    {
-        return findHardDisk (&aId, NULL, true /* aDoSetError */, &aHardDisk);
-    }
-
-    bool getDVDImageUsage (const Guid &aId, ResourceUsage_T aUsage,
-                           Bstr *aMachineIDs = NULL);
-    bool getFloppyImageUsage (const Guid &aId, ResourceUsage_T aUsage,
-                              Bstr *aMachineIDs = NULL);
+    HRESULT findMachine (const Guid &aId, bool aSetError,
+                         ComObjPtr <Machine> *machine = NULL);
+
+    HRESULT findHardDisk2 (const Guid *aId, const BSTR aLocation,
+                           bool aSetError, ComObjPtr <HardDisk2> *aHardDisk = NULL);
+    HRESULT findDVDImage2 (const Guid *aId, const BSTR aLocation,
+                           bool aSetError, ComObjPtr <DVDImage2> *aImage = NULL);
+    HRESULT findFloppyImage2 (const Guid *aId, const BSTR aLocation,
+                              bool aSetError, ComObjPtr <FloppyImage2> *aImage = NULL);
 
     const ComObjPtr <Host> &host() { return mData.mHost; }
@@ -273 +245 @@
     const Utf8Str &homeDir() { return mData.mHomeDir; }
 
+    int calculateFullPath (const char *aPath, Utf8Str &aResult);
     void calculateRelativePath (const char *aPath, Utf8Str &aResult);
 
-    enum RHD_Flags { RHD_Internal, RHD_External, RHD_OnStartUp };
-    HRESULT registerHardDisk (HardDisk *aHardDisk, RHD_Flags aFlags);
-    HRESULT unregisterHardDisk (HardDisk *aHardDisk);
-    HRESULT unregisterDiffHardDisk (HardDisk *aHardDisk);
+    HRESULT registerHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
+    HRESULT unregisterHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
+
+    HRESULT registerDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
+    HRESULT unregisterDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
+
+    HRESULT registerFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
+    HRESULT unregisterFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
+
+    HRESULT cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo);
 
     HRESULT saveSettings();
@@ -284 +263 @@
 
     const Bstr &settingsFileName() { return mData.mCfgFile.mName; }
+
+    static HRESULT ensureFilePathExists (const char *aFileName);
 
     class SettingsTreeHelper : public settings::XmlTreeBackend::InputResolver
@@ -359 +340 @@
     static HRESULT handleUnexpectedExceptions (RT_SRC_POS_DECL);
 
+    /**
+     * Returns a lock handle used to protect changes to the hard disk hierarchy
+     * (e.g. changing HardDisk2::mParent fields and adding/removing children).
+     */
+    RWLockHandle *hardDiskTreeHandle() { return &mHardDiskTreeHandle; }
+
     /* for VirtualBoxSupportErrorInfoImpl */
     static const wchar_t *getComponentName() { return L"VirtualBox"; }
@@ -366 +353 @@
     typedef std::list <ComObjPtr <Machine> > MachineList;
     typedef std::list <ComObjPtr <GuestOSType> > GuestOSTypeList;
-    typedef std::list <ComPtr <IProgress> > ProgressList;
-
-    typedef std::list <ComObjPtr <HardDisk> > HardDiskList;
-    typedef std::list <ComObjPtr <DVDImage> > DVDImageList;
-    typedef std::list <ComObjPtr <FloppyImage> > FloppyImageList;
+
+    typedef std::map <Guid, ComPtr <IProgress> > ProgressMap;
+
+    typedef std::list <ComObjPtr <HardDisk2> > HardDisk2List;
+    typedef std::list <ComObjPtr <DVDImage2> > DVDImage2List;
+    typedef std::list <ComObjPtr <FloppyImage2> > FloppyImage2List;
     typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
 
-    typedef std::map <Guid, ComObjPtr <HardDisk> > HardDiskMap;
-
-    HRESULT findMachine (const Guid &aId, bool aSetError,
-                         ComObjPtr <Machine> *machine = NULL);
-
-    HRESULT findHardDisk (const Guid *aId, const BSTR aLocation,
-                          bool aSetError, ComObjPtr <HardDisk> *aHardDisk = NULL);
-
-    HRESULT findVirtualDiskImage (const Guid *aId, const BSTR aFilePathFull,
-                          bool aSetError, ComObjPtr <HVirtualDiskImage> *aImage = NULL);
-    HRESULT findDVDImage (const Guid *aId, const BSTR aFilePathFull,
-                          bool aSetError, ComObjPtr <DVDImage> *aImage = NULL);
-    HRESULT findFloppyImage (const Guid *aId, const BSTR aFilePathFull,
-                             bool aSetError, ComObjPtr <FloppyImage> *aImage = NULL);
-
-    HRESULT checkMediaForConflicts (HardDisk *aHardDisk,
-                                    const Guid *aId, const BSTR aFilePathFull);
+    typedef std::map <Guid, ComObjPtr <HardDisk2> > HardDisk2Map;
+
+    HRESULT checkMediaForConflicts2 (const Guid &aId, const Bstr &aLocation,
+                                     Utf8Str &aConflictType);
 
     HRESULT loadMachines (const settings::Key &aGlobal);
-    HRESULT loadDisks (const settings::Key &aGlobal);
-    HRESULT loadHardDisks (const settings::Key &aNode);
-
-    HRESULT saveHardDisks (settings::Key &aNode);
+    HRESULT loadMedia (const settings::Key &aGlobal);
 
     HRESULT registerMachine (Machine *aMachine);
-
-    HRESULT registerDVDImage (DVDImage *aImage, bool aOnStartUp);
-    HRESULT registerFloppyImage (FloppyImage *aImage, bool aOnStartUp);
 
     HRESULT lockConfig();
@@ -442 +411 @@
         GuestOSTypeList mGuestOSTypes;
 
-        ProgressList mProgressOperations;
-        HardDiskList mHardDisks;
-        DVDImageList mDVDImages;
-        FloppyImageList mFloppyImages;
+        ProgressMap mProgressOperations;
+
+        HardDisk2List mHardDisks2;
+        DVDImage2List mDVDImages2;
+        FloppyImage2List mFloppyImages2;
         SharedFolderList mSharedFolders;
 
-        HardDiskMap mHardDiskMap;
+        /// @todo NEWMEDIA do we really need this map? Used only in
+        /// find() it seems
+        HardDisk2Map mHardDisk2Map;
 
         CallbackList mCallbacks;
@@ -490 +462 @@
     const RTTHREAD mAsyncEventThread;
     EventQueue * const mAsyncEventQ;
-    /** Lock for calling EventQueue->post() */
-    RWLockHandle mAsyncEventQLock;
+
+    /**
+     * "Safe" lock. May only be used if guaranteed that no other locks are
+     * requested while holding it and no functions that may do so are called.
+     * Currently, protects the following:
+     *
+     * - mProgressOperations
+     */
+    RWLockHandle mSafeLock;
+
+    RWLockHandle mHardDiskTreeHandle;
 
     static Bstr sVersion;

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

@@ -29 +29 @@
 
 /** VirtualBox XML settings version number substring ("x.y")  */
-#define VBOX_XML_VERSION        "1.3"
+#define VBOX_XML_VERSION        "1.4"
 
 /** VirtualBox XML settings version platform substring */