Changeset 16867 in vbox for trunk

Timestamp:

Feb 17, 2009 5:00:56 PM (16 years ago)

Author:

vboxsync

Message:

Main: rename IHardDiskImage2 to IHardDiskImage; rename IFloppyImage2 to IFloppyImage; rename all media-related methods with a '2' suffix

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxInternalManage.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManage.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageDisk.cpp (modified) (12 diffs)
• Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (6 diffs)
• Frontends/VBoxManage/VBoxManageList.cpp (modified) (2 diffs)
• Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (13 diffs)
• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (3 diffs)
• Frontends/VirtualBox/include/VBoxGlobal.h (modified) (4 diffs)
• Frontends/VirtualBox/include/VBoxNewHDWzd.h (modified) (2 diffs)
• Frontends/VirtualBox/include/VBoxNewVMWzd.h (modified) (1 diff)
• Frontends/VirtualBox/include/VBoxProblemReporter.h (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxConsoleWnd.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxGlobal.cpp (modified) (9 diffs)
• Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp (modified) (7 diffs)
• Frontends/VirtualBox/src/VBoxNewHDWzd.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxNewVMWzd.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxProblemReporter.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxSelectorWnd.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxVMFirstRunWzd.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxVMInformationDlg.cpp (modified) (5 diffs)
• Frontends/VirtualBox/src/VBoxVMSettingsFD.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxVMSettingsHD.cpp (modified) (5 diffs)
• Main/ApplianceImpl.cpp (modified) (11 diffs)
• Main/ConsoleImpl.cpp (modified) (8 diffs)
• Main/ConsoleImpl2.cpp (modified) (3 diffs)
• Main/FloppyDriveImpl.cpp (modified) (2 diffs)
• Main/HardDisk2Impl.cpp (modified) (113 diffs)
• Main/HardDiskAttachmentImpl.cpp (modified) (7 diffs)
• Main/MachineImpl.cpp (modified) (55 diffs)
• Main/MediumImpl.cpp (modified) (2 diffs)
• Main/VirtualBoxImpl.cpp (modified) (55 diffs)
• Main/idl/VirtualBox.xidl (modified) (63 diffs)
• Main/include/FloppyDriveImpl.h (modified) (2 diffs)
• Main/include/HardDiskAttachmentImpl.h (modified) (9 diffs)
• Main/include/HardDiskFormatImpl.h (modified) (1 diff)
• Main/include/HardDiskImpl.h (moved) (moved from trunk/src/VBox/Main/include/HardDisk2Impl.h ) (12 diffs)
• Main/include/MachineImpl.h (modified) (4 diffs)
• Main/include/MediumImpl.h (modified) (3 diffs)
• Main/include/VirtualBoxImpl.h (modified) (9 diffs)
• Main/testcase/tstAPI.cpp (modified) (3 diffs)
• Main/testcase/tstVBoxAPILinux.cpp (modified) (2 diffs)
• Main/xpcom/server.cpp (modified) (2 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

@@ -1248 +1248 @@
     if (fRegister)
     {
-        ComPtr<IHardDisk2> hardDisk;
-        CHECK_ERROR(aVirtualBox, OpenHardDisk2(filename, hardDisk.asOutParam()));
+        ComPtr<IHardDisk> hardDisk;
+        CHECK_ERROR(aVirtualBox, OpenHardDisk(filename, hardDisk.asOutParam()));
     }
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

@@ -1414 +1414 @@
                 /* first assume it's a UUID */
                 Guid uuid(a->argv[2]);
-                ComPtr<IFloppyImage2> floppyImage;
+                ComPtr<IFloppyImage> floppyImage;
                 rc = a->virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
                 if (FAILED(rc) || !floppyImage)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

@@ -122 +122 @@
         return errorArgument("Invalid hard disk type '%s' specified", Utf8Str(type).raw());
 
-    ComPtr<IHardDisk2> hardDisk;
-    CHECK_ERROR(a->virtualBox, CreateHardDisk2(format, filename, hardDisk.asOutParam()));
+    ComPtr<IHardDisk> hardDisk;
+    CHECK_ERROR(a->virtualBox, CreateHardDisk(format, filename, hardDisk.asOutParam()));
     if (SUCCEEDED(rc) && hardDisk)
     {
@@ -215 +215 @@
         return errorSyntax(USAGE_MODIFYHD, "Incorrect number of parameters");
 
-    ComPtr<IHardDisk2> hardDisk;
+    ComPtr<IHardDisk> hardDisk;
     Bstr filepath;
 
     /* first guess is that it's a UUID */
     Guid uuid(a->argv[0]);
-    rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+    rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
     /* no? then it must be a filename */
     if (!hardDisk)
     {
         filepath = a->argv[0];
-        CHECK_ERROR(a->virtualBox, FindHardDisk2(filepath, hardDisk.asOutParam()));
+        CHECK_ERROR(a->virtualBox, FindHardDisk(filepath, hardDisk.asOutParam()));
     }
 
@@ -277 +277 @@
         if (!hardDisk)
         {
-            a->virtualBox->OpenHardDisk2(Bstr(a->argv[0]), hardDisk.asOutParam());
+            a->virtualBox->OpenHardDisk(Bstr(a->argv[0]), hardDisk.asOutParam());
             if (!hardDisk)
                 return errorArgument("Hard disk image not found");
@@ -354 +354 @@
         return errorSyntax(USAGE_CLONEHD, "Mandatory output file parameter missing");
 
-    ComPtr<IHardDisk2> srcDisk;
-    ComPtr<IHardDisk2> dstDisk;
+    ComPtr<IHardDisk> srcDisk;
+    ComPtr<IHardDisk> dstDisk;
     bool unknown = false;
 
     /* first guess is that it's a UUID */
     Guid uuid(Utf8Str(src).raw());
-    rc = a->virtualBox->GetHardDisk2(uuid, srcDisk.asOutParam());
+    rc = a->virtualBox->GetHardDisk(uuid, srcDisk.asOutParam());
     /* no? then it must be a filename */
     if (FAILED (rc))
     {
-        rc = a->virtualBox->FindHardDisk2(src, srcDisk.asOutParam());
+        rc = a->virtualBox->FindHardDisk(src, srcDisk.asOutParam());
         /* no? well, then it's an unkwnown image */
         if (FAILED (rc))
         {
-            CHECK_ERROR(a->virtualBox, OpenHardDisk2(src, srcDisk.asOutParam()));
+            CHECK_ERROR(a->virtualBox, OpenHardDisk(src, srcDisk.asOutParam()));
             if (SUCCEEDED (rc))
             {
@@ -387 +387 @@
         }
 
-        CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk2(format, dst, dstDisk.asOutParam()));
+        CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(format, dst, dstDisk.asOutParam()));
 
         ComPtr<IProgress> progress;
@@ -679 +679 @@
     do
     {
-        ComPtr<IHardDisk2> hardDisk;
+        ComPtr<IHardDisk> hardDisk;
         CHECK_ERROR_BREAK (a->virtualBox,
-            CreateHardDisk2(Bstr ("iSCSI"),
-                            BstrFmt ("%ls/%ls", server.raw(), target.raw()),
-                            hardDisk.asOutParam()));
+            CreateHardDisk(Bstr ("iSCSI"),
+                           BstrFmt ("%ls/%ls", server.raw(), target.raw()),
+                           hardDisk.asOutParam()));
         CheckComRCBreakRC (rc);
 
@@ -749 +749 @@
         return errorSyntax(USAGE_SHOWHDINFO, "Incorrect number of parameters");
 
-    ComPtr<IHardDisk2> hardDisk;
+    ComPtr<IHardDisk> hardDisk;
     Bstr filepath;
 
@@ -756 +756 @@
     /* first guess is that it's a UUID */
     Guid uuid(a->argv[0]);
-    rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+    rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
     /* no? then it must be a filename */
     if (FAILED (rc))
     {
         filepath = a->argv[0];
-        rc = a->virtualBox->FindHardDisk2(filepath, hardDisk.asOutParam());
+        rc = a->virtualBox->FindHardDisk(filepath, hardDisk.asOutParam());
         /* no? well, then it's an unkwnown image */
         if (FAILED (rc))
         {
-            CHECK_ERROR(a->virtualBox, OpenHardDisk2(filepath, hardDisk.asOutParam()));
+            CHECK_ERROR(a->virtualBox, OpenHardDisk(filepath, hardDisk.asOutParam()));
             if (SUCCEEDED (rc))
             {
@@ -891 +891 @@
         }
 
-        ComPtr<IHardDisk2> hardDisk;
-        CHECK_ERROR(a->virtualBox, OpenHardDisk2(filepath, hardDisk.asOutParam()));
+        ComPtr<IHardDisk> hardDisk;
+        CHECK_ERROR(a->virtualBox, OpenHardDisk(filepath, hardDisk.asOutParam()));
         if (SUCCEEDED(rc) && hardDisk)
         {
@@ -914 +914 @@
     else if (strcmp(a->argv[0], "floppy") == 0)
     {
-        ComPtr<IFloppyImage2> floppyImage;
+        ComPtr<IFloppyImage> floppyImage;
         CHECK_ERROR(a->virtualBox, OpenFloppyImage(filepath, Guid(), floppyImage.asOutParam()));
     }
@@ -935 +935 @@
     if (strcmp(a->argv[0], "disk") == 0)
     {
-        ComPtr<IHardDisk2> hardDisk;
-        rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+        ComPtr<IHardDisk> hardDisk;
+        rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
         /* not a UUID or not registered? Then it must be a filename */
         if (!hardDisk)
         {
-            CHECK_ERROR(a->virtualBox, FindHardDisk2(Bstr(a->argv[1]), hardDisk.asOutParam()));
+            CHECK_ERROR(a->virtualBox, FindHardDisk(Bstr(a->argv[1]), hardDisk.asOutParam()));
         }
         if (SUCCEEDED(rc) && hardDisk)
@@ -965 +965 @@
     if (strcmp(a->argv[0], "floppy") == 0)
     {
-        ComPtr<IFloppyImage2> floppyImage;
+        ComPtr<IFloppyImage> floppyImage;
         rc = a->virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
         /* not a UUID or not registered? Then it must be a filename */

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -384 +384 @@
                 case DriveState_ImageMounted:
                 {
-                    ComPtr<IFloppyImage2> floppyImage;
+                    ComPtr<IFloppyImage> floppyImage;
                     rc = floppyDrive->GetImage(floppyImage.asOutParam());
                     if (SUCCEEDED(rc) && floppyImage)
@@ -461 +461 @@
     if (fSataEnabled)
     {
-        ComPtr<IHardDisk2> hardDisk;
+        ComPtr<IHardDisk> hardDisk;
         Bstr  filePath;
         ULONG cSataPorts;
@@ -468 +468 @@
         for (ULONG i = 0; i < cSataPorts; ++ i)
         {
-            rc = machine->GetHardDisk2(StorageBus_SATA, i, 0, hardDisk.asOutParam());
+            rc = machine->GetHardDisk(StorageBus_SATA, i, 0, hardDisk.asOutParam());
             if (SUCCEEDED(rc) && hardDisk)
             {
@@ -512 +512 @@
         RTPrintf("IDE Controller:  %s\n", pszIdeController);
 
-    ComPtr<IHardDisk2> hardDisk;
+    ComPtr<IHardDisk> hardDisk;
     Bstr filePath;
-    rc = machine->GetHardDisk2(StorageBus_IDE, 0, 0, hardDisk.asOutParam());
+    rc = machine->GetHardDisk(StorageBus_IDE, 0, 0, hardDisk.asOutParam());
     if (SUCCEEDED(rc) && hardDisk)
     {
@@ -532 +532 @@
             RTPrintf("hda=\"none\"\n");
     }
-    rc = machine->GetHardDisk2(StorageBus_IDE, 0, 1, hardDisk.asOutParam());
+    rc = machine->GetHardDisk(StorageBus_IDE, 0, 1, hardDisk.asOutParam());
     if (SUCCEEDED(rc) && hardDisk)
     {
@@ -550 +550 @@
             RTPrintf("hdb=\"none\"\n");
     }
-    rc = machine->GetHardDisk2(StorageBus_IDE, 1, 1, hardDisk.asOutParam());
+    rc = machine->GetHardDisk(StorageBus_IDE, 1, 1, hardDisk.asOutParam());
     if (SUCCEEDED(rc) && hardDisk)
     {

trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

@@ -389 +389 @@
     if (strcmp(a->argv[0], "hdds") == 0)
     {
-        com::SafeIfaceArray <IHardDisk2> hdds;
-        CHECK_ERROR(a->virtualBox, COMGETTER(HardDisks2)(ComSafeArrayAsOutParam (hdds)));
+        com::SafeIfaceArray<IHardDisk> hdds;
+        CHECK_ERROR(a->virtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam (hdds)));
         for (size_t i = 0; i < hdds.size(); ++ i)
         {
-            ComPtr<IHardDisk2> hdd = hdds[i];
+            ComPtr<IHardDisk> hdd = hdds[i];
             Guid uuid;
             hdd->COMGETTER(Id)(uuid.asOutParam());
@@ -452 +452 @@
     if (strcmp(a->argv[0], "floppies") == 0)
     {
-        com::SafeIfaceArray<IFloppyImage2> floppies;
+        com::SafeIfaceArray<IFloppyImage> floppies;
         CHECK_ERROR(a->virtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
         for (size_t i = 0; i < floppies.size(); ++ i)
         {
-            ComPtr<IFloppyImage2> floppyImage = floppies[i];
+            ComPtr<IFloppyImage> floppyImage = floppies[i];
             Guid uuid;
             floppyImage->COMGETTER(Id)(uuid.asOutParam());

trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

@@ -980 +980 @@
             if (strcmp(hdds[0], "none") == 0)
             {
-                machine->DetachHardDisk2(StorageBus_IDE, 0, 0);
+                machine->DetachHardDisk(StorageBus_IDE, 0, 0);
             }
             else
@@ -986 +986 @@
                 /* first guess is that it's a UUID */
                 Guid uuid(hdds[0]);
-                ComPtr<IHardDisk2> hardDisk;
-                rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+                ComPtr<IHardDisk> hardDisk;
+                rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
                 /* not successful? Then it must be a filename */
                 if (!hardDisk)
                 {
-                    CHECK_ERROR(a->virtualBox, FindHardDisk2(Bstr(hdds[0]), hardDisk.asOutParam()));
+                    CHECK_ERROR(a->virtualBox, FindHardDisk(Bstr(hdds[0]), hardDisk.asOutParam()));
                     if (FAILED(rc))
                     {
                         /* open the new hard disk object */
-                        CHECK_ERROR(a->virtualBox, OpenHardDisk2(Bstr(hdds[0]), hardDisk.asOutParam()));
+                        CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(hdds[0]), hardDisk.asOutParam()));
                     }
                 }
@@ -1001 +1001 @@
                 {
                     hardDisk->COMGETTER(Id)(uuid.asOutParam());
-                    CHECK_ERROR(machine, AttachHardDisk2(uuid, StorageBus_IDE, 0, 0));
+                    CHECK_ERROR(machine, AttachHardDisk(uuid, StorageBus_IDE, 0, 0));
                 }
                 else
@@ -1013 +1013 @@
             if (strcmp(hdds[1], "none") == 0)
             {
-                machine->DetachHardDisk2(StorageBus_IDE, 0, 1);
+                machine->DetachHardDisk(StorageBus_IDE, 0, 1);
             }
             else
@@ -1019 +1019 @@
                 /* first guess is that it's a UUID */
                 Guid uuid(hdds[1]);
-                ComPtr<IHardDisk2> hardDisk;
-                rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+                ComPtr<IHardDisk> hardDisk;
+                rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
                 /* not successful? Then it must be a filename */
                 if (!hardDisk)
                 {
-                    CHECK_ERROR(a->virtualBox, FindHardDisk2(Bstr(hdds[1]), hardDisk.asOutParam()));
+                    CHECK_ERROR(a->virtualBox, FindHardDisk(Bstr(hdds[1]), hardDisk.asOutParam()));
                     if (FAILED(rc))
                     {
                         /* open the new hard disk object */
-                        CHECK_ERROR(a->virtualBox, OpenHardDisk2(Bstr(hdds[1]), hardDisk.asOutParam()));
+                        CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(hdds[1]), hardDisk.asOutParam()));
                     }
                 }
@@ -1034 +1034 @@
                 {
                     hardDisk->COMGETTER(Id)(uuid.asOutParam());
-                    CHECK_ERROR(machine, AttachHardDisk2(uuid, StorageBus_IDE, 0, 1));
+                    CHECK_ERROR(machine, AttachHardDisk(uuid, StorageBus_IDE, 0, 1));
                 }
                 else
@@ -1046 +1046 @@
             if (strcmp(hdds[2], "none") == 0)
             {
-                machine->DetachHardDisk2(StorageBus_IDE, 1, 1);
+                machine->DetachHardDisk(StorageBus_IDE, 1, 1);
             }
             else
@@ -1052 +1052 @@
                 /* first guess is that it's a UUID */
                 Guid uuid(hdds[2]);
-                ComPtr<IHardDisk2> hardDisk;
-                rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+                ComPtr<IHardDisk> hardDisk;
+                rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
                 /* not successful? Then it must be a filename */
                 if (!hardDisk)
                 {
-                    CHECK_ERROR(a->virtualBox, FindHardDisk2(Bstr(hdds[2]), hardDisk.asOutParam()));
+                    CHECK_ERROR(a->virtualBox, FindHardDisk(Bstr(hdds[2]), hardDisk.asOutParam()));
                     if (FAILED(rc))
                     {
                         /* open the new hard disk object */
-                        CHECK_ERROR(a->virtualBox, OpenHardDisk2(Bstr(hdds[2]), hardDisk.asOutParam()));
+                        CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(hdds[2]), hardDisk.asOutParam()));
                     }
                 }
@@ -1067 +1067 @@
                 {
                     hardDisk->COMGETTER(Id)(uuid.asOutParam());
-                    CHECK_ERROR(machine, AttachHardDisk2(uuid, StorageBus_IDE, 1, 1));
+                    CHECK_ERROR(machine, AttachHardDisk(uuid, StorageBus_IDE, 1, 1));
                 }
                 else
@@ -1210 +1210 @@
                     /* first assume it's a UUID */
                     Guid uuid(floppy);
-                    ComPtr<IFloppyImage2> floppyImage;
+                    ComPtr<IFloppyImage> floppyImage;
                     rc = a->virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
                     if (FAILED(rc) || !floppyImage)
@@ -1747 +1747 @@
                 if (strcmp(hdds[i], "none") == 0)
                 {
-                    machine->DetachHardDisk2(StorageBus_SATA, i-4, 0);
+                    machine->DetachHardDisk(StorageBus_SATA, i-4, 0);
                 }
                 else
@@ -1753 +1753 @@
                     /* first guess is that it's a UUID */
                     Guid uuid(hdds[i]);
-                    ComPtr<IHardDisk2> hardDisk;
-                    rc = a->virtualBox->GetHardDisk2(uuid, hardDisk.asOutParam());
+                    ComPtr<IHardDisk> hardDisk;
+                    rc = a->virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
                     /* not successful? Then it must be a filename */
                     if (!hardDisk)
                     {
-                        CHECK_ERROR(a->virtualBox, FindHardDisk2(Bstr(hdds[i]), hardDisk.asOutParam()));
+                        CHECK_ERROR(a->virtualBox, FindHardDisk(Bstr(hdds[i]), hardDisk.asOutParam()));
                         if (FAILED(rc))
                         {
                             /* open the new hard disk object */
-                            CHECK_ERROR(a->virtualBox, OpenHardDisk2(Bstr(hdds[i]), hardDisk.asOutParam()));
+                            CHECK_ERROR(a->virtualBox, OpenHardDisk(Bstr(hdds[i]), hardDisk.asOutParam()));
                         }
                     }
@@ -1768 +1768 @@
                     {
                         hardDisk->COMGETTER(Id)(uuid.asOutParam());
-                        CHECK_ERROR(machine, AttachHardDisk2(uuid, StorageBus_SATA, i-4, 0));
+                        CHECK_ERROR(machine, AttachHardDisk(uuid, StorageBus_SATA, i-4, 0));
                     }
                     else

trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

@@ -1659 +1659 @@
          */
         Bstr hdaFileBstr = hdaFile;
-        ComPtr<IHardDisk2> hardDisk;
-        virtualBox->FindHardDisk2(hdaFileBstr, hardDisk.asOutParam());
+        ComPtr<IHardDisk> hardDisk;
+        virtualBox->FindHardDisk(hdaFileBstr, hardDisk.asOutParam());
         if (!hardDisk)
         {
             /* we've not found the image */
             RTPrintf("Adding hard disk '%S'...\n", hdaFile);
-            virtualBox->OpenHardDisk2 (hdaFileBstr, hardDisk.asOutParam());
+            virtualBox->OpenHardDisk(hdaFileBstr, hardDisk.asOutParam());
         }
         /* do we have the right image now? */
@@ -1675 +1675 @@
             Guid uuid;
             hardDisk->COMGETTER(Id)(uuid.asOutParam());
-            gMachine->DetachHardDisk2(StorageBus_IDE, 0, 0);
-            gMachine->AttachHardDisk2(uuid, StorageBus_IDE, 0, 0);
+            gMachine->DetachHardDisk(StorageBus_IDE, 0, 0);
+            gMachine->AttachHardDisk(uuid, StorageBus_IDE, 0, 0);
             /// @todo why is this attachment saved?
         }
@@ -1726 +1726 @@
         {
             /* try to find an existing one */
-            ComPtr <IFloppyImage2> image;
+            ComPtr<IFloppyImage> image;
             rc = virtualBox->FindFloppyImage (medium, image.asOutParam());
             if (FAILED (rc))

trunk/src/VBox/Frontends/VirtualBox/include/VBoxGlobal.h

@@ -146 +146 @@
     }
 
-    const CHardDisk2 &hardDisk() const { return mHardDisk; }
+    const CHardDisk &hardDisk() const { return mHardDisk; }
     const CDVDImage &dvdImage() const { return mDVDImage; }
-    const CFloppyImage2 &floppyImage() const { return mFloppyImage; }
+    const CFloppyImage &floppyImage() const { return mFloppyImage; }
 
     QUuid id() const { return mId; }
@@ -246 +246 @@
     COMResult mResult;
 
-    CHardDisk2 mHardDisk;
+    CHardDisk mHardDisk;
     CDVDImage mDVDImage;
-    CFloppyImage2 mFloppyImage;
+    CFloppyImage mFloppyImage;
 
     QUuid mId;
@@ -613 +613 @@
      * normal hard disks that have a parent.
      */
-    QString hardDiskTypeString (const CHardDisk2 &aHD) const
+    QString hardDiskTypeString (const CHardDisk &aHD) const
     {
         if (!aHD.GetParent().isNull())
@@ -799 +799 @@
     /* details generators */
 
-    QString details (const CHardDisk2 &aHD, bool aPredictDiff);
+    QString details (const CHardDisk &aHD, bool aPredictDiff);
 
     QString details (const CUSBDevice &aDevice) const;

trunk/src/VBox/Frontends/VirtualBox/include/VBoxNewHDWzd.h

@@ -39 +39 @@
     VBoxNewHDWzd (QWidget *aParent = 0);
 
-    CHardDisk2 hardDisk() { return mHD; }
+    CHardDisk hardDisk() { return mHD; }
     void setRecommendedFileName (const QString &aName);
     void setRecommendedSize (quint64 aSize);
@@ -66 +66 @@
 
     QIWidgetValidator *mWValNameAndSize;
-    CHardDisk2         mHD;
+    CHardDisk          mHD;
     int                mSliderScale;
     quint64            mMaxVDISize;

trunk/src/VBox/Frontends/VirtualBox/include/VBoxNewVMWzd.h

@@ -67 +67 @@
     QIWidgetValidator *mWvalMemory;
     QIWidgetValidator *mWvalHDD;
-    CHardDisk2 mHardDisk;
+    CHardDisk mHardDisk;
     CMachine mMachine;
 };

trunk/src/VBox/Frontends/VirtualBox/include/VBoxProblemReporter.h

@@ -264 +264 @@
     int confirmDeleteHardDiskStorage (QWidget *aParent,
                                       const QString &aLocation);
-    void cannotDeleteHardDiskStorage (QWidget *aParent, const CHardDisk2 &aHD,
+    void cannotDeleteHardDiskStorage (QWidget *aParent, const CHardDisk &aHD,
                                       const CProgress &aProgress);
 
@@ -272 +272 @@
     void cannotCreateHardDiskStorage (QWidget *aParent, const CVirtualBox &aVBox,
                                       const QString &aLocaiton,
-                                      const CHardDisk2 &aHD,
+                                      const CHardDisk &aHD,
                                       const CProgress &aProgress);
     void cannotAttachHardDisk (QWidget *aParent, const CMachine &aMachine,

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleWnd.cpp

@@ -1917 +1917 @@
         QString data;
         bool hasDisks = false;
-        CHardDisk2AttachmentVector vec = cmachine.GetHardDisk2Attachments();
-        for (CHardDisk2AttachmentVector::ConstIterator hda = vec.begin();
+        CHardDiskAttachmentVector vec = cmachine.GetHardDiskAttachments();
+        for (CHardDiskAttachmentVector::ConstIterator hda = vec.begin();
              hda != vec.end(); ++ hda)
         {
-            CHardDisk2 hd = hda->GetHardDisk();
+            CHardDisk hd = hda->GetHardDisk();
             data += QString ("<br><nobr><b>%1 %2</b>: %3</nobr>")
                 .arg (vboxGlobal().toString (hda->GetBus(), hda->GetChannel()))

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobal.cpp

@@ -219 +219 @@
          * to an item from VBoxGlobal::currentMediaList()) */
 
-        CHardDisk2 parent = mHardDisk.GetParent();
+        CHardDisk parent = mHardDisk.GetParent();
         Assert (!parent.isNull() || mParent == NULL);
 
@@ -1938 +1938 @@
  *       @todo in VBoxMedium::details()).
  */
-QString VBoxGlobal::details (const CHardDisk2 &aHD,
+QString VBoxGlobal::details (const CHardDisk &aHD,
                              bool aPredictDiff)
 {
@@ -2161 +2161 @@
         int rows = 2; /* including section header and footer */
 
-        CHardDisk2AttachmentVector vec = aMachine.GetHardDisk2Attachments();
+        CHardDiskAttachmentVector vec = aMachine.GetHardDiskAttachments();
         for (size_t i = 0; i < (size_t) vec.size(); ++ i)
         {
-            CHardDisk2Attachment hda = vec [i];
-            CHardDisk2 hd = hda.GetHardDisk();
+            CHardDiskAttachment hda = vec [i];
+            CHardDisk hd = hda.GetHardDisk();
 
             /// @todo for the explaination of the below isOk() checks, see ***
@@ -2332 +2332 @@
             case KDriveState_ImageMounted:
             {
-                CFloppyImage2 img = floppy.GetImage();
+                CFloppyImage img = floppy.GetImage();
                 item = QString (sSectionItemTpl2)
                     .arg (tr ("Image", "details report (floppy)"),
@@ -2915 +2915 @@
  */
 static
-void AddHardDisksToList (const CHardDisk2Vector &aVector,
+void AddHardDisksToList (const CHardDiskVector &aVector,
                          VBoxMediaList &aList,
                          VBoxMediaList::iterator aWhere,
@@ -2923 +2923 @@
 
     /* First pass: Add siblings sorted */
-    for (CHardDisk2Vector::ConstIterator it = aVector.begin();
+    for (CHardDiskVector::ConstIterator it = aVector.begin();
          it != aVector.end(); ++ it)
     {
@@ -2945 +2945 @@
     for (VBoxMediaList::iterator it = first; it != aWhere;)
     {
-        CHardDisk2Vector children = (*it).hardDisk().GetChildren();
+        CHardDiskVector children = (*it).hardDisk().GetChildren();
         VBoxMedium *parent = &(*it);
 
@@ -2997 +2997 @@
     mMediaList.clear();
     {
-        AddHardDisksToList (mVBox.GetHardDisks2(), mMediaList, mMediaList.end());
+        AddHardDisksToList (mVBox.GetHardDisks(), mMediaList, mMediaList.end());
     }
     {
@@ -3025 +3025 @@
         VBoxMediaList::iterator first = mMediaList.end();
 
-        CFloppyImage2Vector vec = mVBox.GetFloppyImages();
-        for (CFloppyImage2Vector::ConstIterator it = vec.begin();
+        CFloppyImageVector vec = mVBox.GetFloppyImages();
+        for (CFloppyImageVector::ConstIterator it = vec.begin();
              it != vec.end(); ++ it)
         {

trunk/src/VBox/Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp

@@ -972 +972 @@
     if (dlg.exec() == QDialog::Accepted)
     {
-        CHardDisk2 hd = dlg.hardDisk();
+        CHardDisk hd = dlg.hardDisk();
         /* Select the newly created hard disk */
         MediaItem *item = searchItem (mHardDiskView, hd.GetId());
@@ -1094 +1094 @@
             }
 
-            CHardDisk2 hardDisk = item->medium().hardDisk();
+            CHardDisk hardDisk = item->medium().hardDisk();
 
             if (deleteStorage)
@@ -1134 +1134 @@
         case VBoxDefs::MediaType_Floppy:
         {
-            CFloppyImage2 image = item->medium().floppyImage();
+            CFloppyImage image = item->medium().floppyImage();
             image.Close();
             result = image;
@@ -1232 +1232 @@
         case VBoxDefs::MediaType_HardDisk:
         {
-            CHardDisk2AttachmentVector vec =machine.GetHardDisk2Attachments();
+            CHardDiskAttachmentVector vec =machine.GetHardDiskAttachments();
             for (int i = 0; i < vec.size(); ++ i)
             {
-                CHardDisk2Attachment hda = vec [i];
+                CHardDiskAttachment hda = vec [i];
                 if (hda.GetHardDisk().GetId() == aMedium.id())
                 {
-                    machine.DetachHardDisk2 (hda.GetBus(),
-                                             hda.GetChannel(),
-                                             hda.GetDevice());
+                    machine.DetachHardDisk(hda.GetBus(),
+                                           hda.GetChannel(),
+                                           hda.GetDevice());
                     if (!machine.isOk())
                     {
@@ -1543 +1543 @@
         case VBoxDefs::MediaType_HardDisk:
         {
-            CHardDisk2 hd = mVBox.OpenHardDisk2 (aLocation);
+            CHardDisk hd = mVBox.OpenHardDisk(aLocation);
             if (mVBox.isOk())
             {
@@ -1565 +1565 @@
         case VBoxDefs::MediaType_Floppy:
         {
-            CFloppyImage2 image = mVBox.OpenFloppyImage (aLocation, uuid);
+            CFloppyImage image = mVBox.OpenFloppyImage (aLocation, uuid);
             if (mVBox.isOk())
             {
@@ -1591 +1591 @@
     MediaItem *item = 0;
 
-    CHardDisk2 parent = aMedium.hardDisk().GetParent();
+    CHardDisk parent = aMedium.hardDisk().GetParent();
     if (parent.isNull())
     {

trunk/src/VBox/Frontends/VirtualBox/src/VBoxNewHDWzd.cpp

@@ -384 +384 @@
     CProgress progress;
 
-    CHardDisk2 hd = vbox.CreateHardDisk2 (QString ("VDI"), loc);
+    CHardDisk hd = vbox.CreateHardDisk(QString ("VDI"), loc);
 
     if (!vbox.isOk())

trunk/src/VBox/Frontends/VirtualBox/src/VBoxNewVMWzd.cpp

@@ -352 +352 @@
         {
             CMachine m = session.GetMachine();
-            m.AttachHardDisk2 (mHDCombo->id(), KStorageBus_IDE, 0, 0);
+            m.AttachHardDisk(mHDCombo->id(), KStorageBus_IDE, 0, 0);
             if (m.isOk())
             {

trunk/src/VBox/Frontends/VirtualBox/src/VBoxProblemReporter.cpp

@@ -1203 +1203 @@
 
 void VBoxProblemReporter::cannotDeleteHardDiskStorage (QWidget *aParent,
-                                                       const CHardDisk2 &aHD,
+                                                       const CHardDisk &aHD,
                                                        const CProgress &aProgress)
 {
-    /* below, we use CHardDisk2 (aHD) to preserve current error info
+    /* below, we use CHardDisk (aHD) to preserve current error info
      * for formatErrorInfo() */
 
     message (aParent, Error,
         tr ("Failed to delete the storage unit of the hard disk <b>%1</b>.")
-            .arg (CHardDisk2 (aHD).GetLocation()),
+            .arg (CHardDisk (aHD).GetLocation()),
         !aHD.isOk() ? formatErrorInfo (aHD) :
         !aProgress.isOk() ? formatErrorInfo (aProgress) :
@@ -1248 +1248 @@
 void VBoxProblemReporter::cannotCreateHardDiskStorage (
     QWidget *aParent, const CVirtualBox &aVBox, const QString &aLocation,
-    const CHardDisk2 &aHD, const CProgress &aProgress)
+    const CHardDisk &aHD, const CProgress &aProgress)
 {
     message (aParent, Error,

trunk/src/VBox/Frontends/VirtualBox/src/VBoxSelectorWnd.cpp

@@ -872 +872 @@
             CMachine machine = session.GetMachine();
             /* Detach all attached Hard Disks */
-            CHardDisk2AttachmentVector vec = machine.GetHardDisk2Attachments();
+            CHardDiskAttachmentVector vec = machine.GetHardDiskAttachments();
             for (int i = 0; i < vec.size(); ++ i)
             {
-                CHardDisk2Attachment hda = vec [i];
-                machine.DetachHardDisk2 (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
+                CHardDiskAttachment hda = vec [i];
+                machine.DetachHardDisk(hda.GetBus(), hda.GetChannel(), hda.GetDevice());
                 if (!machine.isOk())
                     vboxProblem().cannotDetachHardDisk (this, machine,

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMFirstRunWzd.cpp

@@ -36 +36 @@
 
     /* Hide unnecessary text labels */
-    CHardDisk2AttachmentVector vec = mMachine.GetHardDisk2Attachments();
+    CHardDiskAttachmentVector vec = mMachine.GetHardDiskAttachments();
     if (vec.size() != 0)
     {

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMInformationDlg.cpp

@@ -467 +467 @@
 
         /* IDE Hard Disk (Primary Master) */
-        if (!m.GetHardDisk2 (KStorageBus_IDE, 0, 0).isNull())
+        if (!m.GetHardDisk(KStorageBus_IDE, 0, 0).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 0, 0, "IDE00");
@@ -474 +474 @@
 
         /* IDE Hard Disk (Primary Slave) */
-        if (!m.GetHardDisk2 (KStorageBus_IDE, 0, 1).isNull())
+        if (!m.GetHardDisk(KStorageBus_IDE, 0, 1).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 0, 1, "IDE01");
@@ -481 +481 @@
 
         /* IDE Hard Disk (Secondary Slave) */
-        if (!m.GetHardDisk2 (KStorageBus_IDE, 1, 1).isNull())
+        if (!m.GetHardDisk(KStorageBus_IDE, 1, 1).isNull())
         {
             hdStat += formatHardDisk (KStorageBus_IDE, 1, 1, "IDE11");
@@ -490 +490 @@
         for (int i = 0; i < 30; ++ i)
         {
-            if (!m.GetHardDisk2 (KStorageBus_SATA, i, 0).isNull())
+            if (!m.GetHardDisk(KStorageBus_SATA, i, 0).isNull())
             {
                 hdStat += formatHardDisk (KStorageBus_SATA, i, 0,
@@ -574 +574 @@
         return QString::null;
 
-    CHardDisk2 hd = mSession.GetMachine().GetHardDisk2 (aBus, aChannel, aDevice);
+    CHardDisk hd = mSession.GetMachine().GetHardDisk(aBus, aChannel, aDevice);
     QString header = "<tr><td></td><td colspan=2><nobr><u>%1</u></nobr></td></tr>";
     QString name = vboxGlobal().toFullString (aBus, aChannel, aDevice);

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMSettingsFD.cpp

@@ -110 +110 @@
         case KDriveState_ImageMounted:
         {
-            CFloppyImage2 img = floppy.GetImage();
+            CFloppyImage img = floppy.GetImage();
             QString src = img.GetLocation();
             AssertMsg (!src.isNull(), ("Image file must not be null"));

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMSettingsHD.cpp

@@ -77 +77 @@
 
     VBoxMedium medium = vboxGlobal().getMedium (
-        CMedium (vboxGlobal().virtualBox().GetHardDisk2 (aId)));
+        CMedium (vboxGlobal().virtualBox().GetHardDisk(aId)));
     medium.refresh();
     bool noDiffs = !HDSettings::instance()->showDiffs();
@@ -662 +662 @@
 
     /* Load attachments list */
-    CHardDisk2AttachmentVector vec = mMachine.GetHardDisk2Attachments();
+    CHardDiskAttachmentVector vec = mMachine.GetHardDiskAttachments();
     for (int i = 0; i < vec.size(); ++ i)
     {
-        CHardDisk2Attachment hda = vec [i];
+        CHardDiskAttachment hda = vec [i];
         SlotValue slot (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
         DiskValue disk (hda.GetHardDisk().GetId());
@@ -687 +687 @@
 
     /* Detach all attached Hard Disks */
-    CHardDisk2AttachmentVector vec = mMachine.GetHardDisk2Attachments();
+    CHardDiskAttachmentVector vec = mMachine.GetHardDiskAttachments();
     for (int i = 0; i < vec.size(); ++ i)
     {
-        CHardDisk2Attachment hda = vec [i];
-        mMachine.DetachHardDisk2 (hda.GetBus(), hda.GetChannel(), hda.GetDevice());
+        CHardDiskAttachment hda = vec [i];
+        mMachine.DetachHardDisk(hda.GetBus(), hda.GetChannel(), hda.GetDevice());
 
         /* [dsen] check this */
@@ -708 +708 @@
             maxSATAPort = maxSATAPort < (list [i].slot.channel + 1) ?
                           (list [i].slot.channel + 1) : maxSATAPort;
-        mMachine.AttachHardDisk2 (list [i].disk.id,
+        mMachine.AttachHardDisk(list [i].disk.id,
             list [i].slot.bus, list [i].slot.channel, list [i].slot.device);
 
@@ -715 +715 @@
             vboxProblem().cannotAttachHardDisk (this, mMachine,
                 vboxGlobal().getMedium (CMedium (vboxGlobal().virtualBox()
-                .GetHardDisk2 (list [i].disk.id))).location(),
+                .GetHardDisk(list [i].disk.id))).location(),
                 list [i].slot.bus, list [i].slot.channel, list [i].slot.device);
     }

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -1199 +1199 @@
 {
     // @todo:
-    //  - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk2))
+    //  - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
     //  - Appropriate handle errors like not supported file formats
     AutoCaller autoCaller(this);
@@ -1625 +1625 @@
 HRESULT Appliance::searchUniqueDiskImageFilePath(Utf8Str& aName) const
 {
-    IHardDisk2 *harddisk = NULL;
+    IHardDisk *harddisk = NULL;
     char *tmpName = RTStrDup(aName.c_str());
     int i = 1;
@@ -1632 +1632 @@
     /* @todo: Maybe too cost-intensive; try to find a lighter way */
     while (RTPathExists(tmpName) ||
-           mVirtualBox->FindHardDisk2(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
+           mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
     {
         RTStrFree(tmpName);
@@ -1659 +1659 @@
     Appliance *app = task->that;
 
-    /// @todo ugly hack, fix ComAssert... (same as in HardDisk2::taskThread)
+    /// @todo ugly hack, fix ComAssert... (same as in HardDisk::taskThread)
     #define setError app->setError
 
@@ -1921 +1921 @@
                    the machine, so make an extra try/catch block. */
                 ComPtr<ISession> session;
-                ComPtr<IHardDisk2> srcHdVBox;
+                ComPtr<IHardDisk> srcHdVBox;
                 try
                 {
@@ -1973 +1973 @@
                         rc = VirtualBox::ensureFilePathExists(pcszDstFilePath);
                         CheckComRCThrowRC(rc);
-                        ComPtr<IHardDisk2> dstHdVBox;
+                        ComPtr<IHardDisk> dstHdVBox;
                         /* If strHref is empty we have to create a new file */
                         if (di.strHref.c_str()[0] == 0)
@@ -1983 +1983 @@
                                 srcFormat = L"VMDK";
                             /* Create an empty hard disk */
-                            rc = app->mVirtualBox->CreateHardDisk2(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
+                            rc = app->mVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
                             CheckComRCThrowRC(rc);
                             /* Create a dynamic growing disk image with the given capacity */
@@ -2033 +2033 @@
                              * attached already from a previous import) */
                             /* First open the existing disk image */
-                            rc = app->mVirtualBox->OpenHardDisk2(Bstr(strSrcFilePath), srcHdVBox.asOutParam());
+                            rc = app->mVirtualBox->OpenHardDisk(Bstr(strSrcFilePath), srcHdVBox.asOutParam());
                             CheckComRCThrowRC(rc);
                             /* We need the format description of the source disk image */
@@ -2040 +2040 @@
                             CheckComRCThrowRC(rc);
                             /* Create a new hard disk interface for the destination disk image */
-                            rc = app->mVirtualBox->CreateHardDisk2(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
+                            rc = app->mVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
                             CheckComRCThrowRC(rc);
                             /* Clone the source disk image */
@@ -2096 +2096 @@
                             default: break;
                         }
-                        rc = sMachine->AttachHardDisk2(hdId, sbt, hdc.ulBusNumber, 0);
+                        rc = sMachine->AttachHardDisk(hdId, sbt, hdc.ulBusNumber, 0);
                         CheckComRCThrowRC(rc);
                         rc = sMachine->SaveSettings();
@@ -2150 +2150 @@
     LogFlowFuncLeave();
 
-    /// @todo ugly hack, fix ComAssert... (same as in HardDisk2::taskThread)
+    /// @todo ugly hack, fix ComAssert... (same as in HardDisk::taskThread)
     #undef setError
 

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -2657 +2657 @@
         case DriveState_ImageMounted:
         {
-            ComPtr <IFloppyImage2> ImagePtr;
+            ComPtr<IFloppyImage> ImagePtr;
             rc = mFloppyDrive->GetImage (ImagePtr.asOutParam());
             if (SUCCEEDED (rc))
@@ -4355 +4355 @@
     /* lock all hard disks for writing and their parents for reading */
     {
-        com::SafeIfaceArray <IHardDisk2Attachment> atts;
+        com::SafeIfaceArray <IHardDiskAttachment> atts;
         rc = mMachine->
-            COMGETTER(HardDisk2Attachments) (ComSafeArrayAsOutParam (atts));
+            COMGETTER(HardDiskAttachments) (ComSafeArrayAsOutParam (atts));
         CheckComRCReturnRC (rc);
 
         for (size_t i = 0; i < atts.size(); ++ i)
         {
-            ComPtr <IHardDisk2> hardDisk;
+            ComPtr <IHardDisk> hardDisk;
             rc = atts [i]->COMGETTER(HardDisk) (hardDisk.asOutParam());
             CheckComRCReturnRC (rc);
@@ -4391 +4391 @@
                     task->mediaToCheck.push_back (hardDisk);
 
-                ComPtr <IHardDisk2> parent;
+                ComPtr <IHardDisk> parent;
                 rc = hardDisk->COMGETTER(Parent) (parent.asOutParam());
                 CheckComRCReturnRC (rc);
@@ -4436 +4436 @@
         if (driveState == DriveState_ImageMounted)
         {
-            ComPtr <IFloppyImage2> image;
+            ComPtr<IFloppyImage> image;
             rc = drive->GetImage (image.asOutParam());
             CheckComRCReturnRC (rc);
@@ -6782 +6782 @@
  *  @return  VBox status code.
  */
-static DECLCALLBACK(int) reconfigureHardDisks(PVM pVM, IHardDisk2Attachment *hda,
+static DECLCALLBACK(int) reconfigureHardDisks(PVM pVM, IHardDiskAttachment *hda,
                                               HRESULT *phrc)
 {
@@ -6797 +6797 @@
      * Figure out which IDE device this is.
      */
-    ComPtr<IHardDisk2> hardDisk;
+    ComPtr<IHardDisk> hardDisk;
     hrc = hda->COMGETTER(HardDisk)(hardDisk.asOutParam());                      H();
     StorageBus_T enmBus;
@@ -6947 +6947 @@
 
     /* Create an inversed tree of parents. */
-    ComPtr<IHardDisk2> parentHardDisk = hardDisk;
+    ComPtr<IHardDisk> parentHardDisk = hardDisk;
     for (PCFGMNODE pParent = pCfg;;)
     {
@@ -7084 +7084 @@
             LogFlowFunc (("Reattaching new differencing hard disks...\n"));
 
-            com::SafeIfaceArray <IHardDisk2Attachment> atts;
+            com::SafeIfaceArray <IHardDiskAttachment> atts;
             rc = that->mMachine->
-                COMGETTER(HardDisk2Attachments) (ComSafeArrayAsOutParam (atts));
+                COMGETTER(HardDiskAttachments) (ComSafeArrayAsOutParam (atts));
             if (FAILED (rc))
                 break;

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -577 +577 @@
         rc = CFGMR3InsertNode(pInst,    "LUN#0",     &pLunL0);                          RC_CHECK();
 
-        ComPtr<IFloppyImage2> floppyImage;
+        ComPtr<IFloppyImage> floppyImage;
         hrc = floppyDrive->GetImage(floppyImage.asOutParam());                      H();
         if (floppyImage)
@@ -867 +867 @@
     /* Attach the hard disks */
     {
-        com::SafeIfaceArray <IHardDisk2Attachment> atts;
+        com::SafeIfaceArray<IHardDiskAttachment> atts;
         hrc = pMachine->
-            COMGETTER(HardDisk2Attachments) (ComSafeArrayAsOutParam (atts));    H();
+            COMGETTER(HardDiskAttachments) (ComSafeArrayAsOutParam (atts));    H();
 
         for (size_t i = 0; i < atts.size(); ++ i)
         {
-            ComPtr <IHardDisk2> hardDisk;
+            ComPtr<IHardDisk> hardDisk;
             hrc = atts [i]->COMGETTER(HardDisk) (hardDisk.asOutParam());        H();
             StorageBus_T enmBus;
@@ -986 +986 @@
 
             /* Create an inversed tree of parents. */
-            ComPtr <IHardDisk2> parentHardDisk = hardDisk;
+            ComPtr<IHardDisk> parentHardDisk = hardDisk;
             for (PCFGMNODE pParent = pCfg;;)
             {

trunk/src/VBox/Main/FloppyDriveImpl.cpp

@@ -273 +273 @@
      * We also don't lock mParent since its mParent field is const. */
 
-    ComObjPtr <FloppyImage2> image;
-    rc = mParent->virtualBox()->findFloppyImage2 (&imageId, NULL,
-                                                  true /* aSetError */, &image);
+    ComObjPtr<FloppyImage> image;
+    rc = mParent->virtualBox()->findFloppyImage(&imageId, NULL,
+                                                true /* aSetError */, &image);
 
     if (SUCCEEDED (rc))
@@ -377 +377 @@
 }
 
-STDMETHODIMP FloppyDrive::GetImage (IFloppyImage2 **aFloppyImage)
+STDMETHODIMP FloppyDrive::GetImage(IFloppyImage **aFloppyImage)
 {
     CheckComArgOutPointerValid(aFloppyImage);

trunk/src/VBox/Main/HardDisk2Impl.cpp

@@ -22 +22 @@
  */
 
-#include "HardDisk2Impl.h"
+#include "HardDiskImpl.h"
 
 #include "ProgressImpl.h"
@@ -53 +53 @@
  * task thread function will delete them when the task is complete!
  *
- * @note The constructor of this class adds a caller on the managed HardDisk2
+ * @note The constructor of this class adds a caller on the managed HardDisk
  *       object which is automatically released upon destruction.
  */
-struct HardDisk2::Task : public com::SupportErrorInfoBase
+struct HardDisk::Task : public com::SupportErrorInfoBase
 {
     enum Operation { CreateDynamic, CreateFixed, CreateDiff,
                      Merge, Clone, Delete };
 
-    HardDisk2 *that;
+    HardDisk *that;
     VirtualBoxBaseProto::AutoCaller autoCaller;
 
@@ -70 +70 @@
     HRESULT rc;
 
-    Task (HardDisk2 *aThat, Progress *aProgress, Operation aOperation)
+    Task (HardDisk *aThat, Progress *aProgress, Operation aOperation)
         : that (aThat), autoCaller (aThat)
         , progress (aProgress)
@@ -78 +78 @@
     ~Task();
 
-    void setData (HardDisk2 *aTarget)
+    void setData (HardDisk *aTarget)
     {
         d.target = aTarget;
@@ -104 +104 @@
         /* CreateDiff */
 
-        ComObjPtr <HardDisk2> target;
+        ComObjPtr<HardDisk> target;
 
         /* Merge */
@@ -116 +116 @@
 
     // SupportErrorInfoBase interface
-    const GUID &mainInterfaceID() const { return COM_IIDOF (IHardDisk2); }
-    const char *componentName() const { return HardDisk2::ComponentName(); }
+    const GUID &mainInterfaceID() const { return COM_IIDOF (IHardDisk); }
+    const char *componentName() const { return HardDisk::ComponentName(); }
 };
 
-HardDisk2::Task::~Task()
+HardDisk::Task::~Task()
 {
     /* remove callers added by setData() */
@@ -128 +128 @@
 
 /**
- * Starts a new thread driven by the HardDisk2::taskThread() function and passes
+ * Starts a new thread driven by the HardDisk::taskThread() function and passes
  * this Task instance as an argument.
  *
@@ -140 +140 @@
  *       other threads asynchronously waiting for it.
  */
-HRESULT HardDisk2::Task::startThread()
-{
-    int vrc = RTThreadCreate (NULL, HardDisk2::taskThread, this,
+HRESULT HardDisk::Task::startThread()
+{
+    int vrc = RTThreadCreate (NULL, HardDisk::taskThread, this,
                               0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
                               "HardDisk::Task");
@@ -152 +152 @@
 
 /**
- * Runs HardDisk2::taskThread() by passing it this Task instance as an argument
+ * Runs HardDisk::taskThread() by passing it this Task instance as an argument
  * on the current thread instead of creating a new one.
  *
@@ -169 +169 @@
  *       complete the progress object in this case.
  */
-HRESULT HardDisk2::Task::runNow()
-{
-    HardDisk2::taskThread (NIL_RTTHREAD, this);
+HRESULT HardDisk::Task::runNow()
+{
+    HardDisk::taskThread (NIL_RTTHREAD, this);
 
     return rc;
@@ -182 +182 @@
  *
  * @note It is assumed that when modifying methods of this class are called,
- *       HardDisk2::treeLock() is held in read mode.
+ *       HardDisk::treeLock() is held in read mode.
  */
-class HardDisk2::MergeChain : public HardDisk2::List,
-                              public com::SupportErrorInfoBase
+class HardDisk::MergeChain : public HardDisk::List,
+                             public com::SupportErrorInfoBase
 {
 public:
@@ -220 +220 @@
     }
 
-    HRESULT addSource (HardDisk2 *aHardDisk)
+    HRESULT addSource (HardDisk *aHardDisk)
     {
         HRESULT rc = aHardDisk->addCaller();
@@ -284 +284 @@
     }
 
-    HRESULT addTarget (HardDisk2 *aHardDisk)
+    HRESULT addTarget (HardDisk *aHardDisk)
     {
         HRESULT rc = aHardDisk->addCaller();
@@ -314 +314 @@
     }
 
-    HRESULT addIntermediate (HardDisk2 *aHardDisk)
+    HRESULT addIntermediate (HardDisk *aHardDisk)
     {
         HRESULT rc = aHardDisk->addCaller();
@@ -345 +345 @@
 
     bool isForward() const { return mForward; }
-    HardDisk2 *parent() const { return mParent; }
+    HardDisk *parent() const { return mParent; }
     const List &children() const { return mChildren; }
 
-    HardDisk2 *source() const
+    HardDisk *source() const
     { AssertReturn (size() > 0, NULL); return mForward ? front() : back(); }
 
-    HardDisk2 *target() const
+    HardDisk *target() const
     { AssertReturn (size() > 0, NULL); return mForward ? back() : front(); }
 
@@ -357 +357 @@
 
     // SupportErrorInfoBase interface
-    const GUID &mainInterfaceID() const { return COM_IIDOF (IHardDisk2); }
-    const char *componentName() const { return HardDisk2::ComponentName(); }
+    const GUID &mainInterfaceID() const { return COM_IIDOF (IHardDisk); }
+    const char *componentName() const { return HardDisk::ComponentName(); }
 
 private:
 
-    HRESULT check (HardDisk2 *aHardDisk, bool aChildren, bool aAttachments,
+    HRESULT check (HardDisk *aHardDisk, bool aChildren, bool aAttachments,
                    bool aImmutable)
     {
@@ -398 +398 @@
     }
 
-    HRESULT checkChildren (HardDisk2 *aHardDisk)
+    HRESULT checkChildren (HardDisk *aHardDisk)
     { return check (aHardDisk, true, false, false); }
 
-    HRESULT checkChildrenAndImmutable (HardDisk2 *aHardDisk)
+    HRESULT checkChildrenAndImmutable (HardDisk *aHardDisk)
     { return check (aHardDisk, true, false, true); }
 
-    HRESULT checkChildrenAndAttachments (HardDisk2 *aHardDisk)
+    HRESULT checkChildrenAndAttachments (HardDisk *aHardDisk)
     { return check (aHardDisk, true, true, false); }
 
-    HRESULT checkChildrenAndAttachmentsAndImmutable (HardDisk2 *aHardDisk)
+    HRESULT checkChildrenAndAttachmentsAndImmutable (HardDisk *aHardDisk)
     { return check (aHardDisk, true, true, true); }
 
@@ -416 +416 @@
 
     /** Parent of the source when forward merge (if any) */
-    ComObjPtr <HardDisk2> mParent;
+    ComObjPtr <HardDisk> mParent;
     /** Children of the source when backward merge (if any) */
     List mChildren;
@@ -422 +422 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-// HardDisk2 class
+// HardDisk class
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -428 +428 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-DEFINE_EMPTY_CTOR_DTOR (HardDisk2)
-
-HRESULT HardDisk2::FinalConstruct()
+DEFINE_EMPTY_CTOR_DTOR (HardDisk)
+
+HRESULT HardDisk::FinalConstruct()
 {
     /* Initialize the callbacks of the VD error interface */
@@ -463 +463 @@
     int vrc;
     vrc = VDInterfaceAdd (&mm.vdIfError,
-                          "HardDisk2::vdInterfaceError",
+                          "HardDisk::vdInterfaceError",
                           VDINTERFACETYPE_ERROR,
                           &mm.vdIfCallsError, this, &mm.vdDiskIfaces);
@@ -469 +469 @@
 
     vrc = VDInterfaceAdd (&mm.vdIfProgress,
-                          "HardDisk2::vdInterfaceProgress",
+                          "HardDisk::vdInterfaceProgress",
                           VDINTERFACETYPE_PROGRESS,
                           &mm.vdIfCallsProgress, this, &mm.vdDiskIfaces);
@@ -475 +475 @@
 
     vrc = VDInterfaceAdd (&mm.vdIfConfig,
-                          "HardDisk2::vdInterfaceConfig",
+                          "HardDisk::vdInterfaceConfig",
                           VDINTERFACETYPE_CONFIG,
                           &mm.vdIfCallsConfig, this, &mm.vdDiskIfaces);
@@ -481 +481 @@
 
     vrc = VDInterfaceAdd (&mm.vdIfTcpNet,
-                          "HardDisk2::vdInterfaceTcpNet",
+                          "HardDisk::vdInterfaceTcpNet",
                           VDINTERFACETYPE_TCPNET,
                           &mm.vdIfCallsTcpNet, this, &mm.vdDiskIfaces);
@@ -489 +489 @@
 }
 
-void HardDisk2::FinalRelease()
+void HardDisk::FinalRelease()
 {
     uninit();
@@ -509 +509 @@
  * @param aLocaiton     Storage unit location.
  */
-HRESULT HardDisk2::init (VirtualBox *aVirtualBox, CBSTR aFormat,
-                         CBSTR aLocation)
+HRESULT HardDisk::init(VirtualBox *aVirtualBox, CBSTR aFormat,
+                       CBSTR aLocation)
 {
     AssertReturn (aVirtualBox != NULL, E_FAIL);
@@ -561 +561 @@
         m.state = MediaState_Created;
         unconst (m.id).create();
-        rc = mVirtualBox->registerHardDisk2 (this);
+        rc = mVirtualBox->registerHardDisk (this);
 
         /// @todo later we may want to use a pfnIsConfigSufficient backend info
@@ -589 +589 @@
  * @param aLocaiton     Storage unit location.
  */
-HRESULT HardDisk2::init (VirtualBox *aVirtualBox, CBSTR aLocation)
+HRESULT HardDisk::init (VirtualBox *aVirtualBox, CBSTR aLocation)
 {
     AssertReturn (aVirtualBox, E_INVALIDARG);
@@ -649 +649 @@
  * @note Locks VirtualBox lock for writing, treeLock() for writing.
  */
-HRESULT HardDisk2::init (VirtualBox *aVirtualBox, HardDisk2 *aParent,
-                         const settings::Key &aNode)
+HRESULT HardDisk::init(VirtualBox *aVirtualBox, HardDisk *aParent,
+                       const settings::Key &aNode)
 {
     using namespace settings;
@@ -746 +746 @@
          it != hardDisks.end(); ++ it)
     {
-        ComObjPtr <HardDisk2> hardDisk;
+        ComObjPtr<HardDisk> hardDisk;
         hardDisk.createObject();
         rc = hardDisk->init (aVirtualBox, this, *it);
         CheckComRCBreakRC (rc);
 
-        rc = mVirtualBox->registerHardDisk2 (hardDisk, false /* aSaveRegistry */);
+        rc = mVirtualBox->registerHardDisk(hardDisk, false /* aSaveRegistry */);
         CheckComRCBreakRC (rc);
     }
@@ -772 +772 @@
  * @note Locks treeLock() for writing, VirtualBox for writing.
  */
-void HardDisk2::uninit()
+void HardDisk::uninit()
 {
     /* Enclose the state transition Ready->InUninit->NotReady */
@@ -814 +814 @@
 }
 
-// IHardDisk2 properties
+// IHardDisk properties
 ////////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP HardDisk2::COMGETTER(Format) (BSTR *aFormat)
+STDMETHODIMP HardDisk::COMGETTER(Format) (BSTR *aFormat)
 {
     if (aFormat == NULL)
@@ -831 +831 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(Type) (HardDiskType_T *aType)
+STDMETHODIMP HardDisk::COMGETTER(Type) (HardDiskType_T *aType)
 {
     if (aType == NULL)
@@ -846 +846 @@
 }
 
-STDMETHODIMP HardDisk2::COMSETTER(Type) (HardDiskType_T aType)
+STDMETHODIMP HardDisk::COMSETTER(Type) (HardDiskType_T aType)
 {
     AutoCaller autoCaller (this);
@@ -914 +914 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(Parent) (IHardDisk2 **aParent)
+STDMETHODIMP HardDisk::COMGETTER(Parent) (IHardDisk **aParent)
 {
     if (aParent == NULL)
@@ -930 +930 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(Children) (ComSafeArrayOut (IHardDisk2 *, aChildren))
+STDMETHODIMP HardDisk::COMGETTER(Children) (ComSafeArrayOut (IHardDisk *, aChildren))
 {
     if (ComSafeArrayOutIsNull (aChildren))
@@ -941 +941 @@
     AutoReadLock treeLock (this->treeLock());
 
-    SafeIfaceArray <IHardDisk2> children (this->children());
+    SafeIfaceArray<IHardDisk> children (this->children());
     children.detachTo (ComSafeArrayOutArg (aChildren));
 
@@ -947 +947 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(Root) (IHardDisk2 **aRoot)
+STDMETHODIMP HardDisk::COMGETTER(Root)(IHardDisk **aRoot)
 {
     if (aRoot == NULL)
@@ -959 +959 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(ReadOnly) (BOOL *aReadOnly)
+STDMETHODIMP HardDisk::COMGETTER(ReadOnly) (BOOL *aReadOnly)
 {
     if (aReadOnly == NULL)
@@ -974 +974 @@
 }
 
-STDMETHODIMP HardDisk2::COMGETTER(LogicalSize) (ULONG64 *aLogicalSize)
+STDMETHODIMP HardDisk::COMGETTER(LogicalSize) (ULONG64 *aLogicalSize)
 {
     if (aLogicalSize == NULL)
@@ -1005 +1005 @@
 }
 
-// IHardDisk2 methods
+// IHardDisk methods
 ////////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP HardDisk2::GetProperty (IN_BSTR aName, BSTR *aValue)
+STDMETHODIMP HardDisk::GetProperty (IN_BSTR aName, BSTR *aValue)
 {
     CheckComArgStrNotEmptyOrNull (aName);
@@ -1028 +1028 @@
 }
 
-STDMETHODIMP HardDisk2::SetProperty (IN_BSTR aName, IN_BSTR aValue)
+STDMETHODIMP HardDisk::SetProperty (IN_BSTR aName, IN_BSTR aValue)
 {
     CheckComArgStrNotEmptyOrNull (aName);
@@ -1059 +1059 @@
 }
 
-STDMETHODIMP HardDisk2::GetProperties (IN_BSTR aNames,
-                                       ComSafeArrayOut (BSTR, aReturnNames),
-                                       ComSafeArrayOut (BSTR, aReturnValues))
+STDMETHODIMP HardDisk::GetProperties(IN_BSTR aNames,
+                                     ComSafeArrayOut (BSTR, aReturnNames),
+                                     ComSafeArrayOut (BSTR, aReturnValues))
 {
     CheckComArgOutSafeArrayPointerValid (aReturnNames);
@@ -1092 +1092 @@
 }
 
-STDMETHODIMP HardDisk2::SetProperties (ComSafeArrayIn (IN_BSTR, aNames),
-                                       ComSafeArrayIn (IN_BSTR, aValues))
+STDMETHODIMP HardDisk::SetProperties(ComSafeArrayIn (IN_BSTR, aNames),
+                                      ComSafeArrayIn (IN_BSTR, aValues))
 {
     CheckComArgSafeArrayNotNull (aNames);
@@ -1129 +1129 @@
 }
 
-STDMETHODIMP HardDisk2::CreateDynamicStorage (ULONG64 aLogicalSize,
-                                              IProgress **aProgress)
+STDMETHODIMP HardDisk::CreateDynamicStorage(ULONG64 aLogicalSize,
+                                            IProgress **aProgress)
 {
     CheckComArgOutPointerValid (aProgress);
@@ -1155 +1155 @@
     ComObjPtr <Progress> progress;
     progress.createObject();
-    HRESULT rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+    HRESULT rc = progress->init (mVirtualBox, static_cast<IHardDisk*>(this),
         BstrFmt (tr ("Creating dynamic hard disk storage unit '%ls'"),
                  m.locationFull.raw()),
@@ -1184 +1184 @@
 }
 
-STDMETHODIMP HardDisk2::CreateFixedStorage (ULONG64 aLogicalSize,
-                                            IProgress **aProgress)
+STDMETHODIMP HardDisk::CreateFixedStorage(ULONG64 aLogicalSize,
+                                          IProgress **aProgress)
 {
     CheckComArgOutPointerValid (aProgress);
@@ -1210 +1210 @@
     ComObjPtr <Progress> progress;
     progress.createObject();
-    HRESULT rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+    HRESULT rc = progress->init (mVirtualBox, static_cast<IHardDisk*>(this),
         BstrFmt (tr ("Creating fixed hard disk storage unit '%ls'"),
                  m.locationFull.raw()),
@@ -1239 +1239 @@
 }
 
-STDMETHODIMP HardDisk2::DeleteStorage (IProgress **aProgress)
+STDMETHODIMP HardDisk::DeleteStorage (IProgress **aProgress)
 {
     CheckComArgOutPointerValid (aProgress);
@@ -1258 +1258 @@
 }
 
-STDMETHODIMP HardDisk2::CreateDiffStorage (IHardDisk2 *aTarget, IProgress **aProgress)
+STDMETHODIMP HardDisk::CreateDiffStorage (IHardDisk *aTarget, IProgress **aProgress)
 {
     CheckComArgNotNull (aTarget);
@@ -1266 +1266 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    ComObjPtr <HardDisk2> diff;
+    ComObjPtr<HardDisk> diff;
     HRESULT rc = mVirtualBox->cast (aTarget, diff);
     CheckComRCReturnRC (rc);
@@ -1300 +1300 @@
 }
 
-STDMETHODIMP HardDisk2::MergeTo (IN_GUID aTargetId, IProgress **aProgress)
+STDMETHODIMP HardDisk::MergeTo (IN_GUID aTargetId, IProgress **aProgress)
 {
     AutoCaller autoCaller (this);
@@ -1308 +1308 @@
 }
 
-STDMETHODIMP HardDisk2::CloneTo (IHardDisk2 *aTarget, IProgress **aProgress)
+STDMETHODIMP HardDisk::CloneTo (IHardDisk *aTarget, IProgress **aProgress)
 {
     CheckComArgNotNull (aTarget);
@@ -1316 +1316 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    ComObjPtr <HardDisk2> target;
+    ComObjPtr <HardDisk> target;
     HRESULT rc = mVirtualBox->cast (aTarget, target);
     CheckComRCReturnRC (rc);
@@ -1335 +1335 @@
 
         progress.createObject();
-        rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+        rc = progress->init (mVirtualBox, static_cast <IHardDisk *> (this),
             BstrFmt (tr ("Creating clone hard disk '%ls'"),
                      target->m.locationFull.raw()),
@@ -1378 +1378 @@
 }
 
-STDMETHODIMP HardDisk2::FlattenTo (IHardDisk2 *aTarget, IProgress **aProgress)
+STDMETHODIMP HardDisk::FlattenTo (IHardDisk *aTarget, IProgress **aProgress)
 {
     AutoCaller autoCaller (this);
@@ -1386 +1386 @@
 }
 
-STDMETHODIMP HardDisk2::Compact (IProgress **aProgress)
+STDMETHODIMP HardDisk::Compact (IProgress **aProgress)
 {
     AutoCaller autoCaller (this);
@@ -1407 +1407 @@
  * @note Locks treeLock() for reading, this object and all children for writing.
  */
-void HardDisk2::updatePaths (const char *aOldPath, const char *aNewPath)
+void HardDisk::updatePaths (const char *aOldPath, const char *aNewPath)
 {
     AssertReturnVoid (aOldPath);
@@ -1443 +1443 @@
  * @note Locks treeLock() for reading.
  */
-ComObjPtr <HardDisk2> HardDisk2::root (uint32_t *aLevel /*= NULL*/)
-{
-    ComObjPtr <HardDisk2> root;
+ComObjPtr <HardDisk> HardDisk::root (uint32_t *aLevel /*= NULL*/)
+{
+    ComObjPtr <HardDisk> root;
     uint32_t level;
 
@@ -1485 +1485 @@
  * @note Locks this object and treeLock() for reading.
  */
-bool HardDisk2::isReadOnly()
+bool HardDisk::isReadOnly()
 {
     AutoCaller autoCaller (this);
@@ -1532 +1532 @@
  * @note Locks this object, treeLock() and children for reading.
  */
-HRESULT HardDisk2::saveSettings (settings::Key &aParentNode)
+HRESULT HardDisk::saveSettings (settings::Key &aParentNode)
 {
     using namespace settings;
@@ -1608 +1608 @@
  *                      the specified location, and -1 otherwise.
  */
-HRESULT HardDisk2::compareLocationTo (const char *aLocation, int &aResult)
+HRESULT HardDisk::compareLocationTo (const char *aLocation, int &aResult)
 {
     AutoCaller autoCaller (this);
@@ -1654 +1654 @@
  * @note Must be called from under this object's read or write lock.
  */
-Utf8Str HardDisk2::name()
+Utf8Str HardDisk::name()
 {
     /// @todo NEWMEDIA treat non-FS-paths specially! (may require to requiest
@@ -1682 +1682 @@
  *       intermediate hard disks for writing.
  */
-HRESULT HardDisk2::prepareDiscard (MergeChain * &aChain)
+HRESULT HardDisk::prepareDiscard (MergeChain * &aChain)
 {
     AutoCaller autoCaller (this);
@@ -1738 +1738 @@
                   m.backRefs.front().snapshotIds.size() == 1, E_FAIL);
 
-    ComObjPtr <HardDisk2> child = children().front();
+    ComObjPtr<HardDisk> child = children().front();
 
     /* we keep this locked, so lock the affected child to make sure the lock
@@ -1812 +1812 @@
  *       reading or writing.
  */
-HRESULT HardDisk2::discard (ComObjPtr <Progress> &aProgress, MergeChain *aChain)
+HRESULT HardDisk::discard (ComObjPtr <Progress> &aProgress, MergeChain *aChain)
 {
     AssertReturn (!aProgress.isNull(), E_FAIL);
 
-    ComObjPtr <HardDisk2> hdFrom;
+    ComObjPtr <HardDisk> hdFrom;
 
     HRESULT rc = S_OK;
@@ -1885 +1885 @@
  *       reading.
  */
-void HardDisk2::cancelDiscard (MergeChain *aChain)
+void HardDisk::cancelDiscard (MergeChain *aChain)
 {
     AutoCaller autoCaller (this);
@@ -1924 +1924 @@
  * Returns a preferred format for differencing hard disks.
  */
-Bstr HardDisk2::preferredDiffFormat()
+Bstr HardDisk::preferredDiffFormat()
 {
     Bstr format;
@@ -1970 +1970 @@
  *       writing.
  */
-HRESULT HardDisk2::deleteStorage (ComObjPtr <Progress> *aProgress, bool aWait)
+HRESULT HardDisk::deleteStorage (ComObjPtr <Progress> *aProgress, bool aWait)
 {
     AssertReturn (aProgress != NULL || aWait == true, E_FAIL);
@@ -1977 +1977 @@
      * ourselves atomically after detecting that deletion is possible to make
      * sure that we don't do that after another thread has done
-     * VirtualBox::findHardDisk2() but before it starts using us (provided that
+     * VirtualBox::findHardDisk() but before it starts using us (provided that
      * it holds a mVirtualBox lock too of course). */
 
@@ -2047 +2047 @@
         {
             progress.createObject();
-            rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+            rc = progress->init (mVirtualBox, static_cast<IHardDisk*>(this),
                 BstrFmt (tr ("Deleting hard disk storage unit '%ls'"),
                          m.locationFull.raw()),
@@ -2120 +2120 @@
  * @note Locks this object and @a aTarget for writing.
  */
-HRESULT HardDisk2::createDiffStorage (ComObjPtr <HardDisk2> &aTarget,
-                                      ComObjPtr <Progress> *aProgress,
-                                      bool aWait)
+HRESULT HardDisk::createDiffStorage(ComObjPtr<HardDisk> &aTarget,
+                                    ComObjPtr<Progress> *aProgress,
+                                     bool aWait)
 {
     AssertReturn (!aTarget.isNull(), E_FAIL);
@@ -2157 +2157 @@
              * SnapshotMachine::init()) before deassociating them from the
              * current state (which takes place only on success in
-             * Machine::fixupHardDisks2()), so that the size of snapshotIds
+             * Machine::fixupHardDisks()), so that the size of snapshotIds
              * will be 1 in this case. The given condition is used to filter out
              * this legal situatinon and do not report an error. */
@@ -2185 +2185 @@
         {
             progress.createObject();
-            rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+            rc = progress->init (mVirtualBox, static_cast<IHardDisk*> (this),
                 BstrFmt (tr ("Creating differencing hard disk storage unit '%ls'"),
                          aTarget->m.locationFull.raw()),
@@ -2256 +2256 @@
  *       intermediate hard disks for writing.
  */
-HRESULT HardDisk2::prepareMergeTo (HardDisk2 *aTarget,
-                                   MergeChain * &aChain,
-                                   bool aIgnoreAttachments /*= false*/)
+HRESULT HardDisk::prepareMergeTo(HardDisk *aTarget,
+                                 MergeChain * &aChain,
+                                 bool aIgnoreAttachments /*= false*/)
 {
     AssertReturn (aTarget != NULL, E_FAIL);
@@ -2278 +2278 @@
     bool forward;
     {
-        HardDisk2 *parent = mParent;
+        HardDisk *parent = mParent;
         while (parent != NULL && parent != aTarget)
             parent = parent->mParent;
@@ -2310 +2310 @@
                                                       aIgnoreAttachments));
     {
-        HardDisk2 *last = forward ? aTarget : this;
-        HardDisk2 *first = forward ? this : aTarget;
+        HardDisk *last = forward ? aTarget : this;
+        HardDisk *first = forward ? this : aTarget;
 
         for (;;)
@@ -2375 +2375 @@
  * Note that this (source) hard disk is not uninitialized because of possible
  * AutoCaller instances held by the caller of this method on the current thread.
- * It's therefore the responsibility of the caller to call HardDisk2::uninit()
+ * It's therefore the responsibility of the caller to call HardDisk::uninit()
  * after releasing all callers in this case!
  *
@@ -2405 +2405 @@
  *       for writing.
  */
-HRESULT HardDisk2::mergeTo (MergeChain *aChain,
-                            ComObjPtr <Progress> *aProgress,
-                            bool aWait)
+HRESULT HardDisk::mergeTo(MergeChain *aChain,
+                          ComObjPtr <Progress> *aProgress,
+                          bool aWait)
 {
     AssertReturn (aChain != NULL, E_FAIL);
@@ -2430 +2430 @@
 
             progress.createObject();
-            rc = progress->init (mVirtualBox, static_cast <IHardDisk2 *> (this),
+            rc = progress->init (mVirtualBox, static_cast<IHardDisk*>(this),
                 BstrFmt (tr ("Merging hard disk '%s' to '%s'"),
                          name().raw(), aChain->target()->name().raw()),
@@ -2481 +2481 @@
  * @note Locks the hard disks from the chain for writing.
  */
-void HardDisk2::cancelMergeTo (MergeChain *aChain)
+void HardDisk::cancelMergeTo (MergeChain *aChain)
 {
     AutoCaller autoCaller (this);
@@ -2514 +2514 @@
  * @note Must be called from under this object's write lock.
  */
-HRESULT HardDisk2::setLocation (CBSTR aLocation)
+HRESULT HardDisk::setLocation (CBSTR aLocation)
 {
     /// @todo so far, we assert but later it makes sense to support null
@@ -2666 +2666 @@
  * @note Must be called from under this object's write lock.
  */
-HRESULT HardDisk2::setFormat (CBSTR aFormat)
+HRESULT HardDisk::setFormat (CBSTR aFormat)
 {
     /* get the format object first */
@@ -2719 +2719 @@
  *       writing.
  */
-HRESULT HardDisk2::queryInfo()
+HRESULT HardDisk::queryInfo()
 {
     AutoWriteLock alock (this);
@@ -2873 +2873 @@
 
                     Guid id = parentId;
-                    ComObjPtr <HardDisk2> parent;
-                    rc = mVirtualBox->findHardDisk2 (&id, NULL,
-                                                     false /* aSetError */,
-                                                     &parent);
+                    ComObjPtr<HardDisk> parent;
+                    rc = mVirtualBox->findHardDisk(&id, NULL,
+                                                   false /* aSetError */,
+                                                   &parent);
                     if (FAILED (rc))
                     {
@@ -3005 +3005 @@
  * @note Locks treeLock() for reading.
  */
-HRESULT HardDisk2::canClose()
+HRESULT HardDisk::canClose()
 {
     /* we access children */
@@ -3021 +3021 @@
  * @note Called from within this object's AutoWriteLock.
  */
-HRESULT HardDisk2::canAttach (const Guid &aMachineId,
-                              const Guid &aSnapshotId)
+HRESULT HardDisk::canAttach(const Guid &aMachineId,
+                            const Guid &aSnapshotId)
 {
     if (mm.numCreateDiffTasks > 0)
@@ -3039 +3039 @@
  * @note Locks treeLock() for writing.
  */
-HRESULT HardDisk2::unregisterWithVirtualBox()
+HRESULT HardDisk::unregisterWithVirtualBox()
 {
     /* Note that we need to de-associate ourselves from the parent to let
-     * unregisterHardDisk2() properly save the registry */
+     * unregisterHardDisk() properly save the registry */
 
     /* we modify mParent and access children */
     AutoWriteLock treeLock (this->treeLock());
 
-    const ComObjPtr <HardDisk2, ComWeakRef> parent = mParent;
+    const ComObjPtr<HardDisk, ComWeakRef> parent = mParent;
 
     AssertReturn (children().size() == 0, E_FAIL);
@@ -3059 +3059 @@
     }
 
-    HRESULT rc = mVirtualBox->unregisterHardDisk2 (this);
+    HRESULT rc = mVirtualBox->unregisterHardDisk(this);
 
     if (FAILED (rc))
@@ -3098 +3098 @@
  * @param aVRC  VBox error code to use when no error message is provided.
  */
-Utf8Str HardDisk2::vdError (int aVRC)
+Utf8Str HardDisk::vdError (int aVRC)
 {
     Utf8Str error;
@@ -3127 +3127 @@
  */
 /*static*/
-DECLCALLBACK(void) HardDisk2::vdErrorCall (void *pvUser, int rc, RT_SRC_POS_DECL,
-                                           const char *pszFormat, va_list va)
-{
-    HardDisk2 *that = static_cast <HardDisk2 *> (pvUser);
+DECLCALLBACK(void) HardDisk::vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
+                                         const char *pszFormat, va_list va)
+{
+    HardDisk *that = static_cast<HardDisk*>(pvUser);
     AssertReturnVoid (that != NULL);
 
@@ -3149 +3149 @@
  */
 /*static*/
-DECLCALLBACK(int) HardDisk2::vdProgressCall (PVM /* pVM */, unsigned uPercent,
-                                             void *pvUser)
-{
-    HardDisk2 *that = static_cast <HardDisk2 *> (pvUser);
+DECLCALLBACK(int) HardDisk::vdProgressCall(PVM /* pVM */, unsigned uPercent,
+                                           void *pvUser)
+{
+    HardDisk *that = static_cast<HardDisk*>(pvUser);
     AssertReturn (that != NULL, VERR_GENERAL_FAILURE);
 
@@ -3166 +3166 @@
 
 /* static */
-DECLCALLBACK(bool) HardDisk2::vdConfigAreKeysValid (void *pvUser,
+DECLCALLBACK(bool) HardDisk::vdConfigAreKeysValid (void *pvUser,
                                                     const char *pszzValid)
 {
-    HardDisk2 *that = static_cast <HardDisk2 *> (pvUser);
+    HardDisk *that = static_cast<HardDisk*>(pvUser);
     AssertReturn (that != NULL, false);
 
@@ -3178 +3178 @@
 
 /* static */
-DECLCALLBACK(int) HardDisk2::vdConfigQuerySize (void *pvUser, const char *pszName,
-                                                size_t *pcbValue)
+DECLCALLBACK(int) HardDisk::vdConfigQuerySize(void *pvUser, const char *pszName,
+                                              size_t *pcbValue)
 {
     AssertReturn (VALID_PTR (pcbValue), VERR_INVALID_POINTER);
 
-    HardDisk2 *that = static_cast <HardDisk2 *> (pvUser);
+    HardDisk *that = static_cast<HardDisk*>(pvUser);
     AssertReturn (that != NULL, VERR_GENERAL_FAILURE);
 
@@ -3191 +3191 @@
         return VERR_CFGM_VALUE_NOT_FOUND;
 
-    /* we interpret null values as "no value" in HardDisk2 */
+    /* we interpret null values as "no value" in HardDisk */
     if (it->second.isNull())
         return VERR_CFGM_VALUE_NOT_FOUND;
@@ -3201 +3201 @@
 
 /* static */
-DECLCALLBACK(int) HardDisk2::vdConfigQuery (void *pvUser, const char *pszName,
+DECLCALLBACK(int) HardDisk::vdConfigQuery (void *pvUser, const char *pszName,
                                             char *pszValue, size_t cchValue)
 {
     AssertReturn (VALID_PTR (pszValue), VERR_INVALID_POINTER);
 
-    HardDisk2 *that = static_cast <HardDisk2 *> (pvUser);
+    HardDisk *that = static_cast<HardDisk*>(pvUser);
     AssertReturn (that != NULL, VERR_GENERAL_FAILURE);
 
@@ -3218 +3218 @@
         return VERR_CFGM_NOT_ENOUGH_SPACE;
 
-    /* we interpret null values as "no value" in HardDisk2 */
+    /* we interpret null values as "no value" in HardDisk */
     if (it->second.isNull())
         return VERR_CFGM_VALUE_NOT_FOUND;
@@ -3236 +3236 @@
  */
 /* static */
-DECLCALLBACK(int) HardDisk2::taskThread (RTTHREAD thread, void *pvUser)
+DECLCALLBACK(int) HardDisk::taskThread (RTTHREAD thread, void *pvUser)
 {
     std::auto_ptr <Task> task (static_cast <Task *> (pvUser));
@@ -3243 +3243 @@
     bool isAsync = thread != NIL_RTTHREAD;
 
-    HardDisk2 *that = task->that;
+    HardDisk *that = task->that;
 
     /// @todo ugly hack, fix ComAssert... later
@@ -3276 +3276 @@
             {
                 id.create();
-                /* VirtualBox::registerHardDisk2() will need UUID */
+                /* VirtualBox::registerHardDisk() will need UUID */
                 unconst (that->m.id) = id;
             }
@@ -3337 +3337 @@
                  * Created state only on success (leaving an orphan file is
                  * better than breaking media registry consistency) */
-                rc = that->mVirtualBox->registerHardDisk2 (that);
+                rc = that->mVirtualBox->registerHardDisk(that);
             }
 
@@ -3366 +3366 @@
         case Task::CreateDiff:
         {
-            ComObjPtr <HardDisk2> &target = task->d.target;
+            ComObjPtr<HardDisk> &target = task->d.target;
 
             /* Lock both in {parent,child} order. The lock is also used as a
@@ -3382 +3382 @@
             {
                 targetId.create();
-                /* VirtualBox::registerHardDisk2() will need UUID */
+                /* VirtualBox::registerHardDisk() will need UUID */
                 unconst (target->m.id) = targetId;
             }
@@ -3474 +3474 @@
                  * Created state only on success (leaving an orphan file is
                  * better than breaking media registry consistency) */
-                rc = that->mVirtualBox->registerHardDisk2 (target);
+                rc = that->mVirtualBox->registerHardDisk(target);
 
                 if (FAILED (rc))
@@ -3677 +3677 @@
                                            that->treeLock());
 
-                HardDisk2 *source = chain->source();
-                HardDisk2 *target = chain->target();
+                HardDisk *source = chain->source();
+                HardDisk *target = chain->target();
 
                 if (chain->isForward())
@@ -3685 +3685 @@
                      * hard disk which needs re-registration */
                     rc2 = target->mVirtualBox->
-                        unregisterHardDisk2 (target, false /* aSaveSettings */);
+                        unregisterHardDisk (target, false /* aSaveSettings */);
                     AssertComRC (rc2);
 
@@ -3706 +3706 @@
                     /* then, register again */
                     rc2 = target->mVirtualBox->
-                        registerHardDisk2 (target, false /* aSaveSettings */);
+                        registerHardDisk (target, false /* aSaveSettings */);
                     AssertComRC (rc2);
                 }
@@ -3712 +3712 @@
                 {
                     Assert (target->children().size() == 1);
-                    HardDisk2 *targetChild = target->children().front();
+                    HardDisk *targetChild = target->children().front();
 
                     /* disconnect the deleted branch at the elder end */
@@ -3757 +3757 @@
 
                         rc2 = (*it)->mVirtualBox->
-                            unregisterHardDisk2 (*it, false /* aSaveSettings */);
+                            unregisterHardDisk(*it, false /* aSaveSettings */);
                         AssertComRC (rc2);
 
@@ -3830 +3830 @@
         case Task::Clone:
         {
-            ComObjPtr <HardDisk2> &target = task->d.target;
+            ComObjPtr<HardDisk> &target = task->d.target;
 
             /* Lock both in {parent,child} order. The lock is also used as a
@@ -3846 +3846 @@
             {
                 targetId.create();
-                /* VirtualBox::registerHardDisk2() will need UUID */
+                /* VirtualBox::registerHardDisk() will need UUID */
                 unconst (target->m.id) = targetId;
             }
@@ -3941 +3941 @@
                      * Created state only on success (leaving an orphan file is
                      * better than breaking media registry consistency) */
-                    rc = that->mVirtualBox->registerHardDisk2 (target);
+                    rc = that->mVirtualBox->registerHardDisk(target);
 
                     if (FAILED (rc))
@@ -3954 +3954 @@
                 {
                     /* just register  */
-                    rc = that->mVirtualBox->registerHardDisk2 (target);
+                    rc = that->mVirtualBox->registerHardDisk(target);
                 }
             }

trunk/src/VBox/Main/HardDiskAttachmentImpl.cpp

@@ -27 +27 @@
 /////////////////////////////////////////////////////////////////////////////
 
-HRESULT HardDisk2Attachment::FinalConstruct()
+HRESULT HardDiskAttachment::FinalConstruct()
 {
     return S_OK;
 }
 
-void HardDisk2Attachment::FinalRelease()
+void HardDiskAttachment::FinalRelease()
 {
     uninit();
@@ -49 +49 @@
  * @param aImplicit Wether the attachment contains an implicitly created diff.
  */
-HRESULT HardDisk2Attachment::init (HardDisk2 *aHD, StorageBus_T aBus, LONG aChannel,
-                                   LONG aDevice, bool aImplicit /*= false*/)
+HRESULT HardDiskAttachment::init(HardDisk *aHD, StorageBus_T aBus, LONG aChannel,
+                                 LONG aDevice, bool aImplicit /*= false*/)
 {
     AssertReturn (aHD, E_INVALIDARG);
@@ -75 +75 @@
  * Called from FinalRelease().
  */
-void HardDisk2Attachment::uninit()
+void HardDiskAttachment::uninit()
 {
     /* Enclose the state transition Ready->InUninit->NotReady */
@@ -83 +83 @@
 }
 
-// IHardDisk2Attachment properties
+// IHardDiskAttachment properties
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP HardDisk2Attachment::COMGETTER(HardDisk) (IHardDisk2 **aHardDisk)
+STDMETHODIMP HardDiskAttachment::COMGETTER(HardDisk) (IHardDisk **aHardDisk)
 {
     CheckComArgOutPointerValid(aHardDisk);
@@ -100 +100 @@
 }
 
-STDMETHODIMP HardDisk2Attachment::COMGETTER(Bus) (StorageBus_T *aBus)
+STDMETHODIMP HardDiskAttachment::COMGETTER(Bus) (StorageBus_T *aBus)
 {
     CheckComArgOutPointerValid(aBus);
@@ -113 +113 @@
 }
 
-STDMETHODIMP HardDisk2Attachment::COMGETTER(Channel) (LONG *aChannel)
+STDMETHODIMP HardDiskAttachment::COMGETTER(Channel) (LONG *aChannel)
 {
     CheckComArgOutPointerValid(aChannel);
@@ -126 +126 @@
 }
 
-STDMETHODIMP HardDisk2Attachment::COMGETTER(Device) (LONG *aDevice)
+STDMETHODIMP HardDiskAttachment::COMGETTER(Device) (LONG *aDevice)
 {
     CheckComArgOutPointerValid(aDevice);

trunk/src/VBox/Main/MachineImpl.cpp

@@ -1427 +1427 @@
 
 STDMETHODIMP Machine::
-COMGETTER(HardDisk2Attachments) (ComSafeArrayOut (IHardDisk2Attachment *, aAttachments))
+COMGETTER(HardDiskAttachments) (ComSafeArrayOut(IHardDiskAttachment *, aAttachments))
 {
     if (ComSafeArrayOutIsNull (aAttachments))
@@ -1437 +1437 @@
     AutoReadLock alock (this);
 
-    SafeIfaceArray <IHardDisk2Attachment> attachments (mHDData->mAttachments);
+    SafeIfaceArray<IHardDiskAttachment> attachments (mHDData->mAttachments);
     attachments.detachTo (ComSafeArrayOutArg (aAttachments));
 
@@ -1882 +1882 @@
 }
 
-STDMETHODIMP Machine::AttachHardDisk2 (IN_GUID aId,
-                                       StorageBus_T aBus, LONG aChannel,
-                                       LONG aDevice)
+STDMETHODIMP Machine::AttachHardDisk(IN_GUID aId,
+                                     StorageBus_T aBus, LONG aChannel,
+                                     LONG aDevice)
 {
     if (aBus == StorageBus_SATA)
@@ -1934 +1934 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    /* VirtualBox::findHardDisk2() need read lock; also we want to make sure the
+    /* VirtualBox::findHardDisk() need read lock; also we want to make sure the
      * hard disk object we pick up doesn't get unregistered before we finish. */
     AutoReadLock vboxLock (mParent);
@@ -1957 +1957 @@
         std::find_if (mHDData->mAttachments.begin(),
                       mHDData->mAttachments.end(),
-                      HardDisk2Attachment::EqualsTo (aBus, aChannel, aDevice));
+                      HardDiskAttachment::EqualsTo (aBus, aChannel, aDevice));
 
     if (it != mHDData->mAttachments.end())
     {
-        ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+        ComObjPtr<HardDisk> hd = (*it)->hardDisk();
         AutoReadLock hdLock (hd);
         return setError (VBOX_E_OBJECT_IN_USE,
@@ -1972 +1972 @@
 
     /* find a hard disk by UUID */
-    ComObjPtr <HardDisk2> hd;
-    rc = mParent->findHardDisk2 (&id, NULL, true /* aSetError */, &hd);
+    ComObjPtr<HardDisk> hd;
+    rc = mParent->findHardDisk(&id, NULL, true /* aSetError */, &hd);
     CheckComRCReturnRC (rc);
 
@@ -1983 +1983 @@
     if (std::find_if (mHDData->mAttachments.begin(),
                       mHDData->mAttachments.end(),
-                      HardDisk2Attachment::RefersTo (hd)) !=
+                      HardDiskAttachment::RefersTo (hd)) !=
             mHDData->mAttachments.end())
     {
@@ -2006 +2006 @@
             HDData::AttachmentList::const_iterator it =
                 std::find_if (oldAtts.begin(), oldAtts.end(),
-                              HardDisk2Attachment::RefersTo (hd));
+                              HardDiskAttachment::RefersTo (hd));
             if (it != oldAtts.end())
             {
@@ -2060 +2060 @@
                         if (std::find_if (mHDData->mAttachments.begin(),
                                           mHDData->mAttachments.end(),
-                                          HardDisk2Attachment::RefersTo (
+                                          HardDiskAttachment::RefersTo (
                                               (*it)->hardDisk())) !=
                                 mHDData->mAttachments.end())
@@ -2099 +2099 @@
                     indirect = false;
                     associate = false;
-                    /* go right to the HardDisk2Attachment creation */
+                    /* go right to the HardDiskAttachment creation */
                     break;
                 }
@@ -2107 +2107 @@
              * hard disk's chain to base the new diff on */
 
-            ComObjPtr <HardDisk2> base;
-            ComObjPtr <Snapshot> snap = mData->mCurrentSnapshot;
+            ComObjPtr<HardDisk> base;
+            ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
             while (snap)
             {
@@ -2166 +2166 @@
         }
 
-        ComObjPtr <HardDisk2> diff;
+        ComObjPtr<HardDisk> diff;
         diff.createObject();
         rc = diff->init (mParent, hd->preferredDiffFormat(),
@@ -2205 +2205 @@
     while (0);
 
-    ComObjPtr <HardDisk2Attachment> attachment;
+    ComObjPtr<HardDiskAttachment> attachment;
     attachment.createObject();
     rc = attachment->init (hd, aBus, aChannel, aDevice, indirect);
@@ -2226 +2226 @@
 }
 
-STDMETHODIMP Machine::GetHardDisk2 (StorageBus_T aBus, LONG aChannel,
-                                    LONG aDevice, IHardDisk2 **aHardDisk)
+STDMETHODIMP Machine::GetHardDisk(StorageBus_T aBus, LONG aChannel,
+                                  LONG aDevice, IHardDisk **aHardDisk)
 {
     CheckComArgExpr (aBus, aBus != StorageBus_Null);
@@ -2242 +2242 @@
         std::find_if (mHDData->mAttachments.begin(),
                       mHDData->mAttachments.end(),
-                      HardDisk2Attachment::EqualsTo (aBus, aChannel, aDevice));
+                      HardDiskAttachment::EqualsTo (aBus, aChannel, aDevice));
 
     if (it == mHDData->mAttachments.end())
@@ -2254 +2254 @@
 }
 
-STDMETHODIMP Machine::DetachHardDisk2 (StorageBus_T aBus, LONG aChannel,
-                                       LONG aDevice)
+STDMETHODIMP Machine::DetachHardDisk(StorageBus_T aBus, LONG aChannel,
+                                     LONG aDevice)
 {
     CheckComArgExpr (aBus, aBus != StorageBus_Null);
@@ -2276 +2276 @@
         std::find_if (mHDData->mAttachments.begin(),
                       mHDData->mAttachments.end(),
-                      HardDisk2Attachment::EqualsTo (aBus, aChannel, aDevice));
+                      HardDiskAttachment::EqualsTo (aBus, aChannel, aDevice));
 
     if (it == mHDData->mAttachments.end())
@@ -2283 +2283 @@
             aDevice, aChannel, aBus);
 
-    ComObjPtr <HardDisk2Attachment> hda = *it;
-    ComObjPtr <HardDisk2> hd = hda->hardDisk();
+    ComObjPtr<HardDiskAttachment> hda = *it;
+    ComObjPtr<HardDisk> hd = hda->hardDisk();
 
     if (hda->isImplicit())
@@ -2290 +2290 @@
         /* attempt to implicitly delete the implicitly created diff */
 
-        /// @todo move the implicit flag from HardDisk2Attachment to HardDisk2
+        /// @todo move the implicit flag from HardDiskAttachment to HardDisk
         /// and forbid any hard disk operation when it is implicit. Or maybe
         /// a special media state for it to make it even more simple.
@@ -5332 +5332 @@
 
         /* find a hard disk by UUID */
-        ComObjPtr <HardDisk2> hd;
-        rc = mParent->findHardDisk2 (&uuid, NULL, true /* aDoSetError */, &hd);
+        ComObjPtr<HardDisk> hd;
+        rc = mParent->findHardDisk(&uuid, NULL, true /* aDoSetError */, &hd);
         CheckComRCReturnRC (rc);
 
@@ -5367 +5367 @@
         if (std::find_if (mHDData->mAttachments.begin(),
                           mHDData->mAttachments.end(),
-                          HardDisk2Attachment::RefersTo (hd)) !=
+                          HardDiskAttachment::RefersTo (hd)) !=
                 mHDData->mAttachments.end())
         {
@@ -5386 +5386 @@
             AssertFailedReturn (E_FAIL);
 
-        ComObjPtr <HardDisk2Attachment> attachment;
+        ComObjPtr<HardDiskAttachment> attachment;
         attachment.createObject();
         rc = attachment->init (hd, bus, channel, device);
@@ -6668 +6668 @@
          ++ it)
     {
-        ComObjPtr <HardDisk2Attachment> att = *it;
+        ComObjPtr <HardDiskAttachment> att = *it;
 
         Key hdNode = aNode.appendKey ("HardDiskAttachment");
@@ -6829 +6829 @@
     HRESULT rc = S_OK;
 
-    typedef std::list <ComObjPtr <HardDisk2> > LockedMedia;
+    typedef std::list< ComObjPtr<HardDisk> > LockedMedia;
     LockedMedia lockedMedia;
 
@@ -6843 +6843 @@
                  ++ it)
             {
-                ComObjPtr <HardDisk2Attachment> hda = *it;
-                ComObjPtr <HardDisk2> hd = hda->hardDisk();
+                ComObjPtr<HardDiskAttachment> hda = *it;
+                ComObjPtr<HardDisk> hd = hda->hardDisk();
 
                 rc = hd->LockRead (NULL);
@@ -6866 +6866 @@
              it = atts.begin(); it != atts.end(); ++ it)
         {
-            ComObjPtr <HardDisk2Attachment> hda = *it;
-            ComObjPtr <HardDisk2> hd = hda->hardDisk();
+            ComObjPtr<HardDiskAttachment> hda = *it;
+            ComObjPtr<HardDisk> hd = hda->hardDisk();
 
             /* type cannot be changed while attached => no need to lock */
@@ -6892 +6892 @@
             CheckComRCThrowRC (rc);
 
-            ComObjPtr <HardDisk2> diff;
+            ComObjPtr<HardDisk> diff;
             diff.createObject();
             rc = diff->init (mParent, hd->preferredDiffFormat(),
@@ -6912 +6912 @@
 
             /* add a new attachment */
-            ComObjPtr <HardDisk2Attachment> attachment;
+            ComObjPtr<HardDiskAttachment> attachment;
             attachment.createObject();
             rc = attachment->init (diff, hda->bus(), hda->channel(),
@@ -6948 +6948 @@
 /**
  * Deletes implicit differencing hard disks created either by
- * #createImplicitDiffs() or by #AttachHardDisk2() and rolls back mHDData.
- *
- * Note that to delete hard disks created by #AttachHardDisk2() this method is
- * called from #fixupHardDisks2() when the changes are rolled back.
+ * #createImplicitDiffs() or by #AttachHardDisk() and rolls back mHDData.
+ *
+ * Note that to delete hard disks created by #AttachHardDisk() this method is
+ * called from #fixupHardDisks() when the changes are rolled back.
  *
  * @note Locks this object for writing.
@@ -6976 +6976 @@
          it != mHDData->mAttachments.end(); ++ it)
     {
-        ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+        ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
         if ((*it)->isImplicit())
@@ -6989 +6989 @@
         /* was this hard disk attached before? */
         HDData::AttachmentList::const_iterator oldIt =
-            std::find_if (oldAtts.begin(), oldAtts.end(),
-                          HardDisk2Attachment::RefersTo (hd));
+            std::find_if(oldAtts.begin(), oldAtts.end(),
+                         HardDiskAttachment::RefersTo (hd));
         if (oldIt == oldAtts.end())
         {
@@ -7024 +7024 @@
              it != implicitAtts.end(); ++ it)
         {
-            ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+            ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
             mrc = hd->deleteStorageAndWait();
@@ -7060 +7060 @@
  * @note Locks this object for writing!
  */
-void Machine::fixupHardDisks2 (bool aCommit, bool aOnline /*= false*/)
+void Machine::fixupHardDisks(bool aCommit, bool aOnline /*= false*/)
 {
     AutoCaller autoCaller (this);
@@ -7083 +7083 @@
              it != mHDData->mAttachments.end(); ++ it)
         {
-            ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+            ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
             if ((*it)->isImplicit())
@@ -7098 +7098 @@
                      * new diff for reading if the VM is online */
 
-                    ComObjPtr <HardDisk2> parent = hd->parent();
+                    ComObjPtr<HardDisk> parent = hd->parent();
                     /* make the relock atomic */
                     AutoWriteLock parentLock (parent);
@@ -7113 +7113 @@
             HDData::AttachmentList::iterator oldIt =
                 std::find_if (oldAtts.begin(), oldAtts.end(),
-                              HardDisk2Attachment::RefersTo (hd));
+                              HardDiskAttachment::RefersTo (hd));
             if (oldIt != oldAtts.end())
             {
@@ -7126 +7126 @@
              it != oldAtts.end(); ++ it)
         {
-            ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+            ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
             /* now de-associate from the current machine state */
@@ -7376 +7376 @@
 
     if (mHDData.isBackedUp())
-        fixupHardDisks2 (false /* aCommit */);
+        fixupHardDisks(false /* aCommit */);
 
     /* check for changes in child objects */
@@ -7481 +7481 @@
 
     if (mHDData.isBackedUp())
-        fixupHardDisks2 (true /* aCommit */);
+        fixupHardDisks(true /* aCommit */);
 
     mBIOSSettings->commit();
@@ -7505 +7505 @@
         mPeer->mUserData.attach (mUserData);
         mPeer->mHWData.attach (mHWData);
-        /* mHDData is reshared by fixupHardDisks2 */
+        /* mHDData is reshared by fixupHardDisks */
         // mPeer->mHDData.attach (mHDData);
         Assert (mPeer->mHDData.data() == mHDData.data());
@@ -8482 +8482 @@
          ++ it)
     {
-        ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+        ComObjPtr <HardDisk> hd = (*it)->hardDisk();
         AutoReadLock hdLock (hd);
         if (hd->type() == HardDiskType_Writethrough)
@@ -9499 +9499 @@
 
         /* associate old hard disks with the snapshot and do locking/unlocking*/
-        fixupHardDisks2 (true /* aCommit */, online);
+        fixupHardDisks(true /* aCommit */, online);
 
         /* inform callbacks */
@@ -9514 +9514 @@
         /* delete all differencing hard disks created (this will also attach
          * their parents back by rolling back mHDData) */
-        fixupHardDisks2 (false /* aCommit */);
+        fixupHardDisks(false /* aCommit */);
 
         /* delete the saved state file (it might have been already created) */
@@ -9642 +9642 @@
     HardDiskDiscardRec() : chain (NULL) {}
 
-    HardDiskDiscardRec (const ComObjPtr <HardDisk2> &aHd,
-                HardDisk2::MergeChain *aChain = NULL)
+    HardDiskDiscardRec (const ComObjPtr<HardDisk> &aHd,
+                HardDisk::MergeChain *aChain = NULL)
         : hd (aHd), chain (aChain) {}
 
-    HardDiskDiscardRec (const ComObjPtr <HardDisk2> &aHd,
-                        HardDisk2::MergeChain *aChain,
-                        const ComObjPtr <HardDisk2> &aReplaceHd,
-                        const ComObjPtr <HardDisk2Attachment> &aReplaceHda,
+    HardDiskDiscardRec (const ComObjPtr<HardDisk> &aHd,
+                        HardDisk::MergeChain *aChain,
+                        const ComObjPtr<HardDisk> &aReplaceHd,
+                        const ComObjPtr<HardDiskAttachment> &aReplaceHda,
                         const Guid &aSnapshotId)
         : hd (aHd), chain (aChain)
@@ -9655 +9655 @@
         , snapshotId (aSnapshotId) {}
 
-    ComObjPtr <HardDisk2> hd;
-    HardDisk2::MergeChain *chain;
+    ComObjPtr<HardDisk> hd;
+    HardDisk::MergeChain *chain;
     /* these are for the replace hard disk case: */
-    ComObjPtr <HardDisk2> replaceHd;
-    ComObjPtr <HardDisk2Attachment> replaceHda;
+    ComObjPtr<HardDisk> replaceHd;
+    ComObjPtr<HardDiskAttachment> replaceHda;
     Guid snapshotId;
 };
@@ -9729 +9729 @@
              ++ it)
         {
-            ComObjPtr <HardDisk2Attachment> hda = *it;
-            ComObjPtr <HardDisk2> hd = hda->hardDisk();
-
-            /* HardDisk2::prepareDiscard() reqiuires a write lock */
+            ComObjPtr<HardDiskAttachment> hda = *it;
+            ComObjPtr<HardDisk> hd = hda->hardDisk();
+
+            /* HardDisk::prepareDiscard() reqiuires a write lock */
             AutoWriteLock hdLock (hd);
 
@@ -9749 +9749 @@
             }
 
-            HardDisk2::MergeChain *chain = NULL;
+            HardDisk::MergeChain *chain = NULL;
 
             /* needs to be discarded (merged with the child if any), check
@@ -9766 +9766 @@
 
                 /* The below assert would be nice but I don't want to move
-                 * HardDisk2::MergeChain to the header just for that
+                 * HardDisk::MergeChain to the header just for that
                  * Assert (!chain->isForward()); */
 
                 Assert (hd->children().size() == 1);
 
-                ComObjPtr <HardDisk2> replaceHd = hd->children().front();
+                ComObjPtr<HardDisk> replaceHd = hd->children().front();
 
                 Assert (replaceHd->backRefs().front().machineId == mData->mUuid);
@@ -9796 +9796 @@
                     it = std::find_if (mHDData->mAttachments.begin(),
                                        mHDData->mAttachments.end(),
-                                       HardDisk2Attachment::RefersTo (replaceHd));
+                                       HardDiskAttachment::RefersTo (replaceHd));
                     AssertBreak (it != mHDData->mAttachments.end());
                 }
@@ -9811 +9811 @@
                     it = std::find_if (snapAtts.begin(),
                                        snapAtts.end(),
-                                       HardDisk2Attachment::RefersTo (replaceHd));
+                                       HardDiskAttachment::RefersTo (replaceHd));
                     AssertBreak (it != snapAtts.end());
                 }
@@ -10171 +10171 @@
          * become unused and need to be auto-deleted */
 
-        std::list <ComObjPtr <HardDisk2> > diffs;
+        std::list< ComObjPtr<HardDisk> > diffs;
 
         for (HDData::AttachmentList::const_iterator
@@ -10177 +10177 @@
              it != mHDData.backedUpData()->mAttachments.end(); ++ it)
         {
-            ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+            ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
             /* while the hard disk is attached, the number of children or the
@@ -10196 +10196 @@
              * may fail otherwise (too many children of the hard disk to be
              * discarded) */
-            for (std::list <ComObjPtr <HardDisk2> >::const_iterator
+            for (std::list< ComObjPtr<HardDisk> >::const_iterator
                  it = diffs.begin(); it != diffs.end(); ++ it)
             {
@@ -10273 +10273 @@
         {
             /* now, delete the unused diffs (only on success!) and uninit them*/
-            for (std::list <ComObjPtr <HardDisk2> >::const_iterator
+            for (std::list< ComObjPtr<HardDisk> >::const_iterator
                  it = diffs.begin(); it != diffs.end(); ++ it)
             {
@@ -10378 +10378 @@
              it != mHDData->mAttachments.end(); ++ it)
         {
-            ComObjPtr <HardDisk2> hd = (*it)->hardDisk();
+            ComObjPtr<HardDisk> hd = (*it)->hardDisk();
 
             bool first = true;

trunk/src/VBox/Main/MediumImpl.cpp

@@ -1111 +1111 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-// FloppyImage2 class
-////////////////////////////////////////////////////////////////////////////////
-
-DEFINE_EMPTY_CTOR_DTOR (FloppyImage2)
+// FloppyImage class
+////////////////////////////////////////////////////////////////////////////////
+
+DEFINE_EMPTY_CTOR_DTOR (FloppyImage)
 
 /**
@@ -1120 +1120 @@
  *       mVirtualBox write lock.
  */
-HRESULT FloppyImage2::unregisterWithVirtualBox()
+HRESULT FloppyImage::unregisterWithVirtualBox()
 {
     return mVirtualBox->unregisterFloppyImage (this);

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -53 +53 @@
 #include "Global.h"
 #include "MachineImpl.h"
-#include "HardDisk2Impl.h"
+#include "HardDiskImpl.h"
 #include "MediumImpl.h"
 #include "SharedFolderImpl.h"
@@ -387 +387 @@
     uninitDependentChildren();
 
-    mData.mHardDisk2Map.clear();
-
-    mData.mFloppyImages2.clear();
-    mData.mDVDImages2.clear();
-    mData.mHardDisks2.clear();
+    mData.mHardDiskMap.clear();
+
+    mData.mFloppyImages.clear();
+    mData.mDVDImages.clear();
+    mData.mHardDisks.clear();
 
     mData.mProgressOperations.clear();
@@ -401 +401 @@
      * some resources of the singletons which would prevent them from
      * uninitializing (as for example, mSystemProperties which owns
-     * HardDiskFormat objects which HardDisk2 objects refer to) */
+     * HardDiskFormat objects which HardDisk objects refer to) */
     if (mData.mSystemProperties)
     {
@@ -626 +626 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(HardDisks2) (ComSafeArrayOut (IHardDisk2 *, aHardDisks))
+STDMETHODIMP VirtualBox::COMGETTER(HardDisks) (ComSafeArrayOut (IHardDisk *, aHardDisks))
 {
     if (ComSafeArrayOutIsNull (aHardDisks))
@@ -636 +636 @@
     AutoReadLock alock (this);
 
-    SafeIfaceArray <IHardDisk2> hardDisks (mData.mHardDisks2);
+    SafeIfaceArray<IHardDisk> hardDisks (mData.mHardDisks);
     hardDisks.detachTo (ComSafeArrayOutArg (aHardDisks));
 
@@ -653 +653 @@
     AutoReadLock alock (this);
 
-    SafeIfaceArray <IDVDImage> images (mData.mDVDImages2);
+    SafeIfaceArray <IDVDImage> images (mData.mDVDImages);
     images.detachTo (ComSafeArrayOutArg (aDVDImages));
 
@@ -660 +660 @@
 
 STDMETHODIMP
-VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages))
+VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut(IFloppyImage *, aFloppyImages))
 {
     if (ComSafeArrayOutIsNull (aFloppyImages))
@@ -670 +670 @@
     AutoReadLock alock (this);
 
-    SafeIfaceArray <IFloppyImage2> images (mData.mFloppyImages2);
+    SafeIfaceArray<IFloppyImage> images (mData.mFloppyImages);
     images.detachTo (ComSafeArrayOutArg (aFloppyImages));
 
@@ -1063 +1063 @@
 }
 
-STDMETHODIMP VirtualBox::CreateHardDisk2 (IN_BSTR aFormat,
-                                          IN_BSTR aLocation,
-                                          IHardDisk2 **aHardDisk)
+STDMETHODIMP VirtualBox::CreateHardDisk(IN_BSTR aFormat,
+                                        IN_BSTR aLocation,
+                                        IHardDisk **aHardDisk)
 {
     CheckComArgStrNotEmptyOrNull (aFormat);
@@ -1084 +1084 @@
     HRESULT rc = E_FAIL;
 
-    ComObjPtr <HardDisk2> hardDisk;
+    ComObjPtr<HardDisk> hardDisk;
     hardDisk.createObject();
     rc = hardDisk->init (this, format, aLocation);
@@ -1094 +1094 @@
 }
 
-STDMETHODIMP VirtualBox::OpenHardDisk2 (IN_BSTR aLocation,
-                                        IHardDisk2 **aHardDisk)
+STDMETHODIMP VirtualBox::OpenHardDisk(IN_BSTR aLocation,
+                                      IHardDisk **aHardDisk)
 {
     CheckComArgNotNull(aLocation);
@@ -1107 +1107 @@
     HRESULT rc = E_FAIL;
 
-    ComObjPtr <HardDisk2> hardDisk;
+    ComObjPtr<HardDisk> hardDisk;
     hardDisk.createObject();
     rc = hardDisk->init (this, aLocation);
@@ -1113 +1113 @@
     if (SUCCEEDED (rc))
     {
-        rc = registerHardDisk2 (hardDisk);
+        rc = registerHardDisk (hardDisk);
 
         /* Note that it's important to call uninit() on failure to register
@@ -1128 +1128 @@
 }
 
-STDMETHODIMP VirtualBox::GetHardDisk2 (IN_GUID aId,
-                                       IHardDisk2 **aHardDisk)
+STDMETHODIMP VirtualBox::GetHardDisk(IN_GUID aId,
+                                     IHardDisk **aHardDisk)
 {
     CheckComArgOutSafeArrayPointerValid(aHardDisk);
@@ -1137 +1137 @@
 
     Guid id = aId;
-    ComObjPtr <HardDisk2> hardDisk;
-    HRESULT rc = findHardDisk2 (&id, NULL, true /* setError */, &hardDisk);
+    ComObjPtr<HardDisk> hardDisk;
+    HRESULT rc = findHardDisk(&id, NULL, true /* setError */, &hardDisk);
 
     /* the below will set *aHardDisk to NULL if hardDisk is null */
@@ -1146 +1146 @@
 }
 
-STDMETHODIMP VirtualBox::FindHardDisk2 (IN_BSTR aLocation,
-                                        IHardDisk2 **aHardDisk)
+STDMETHODIMP VirtualBox::FindHardDisk(IN_BSTR aLocation,
+                                      IHardDisk **aHardDisk)
 {
     CheckComArgNotNull(aLocation);
@@ -1155 +1155 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    ComObjPtr <HardDisk2> hardDisk;
-    HRESULT rc = findHardDisk2 (NULL, aLocation, true /* setError */, &hardDisk);
+    ComObjPtr<HardDisk> hardDisk;
+    HRESULT rc = findHardDisk(NULL, aLocation, true /* setError */, &hardDisk);
 
     /* the below will set *aHardDisk to NULL if hardDisk is null */
@@ -1233 +1233 @@
 /** @note Doesn't lock anything. */
 STDMETHODIMP VirtualBox::OpenFloppyImage (IN_BSTR aLocation, IN_GUID aId,
-                                          IFloppyImage2 **aFloppyImage)
+                                          IFloppyImage **aFloppyImage)
 {
     CheckComArgStrNotEmptyOrNull(aLocation);
@@ -1248 +1248 @@
         id.create();
 
-    ComObjPtr <FloppyImage2> image;
+    ComObjPtr<FloppyImage> image;
     image.createObject();
     rc = image->init (this, aLocation, id);
@@ -1264 +1264 @@
 /** @note Locks objects! */
 STDMETHODIMP VirtualBox::GetFloppyImage (IN_GUID aId,
-                                         IFloppyImage2 **aFloppyImage)
+                                         IFloppyImage **aFloppyImage)
 
 {
@@ -1273 +1273 @@
 
     Guid id = aId;
-    ComObjPtr <FloppyImage2> image;
-    HRESULT rc = findFloppyImage2 (&id, NULL, true /* setError */, &image);
+    ComObjPtr<FloppyImage> image;
+    HRESULT rc = findFloppyImage (&id, NULL, true /* setError */, &image);
 
     /* the below will set *aFloppyImage to NULL if image is null */
@@ -1284 +1284 @@
 /** @note Locks objects! */
 STDMETHODIMP VirtualBox::FindFloppyImage (IN_BSTR aLocation,
-                                          IFloppyImage2 **aFloppyImage)
+                                          IFloppyImage **aFloppyImage)
 {
     CheckComArgNotNull(aLocation);
@@ -1292 +1292 @@
     CheckComRCReturnRC (autoCaller.rc());
 
-    ComObjPtr <FloppyImage2> image;
-    HRESULT rc = findFloppyImage2 (NULL, aLocation, true /* setError */, &image);
+    ComObjPtr<FloppyImage> image;
+    HRESULT rc = findFloppyImage(NULL, aLocation, true /* setError */, &image);
 
     /* the below will set *aFloppyImage to NULL if img is null */
@@ -2635 +2635 @@
  */
 HRESULT VirtualBox::
-findHardDisk2 (const Guid *aId, CBSTR aLocation,
-               bool aSetError, ComObjPtr <HardDisk2> *aHardDisk /*= NULL*/)
+findHardDisk(const Guid *aId, CBSTR aLocation,
+             bool aSetError, ComObjPtr<HardDisk> *aHardDisk /*= NULL*/)
 {
     AssertReturn (aId || aLocation, E_INVALIDARG);
@@ -2645 +2645 @@
     if (aId)
     {
-        HardDisk2Map::const_iterator it = mData.mHardDisk2Map.find (*aId);
-        if (it != mData.mHardDisk2Map.end())
+        HardDiskMap::const_iterator it = mData.mHardDiskMap.find (*aId);
+        if (it != mData.mHardDiskMap.end())
         {
             if (aHardDisk)
@@ -2660 +2660 @@
         Utf8Str location = aLocation;
 
-        for (HardDisk2Map::const_iterator it = mData.mHardDisk2Map.begin();
-             it != mData.mHardDisk2Map.end();
+        for (HardDiskMap::const_iterator it = mData.mHardDiskMap.begin();
+             it != mData.mHardDiskMap.end();
              ++ it)
         {
-            const ComObjPtr <HardDisk2> &hd = (*it).second;
+            const ComObjPtr<HardDisk> &hd = (*it).second;
 
             HRESULT rc = hd->compareLocationTo (location, result);
@@ -2731 +2731 @@
     bool found = false;
 
-    for (DVDImageList::const_iterator it = mData.mDVDImages2.begin();
-         it != mData.mDVDImages2.end();
+    for (DVDImageList::const_iterator it = mData.mDVDImages.begin();
+         it != mData.mDVDImages.end();
          ++ it)
     {
@@ -2767 +2767 @@
 
 /**
- * Searches for a FloppyImage2 object with the given ID or location in the
+ * Searches for a FloppyImage object with the given ID or location in the
  * collection of registered DVD images. If both ID and file path are specified,
  * the first object that matches either of them (not necessarily both) is
@@ -2782 +2782 @@
  * @note Locks this object and image objects for reading.
  */
-HRESULT VirtualBox::findFloppyImage2 (const Guid *aId, CBSTR aLocation,
-                                      bool aSetError,
-                                      ComObjPtr <FloppyImage2> *aImage /* = NULL */)
+HRESULT VirtualBox::findFloppyImage(const Guid *aId, CBSTR aLocation,
+                                    bool aSetError,
+                                    ComObjPtr<FloppyImage> *aImage /* = NULL */)
 {
     AssertReturn (aId || aLocation, E_INVALIDARG);
@@ -2803 +2803 @@
     bool found = false;
 
-    for (FloppyImage2List::const_iterator it = mData.mFloppyImages2.begin();
-         it != mData.mFloppyImages2.end();
+    for (FloppyImageList::const_iterator it = mData.mFloppyImages.begin();
+         it != mData.mFloppyImages.end();
          ++ it)
     {
@@ -2925 +2925 @@
 
     {
-        ComObjPtr <HardDisk2> hardDisk;
-        rc = findHardDisk2 (&aId, aLocation, false /* aSetError */, &hardDisk);
+        ComObjPtr<HardDisk> hardDisk;
+        rc = findHardDisk(&aId, aLocation, false /* aSetError */, &hardDisk);
         if (SUCCEEDED (rc))
         {
@@ -2953 +2953 @@
 
     {
-        ComObjPtr <FloppyImage2> image;
-        rc = findFloppyImage2 (&aId, aLocation, false /* aSetError */, &image);
+        ComObjPtr<FloppyImage> image;
+        rc = findFloppyImage(&aId, aLocation, false /* aSetError */, &image);
         if (SUCCEEDED (rc))
         {
@@ -3047 +3047 @@
                  it != hardDisks.end(); ++ it)
             {
-                ComObjPtr <HardDisk2> hardDisk;
+                ComObjPtr<HardDisk> hardDisk;
                 hardDisk.createObject();
                 rc = hardDisk->init (this, NULL, *it);
                 CheckComRCBreakRC (rc);
 
-                rc = registerHardDisk2 (hardDisk, false /* aSaveRegistry */);
+                rc = registerHardDisk(hardDisk, false /* aSaveRegistry */);
                 CheckComRCBreakRC (rc);
             }
@@ -3081 +3081 @@
                 case 2: /* FloppyImages */
                 {
-                    ComObjPtr <FloppyImage2> image;
+                    ComObjPtr<FloppyImage> image;
                     image.createObject();
                     rc = image->init (this, *it);
@@ -3168 +3168 @@
                 Key hardDisksNode = registryNode.createKey ("HardDisks");
 
-                for (HardDisk2List::const_iterator it =
-                        mData.mHardDisks2.begin();
-                     it != mData.mHardDisks2.end();
+                for (HardDiskList::const_iterator it =
+                        mData.mHardDisks.begin();
+                     it != mData.mHardDisks.end();
                      ++ it)
                 {
@@ -3183 +3183 @@
 
                 for (DVDImageList::const_iterator it =
-                        mData.mDVDImages2.begin();
-                     it != mData.mDVDImages2.end();
+                        mData.mDVDImages.begin();
+                     it != mData.mDVDImages.end();
                      ++ it)
                 {
@@ -3196 +3196 @@
                 Key imagesNode = registryNode.createKey ("FloppyImages");
 
-                for (FloppyImage2List::const_iterator it =
-                        mData.mFloppyImages2.begin();
-                     it != mData.mFloppyImages2.end();
+                for (FloppyImageList::const_iterator it =
+                        mData.mFloppyImages.begin();
+                     it != mData.mFloppyImages.end();
                      ++ it)
                 {
@@ -3307 +3307 @@
  * @note Locks this object for writing and @a aHardDisk for reading.
  */
-HRESULT VirtualBox::registerHardDisk2 (HardDisk2 *aHardDisk,
-                                       bool aSaveRegistry /*= true*/)
+HRESULT VirtualBox::registerHardDisk(HardDisk *aHardDisk,
+                                     bool aSaveRegistry /*= true*/)
 {
     AssertReturn (aHardDisk != NULL, E_INVALIDARG);
@@ -3340 +3340 @@
     {
         /* base (root) hard disk */
-        mData.mHardDisks2.push_back (aHardDisk);
-    }
-
-    mData.mHardDisk2Map
-        .insert (HardDisk2Map::value_type (
-            aHardDisk->id(), HardDisk2Map::mapped_type (aHardDisk)));
+        mData.mHardDisks.push_back (aHardDisk);
+    }
+
+    mData.mHardDiskMap
+        .insert (HardDiskMap::value_type (
+            aHardDisk->id(), HardDiskMap::mapped_type (aHardDisk)));
 
     if (aSaveRegistry)
@@ -3351 +3351 @@
         rc = saveSettings();
         if (FAILED (rc))
-            unregisterHardDisk2 (aHardDisk, false /* aSaveRegistry */);
+            unregisterHardDisk(aHardDisk, false /* aSaveRegistry */);
     }
 
@@ -3372 +3372 @@
  * @note Locks this object for writing and @a aHardDisk for reading.
  */
-HRESULT VirtualBox::unregisterHardDisk2 (HardDisk2 *aHardDisk,
-                                         bool aSaveRegistry /*= true*/)
+HRESULT VirtualBox::unregisterHardDisk(HardDisk *aHardDisk,
+                                       bool aSaveRegistry /*= true*/)
 {
     AssertReturn (aHardDisk != NULL, E_INVALIDARG);
@@ -3387 +3387 @@
     AutoReadLock hardDiskLock (aHardDisk);
 
-    size_t cnt = mData.mHardDisk2Map.erase (aHardDisk->id());
+    size_t cnt = mData.mHardDiskMap.erase (aHardDisk->id());
     Assert (cnt == 1);
 
@@ -3393 +3393 @@
     {
         /* base (root) hard disk */
-        mData.mHardDisks2.remove (aHardDisk);
+        mData.mHardDisks.remove (aHardDisk);
     }
 
@@ -3402 +3402 @@
         rc = saveSettings();
         if (FAILED (rc))
-            registerHardDisk2 (aHardDisk, false /* aSaveRegistry */);
+            registerHardDisk(aHardDisk, false /* aSaveRegistry */);
     }
 
@@ -3453 +3453 @@
 
     /* add to the collection */
-    mData.mDVDImages2.push_back (aImage);
+    mData.mDVDImages.push_back (aImage);
 
     if (aSaveRegistry)
@@ -3495 +3495 @@
     AutoReadLock imageLock (aImage);
 
-    mData.mDVDImages2.remove (aImage);
+    mData.mDVDImages.remove (aImage);
 
     HRESULT rc = S_OK;
@@ -3524 +3524 @@
  * @note Locks this object for writing and @a aImage for reading.
  */
-HRESULT VirtualBox::registerFloppyImage (FloppyImage2 *aImage,
-                                         bool aSaveRegistry /*= true*/)
+HRESULT VirtualBox::registerFloppyImage(FloppyImage *aImage,
+                                        bool aSaveRegistry /*= true*/)
 {
     AssertReturn (aImage != NULL, E_INVALIDARG);
@@ -3554 +3554 @@
 
     /* add to the collection */
-    mData.mFloppyImages2.push_back (aImage);
+    mData.mFloppyImages.push_back (aImage);
 
     if (aSaveRegistry)
@@ -3581 +3581 @@
  * @note Locks this object for writing and @a aImage for reading.
  */
-HRESULT VirtualBox::unregisterFloppyImage (FloppyImage2 *aImage,
-                                           bool aSaveRegistry /*= true*/)
+HRESULT VirtualBox::unregisterFloppyImage(FloppyImage *aImage,
+                                          bool aSaveRegistry /*= true*/)
 {
     AssertReturn (aImage != NULL, E_INVALIDARG);
@@ -3596 +3596 @@
     AutoReadLock imageLock (aImage);
 
-    mData.mFloppyImages2.remove (aImage);
+    mData.mFloppyImages.remove (aImage);
 
     HRESULT rc = S_OK;
@@ -3620 +3620 @@
  * @note Locks #childrenLock() for reading.
  */
-HRESULT VirtualBox::cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo)
+HRESULT VirtualBox::cast (IHardDisk *aFrom, ComObjPtr <HardDisk> &aTo)
 {
     AssertReturn (aFrom != NULL, E_INVALIDARG);
@@ -3639 +3639 @@
      * implementations of IHardDisk can be among our children */
 
-    aTo = static_cast <HardDisk2 *> (child);
+    aTo = static_cast<HardDisk*>(child);
 
     return S_OK;
@@ -3667 +3667 @@
 
     /* check DVD paths */
-    for (DVDImageList::iterator it = mData.mDVDImages2.begin();
-         it != mData.mDVDImages2.end();
+    for (DVDImageList::iterator it = mData.mDVDImages.begin();
+         it != mData.mDVDImages.end();
          ++ it)
     {
@@ -3675 +3675 @@
 
     /* check Floppy paths */
-    for (FloppyImage2List::iterator it = mData.mFloppyImages2.begin();
-         it != mData.mFloppyImages2.end();
+    for (FloppyImageList::iterator it = mData.mFloppyImages.begin();
+         it != mData.mFloppyImages  .end();
          ++ it)
     {
@@ -3683 +3683 @@
 
     /* check HardDisk paths */
-    for (HardDisk2List::const_iterator it = mData.mHardDisks2.begin();
-         it != mData.mHardDisks2.end();
+    for (HardDiskList::const_iterator it = mData.mHardDisks.begin();
+         it != mData.mHardDisks.end();
          ++ it)
     {

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -437 +437 @@
 
       The first diagram shows what happens when a lengthy setup operation is
-      being executed (such as <link to="IMachine::attachHardDisk2"/>).
+      being executed (such as <link to="IMachine::attachHardDisk"/>).
 
       <pre>
@@ -1111 +1111 @@
         <li><link to="DeviceType_HardDisk"/>: the media is a hard disk
         that, if registered, can be obtained using the
-        <link to="IVirtualBox::getHardDisk2"/> call.</li>
+        <link to="IVirtualBox::getHardDisk"/> call.</li>
         <li><link to="DeviceType_DVD"/>: the media is a CD/DVD image
         that, if registered, can be obtained using the
@@ -1385 +1385 @@
     </attribute>
 
-    <attribute name="hardDisks2" type="IHardDisk2" readonly="yes" safearray="yes">
+    <attribute name="hardDisks" type="IHardDisk" readonly="yes" safearray="yes">
       <desc>
         Array of hard disk objects known to this VirtualBox installation.
@@ -1391 +1391 @@
         This array contains only base (root) hard disks. All differencing
         hard disks of the given base hard disk can be enumerated using
-        <link to="IHardDisk2::children"/>.
+        <link to="IHardDisk::children"/>.
       </desc>
     </attribute>
@@ -1401 +1401 @@
     </attribute>
 
-    <attribute name="floppyImages" type="IFloppyImage2" readonly="yes" safearray="yes">
+    <attribute name="floppyImages" type="IFloppyImage" readonly="yes" safearray="yes">
       <desc>
         Array of floppy image objects registered with this VirtualBox instance.
@@ -1738 +1738 @@
     </method>
 
-    <method name="createHardDisk2">
+    <method name="createHardDisk">
       <desc>
         Creates a new base hard disk object that will use the given storage
@@ -1748 +1748 @@
         allocate a format-specific storage unit at the specified location:
         <ul>
-          <li><link to="IHardDisk2::createDynamicStorage"/></li>
-          <li><link to="IHardDisk2::createFixedStorage"/></li>
-          <li><link to="IHardDisk2::createDiffStorage"/></li>
+          <li><link to="IHardDisk::createDynamicStorage"/></li>
+          <li><link to="IHardDisk::createFixedStorage"/></li>
+          <li><link to="IHardDisk::createDiffStorage"/></li>
         </ul>
 
-        Some hard disk attributes, such as <link to="IHardDisk2::id"/>, may
+        Some hard disk attributes, such as <link to="IHardDisk::id"/>, may
         remain uninitialized until the hard disk storage unit is successfully
         created by one of the above methods.
@@ -1759 +1759 @@
         After the storage unit is successfully created, the hard disk gets
         remembered by this VirtualBox installation and will be accessible
-        through <link to="#getHardDisk2"/> and <link to="#findHardDisk2"/>
+        through <link to="#getHardDisk"/> and <link to="#findHardDisk"/>
         methods. Remembered root (base) hard disks are also returned as part of
-        the <link to="#hardDisks2"/> array. See IHardDisk2 for more details.
+        the <link to="#hardDisks"/> array. See IHardDisk for more details.
 
         The list of all storage formats supported by this VirtualBox
@@ -1771 +1771 @@
 
         Note that the format of the location string is storage format specific.
-        See <link to="IMedium::location"/>, IHardDisk2 and
+        See <link to="IMedium::location"/>, IHardDisk and
         <link to="ISystemProperties::defaultHardDiskFolder"/> for more details.
 
@@ -1795 +1795 @@
         </desc>
       </param>
-      <param name="hardDisk" type="IHardDisk2" dir="return">
+      <param name="hardDisk" type="IHardDisk" dir="return">
         <desc>Created hard disk object.</desc>
       </param>
     </method>
 
-    <method name="openHardDisk2">
+    <method name="openHardDisk">
       <desc>
         Opens a hard disk from an existing location.
@@ -1806 +1806 @@
         After the hard disk is successfully opened by this method, it gets
         remembered by (known to) this VirtualBox installation and will be
-        accessible through <link to="#getHardDisk2"/> and
-        <link to="#findHardDisk2"/> methods. Remembered root (base) hard disks
-        are also returned as part of the <link to="#hardDisks2"/> array and can
-        be attached to virtual machines. See IHardDisk2 for more details.
+        accessible through <link to="#getHardDisk"/> and
+        <link to="#findHardDisk"/> methods. Remembered root (base) hard disks
+        are also returned as part of the <link to="#hardDisks"/> array and can
+        be attached to virtual machines. See IHardDisk for more details.
 
         If a differencing hard disk is to be opened by this method, the
@@ -1820 +1820 @@
 
         Note that the format of the location string is storage format specific.
-        See <link to="IMedium::location"/>, IHardDisk2 and
+        See <link to="IMedium::location"/>, IHardDisk and
         <link to="ISystemProperties::defaultHardDiskFolder"/> for more details.
 
@@ -1841 +1841 @@
         </desc>
       </param>
-      <param name="hardDisk" type="IHardDisk2" dir="return">
+      <param name="hardDisk" type="IHardDisk" dir="return">
         <desc>Opened hard disk object.</desc>
       </param>
     </method>
 
-    <method name="getHardDisk2" const="yes">
+    <method name="getHardDisk" const="yes">
       <desc>
         Returns a hard disk with the given UUID.
@@ -1852 +1852 @@
         The hard disk with the given UUID must be known to this VirtualBox
         installation, i.e. it must be previously created by
-        <link to="#createHardDisk2"/> or opened by <link
-        to="#openHardDisk2"/>, or attached to some known virtual machine.
+        <link to="#createHardDisk"/> or opened by <link
+        to="#openHardDisk"/>, or attached to some known virtual machine.
 
         <result name="VBOX_E_OBJECT_NOT_FOUND">
@@ -1863 +1863 @@
         <desc>UUID of the hard disk to look for.</desc>
       </param>
-      <param name="hardDisk" type="IHardDisk2" dir="return">
+      <param name="hardDisk" type="IHardDisk" dir="return">
         <desc>Found hard disk object.</desc>
       </param>
     </method>
 
-    <method name="findHardDisk2">
+    <method name="findHardDisk">
       <desc>
         Returns a hard disk that uses the given location to store hard
@@ -1875 +1875 @@
         The given hard disk must be known to this VirtualBox installation, i.e.
         it must be previously created by
-        <link to="#createHardDisk2"/> or opened by <link
-        to="#openHardDisk2"/>, or attached to some known virtual machine.
+        <link to="#createHardDisk"/> or opened by <link
+        to="#openHardDisk"/>, or attached to some known virtual machine.
 
         The search is done by comparing the value of the @a location argument to
-        the <link to="IHardDisk2::location"/> attribute of each known hard
+        the <link to="IHardDisk::location"/> attribute of each known hard
         disk.
 
@@ -1899 +1899 @@
         <desc>Location string to search for.</desc>
       </param>
-      <param name="hardDisk" type="IHardDisk2" dir="return">
+      <param name="hardDisk" type="IHardDisk" dir="return">
         <desc>Found hard disk object.</desc>
       </param>
@@ -2039 +2039 @@
         </desc>
       </param>
-      <param name="image" type="IFloppyImage2" dir="return">
+      <param name="image" type="IFloppyImage" dir="return">
         <desc>Opened floppy image object.</desc>
       </param>
@@ -2060 +2060 @@
         <desc>UUID of the image to look for.</desc>
       </param>
-      <param name="image" type="IFloppyImage2" dir="return">
+      <param name="image" type="IFloppyImage" dir="return">
         <desc>Found floppy image object.</desc>
       </param>
@@ -2095 +2095 @@
         <desc>Floppy image file path to look for.</desc>
       </param>
-      <param name="image" type="IFloppyImage2" dir="return">
+      <param name="image" type="IFloppyImage" dir="return">
         <desc>Found floppy image object.</desc>
       </param>
@@ -3935 +3935 @@
     </attribute>
 
-    <attribute name="hardDisk2Attachments" type="IHardDisk2Attachment" readonly="yes" safearray="yes">
+    <attribute name="hardDiskAttachments" type="IHardDiskAttachment" readonly="yes" safearray="yes">
       <desc>Array of hard disks attached to this machine.</desc>
     </attribute>
@@ -4244 +4244 @@
     </method>
 
-    <method name="attachHardDisk2">
+    <method name="attachHardDisk">
       <desc>
         Attaches a virtual hard disk identified by the given UUID @a id
@@ -4265 +4265 @@
         this method will fail.
 
-        See <link to="IHardDisk2"/> for more detailed information about
+        See <link to="IHardDisk"/> for more detailed information about
         attaching hard disks.
 
@@ -4312 +4312 @@
     </method>
 
-    <method name="getHardDisk2" const="yes">
+    <method name="getHardDisk" const="yes">
       <desc>
         Returns the virtual hard disk attached to a device slot of the specified
@@ -4318 +4318 @@
 
         Note that if the hard disk was indirectly attached by
-        <link to="#attachHardDisk2"/> to the given device slot then this
+        <link to="#attachHardDisk"/> to the given device slot then this
         method will return not the same object as passed to the
-        <link to="#attachHardDisk2"/> call. See <link to="IHardDisk2"/> for
+        <link to="#attachHardDisk"/> call. See <link to="IHardDisk"/> for
         more detailed information about attaching hard disks.
 
@@ -4337 +4337 @@
         <desc>Device slot in the given channel to query.</desc>
       </param>
-      <param name="hardDisk" type="IHardDisk2" dir="return">
+      <param name="hardDisk" type="IHardDisk" dir="return">
         <desc>Attached hard disk object.</desc>
       </param>
     </method>
 
-    <method name="detachHardDisk2">
+    <method name="detachHardDisk">
       <desc>
         Detaches the virtual hard disk attached to a device slot of the
@@ -4350 +4350 @@
         that the hard disk remains associated with the machine when this method
         returns and gets actually de-associated only after a successful
-        <link to="#saveSettings"/> call. See <link to="IHardDisk2"/>
+        <link to="#saveSettings"/> call. See <link to="IHardDisk"/>
         for more detailed information about attaching hard disks.
 
@@ -4358 +4358 @@
         <note>
           Detaching differencing hard disks implicitly created by <link
-          to="#attachHardDisk2"/> for the indirect attachment using this
+          to="#attachHardDisk"/> for the indirect attachment using this
           method will <b>not</b> implicitly delete them. The
-          <link to="IHardDisk2::deleteStorage"/> operation should be
+          <link to="IHardDisk::deleteStorage"/> operation should be
           explicitly performed by the caller after the hard disk is successfully
           detached and the settings are saved with
@@ -6950 +6950 @@
 
         <see>
-          IHardDisk2,
-          <link to="IVirtualBox::createHardDisk2"/>,
-          <link to="IVirtualBox::openHardDisk2"/>,
+          IHardDisk,
+          <link to="IVirtualBox::createHardDisk"/>,
+          <link to="IVirtualBox::openHardDisk"/>,
           <link to="IMedium::location"/>
         </see>
@@ -6965 +6965 @@
         Keep in mind that the hard disk format identifier
         (<link to="IHardDiskFormat::id"/>) used in other API calls like
-        <link to="IVirtualBox::createHardDisk2"/> to refer to a particular
+        <link to="IVirtualBox::createHardDisk"/> to refer to a particular
         hard disk format is a case-insensitive string. This means that, for
         example, all of the following strings:
@@ -6990 +6990 @@
         The hard disk format set by this attribute is used by VirtualBox
         when the hard disk format was not specified explicitly. One example is
-        <link to="IVirtualBox::createHardDisk2"/> with the <tt>null</tt>
+        <link to="IVirtualBox::createHardDisk"/> with the <tt>null</tt>
         format argument. A more complex example is implicit creation of
         differencing hard disks when taking a snapshot of a virtual machine:
@@ -7014 +7014 @@
           <link to="#hardDiskFormats"/>,
           <link to="IHardDiskFormat::id"/>,
-          <link to="IVirtualBox::createHardDisk2"/>
+          <link to="IVirtualBox::createHardDisk"/>
         </see>
       </desc>
@@ -7475 +7475 @@
       Snapshots can be chained. Chained snapshots form a branch where
       every next snapshot is based on the previous one. This chaining is
-      mostly related to hard disk branching (see <link to="IHardDisk2"/>
+      mostly related to hard disk branching (see <link to="IHardDisk"/>
       description). This means that every time a new snapshot is created,
       a new differencing hard disk is implicitly created for all normal
@@ -7722 +7722 @@
       interface such as:
       <ul>
-        <li>IHardDisk2 (virtual hard disks)</li>
+        <li>IHardDisk (virtual hard disks)</li>
         <li>IDVDImage (standard CD/DVD ISO image files)</li>
-        <li>IFloppyImage2 (raw floppy image files)</li>
+        <li>IFloppyImage (raw floppy image files)</li>
       </ul>
 
@@ -7730 +7730 @@
       media type:
       <ul>
-        <li><link to="IVirtualBox::openHardDisk2"/></li>
+        <li><link to="IVirtualBox::openHardDisk"/></li>
         <li><link to="IVirtualBox::openDVDImage"/></li>
         <li><link to="IVirtualBox::openFloppyImage"/></li>
@@ -7736 +7736 @@
 
       New hard disk media are created using the
-      <link to="IVirtualBox::createHardDisk2"/> method. CD/DVD and floppy
+      <link to="IVirtualBox::createHardDisk"/> method. CD/DVD and floppy
       images are created outside VirtualBox, usually by storing a copy
       of the real medium of the corresponding type in a regular file.
@@ -7749 +7749 @@
 
       Newly created virtual hard disks get remembered only when the associated
-      storage unit is actually created (see IHardDisk2 for more details).
+      storage unit is actually created (see IHardDisk for more details).
 
       All known media can be enumerated using
-      <link to="IVirtualBox::hardDisks2"/>,
+      <link to="IVirtualBox::hardDisks"/>,
       <link to="IVirtualBox::DVDImages"/> and
       <link to="IVirtualBox::floppyImages"/> attributes. Individual media can be
-      quickly found by UUID using <link to="IVirtualBox::getHardDisk2"/>
+      quickly found by UUID using <link to="IVirtualBox::getHardDisk"/>
       and similar methods or by location using
-      <link to="IVirtualBox::findHardDisk2"/> and similar methods.
+      <link to="IVirtualBox::findHardDisk"/> and similar methods.
 
       Only known media can be attached to virtual machines.
@@ -7853 +7853 @@
         <link to="MediaState_LockedWrite"/>, <link to="MediaState_Creating"/>,
         <link to="MediaState_Deleting"/> are meaningless for IDVDImage and
-        IFloppyImage2 media.
+        IFloppyImage media.
       </desc>
     </attribute>
@@ -8124 +8124 @@
         deleted. In particular, this means that this hard disk can be
         later opened again using the <link
-        to="IVirtualBox::openHardDisk2"/> call.
+        to="IVirtualBox::openHardDisk"/> call.
 
         Note that after this method successfully returns, the given hard
@@ -8152 +8152 @@
 
   <!--
-  // IHardDisk2
+  // IHardDisk
   /////////////////////////////////////////////////////////////////////////
   -->
@@ -8186 +8186 @@
 
   <interface
-    name="IHardDisk2Attachment" extends="$unknown"
-    uuid="fa2f4619-2c14-4090-869e-73b45419b7b5"
+    name="IHardDiskAttachment" extends="$unknown"
+    uuid="b1dd04bb-93c0-4ad3-a9cf-82316e595836"
     wsmap="struct"
   >
     <desc>
-      The IHardDisk2Attachment interface represents a hard disk attachment of a
+      The IHardDiskAttachment interface represents a hard disk attachment of a
       virtual machine.
 
@@ -8198 +8198 @@
 
       The array of hard disk attachments is returned by
-      <link to="IMachine::hardDisk2Attachments"/>.
+      <link to="IMachine::hardDiskAttachments"/>.
 
       <note>
@@ -8206 +8206 @@
       </note>
     </desc>
-    <attribute name="hardDisk" type="IHardDisk2" readonly="yes">
+    <attribute name="hardDisk" type="IHardDisk" readonly="yes">
       <desc>Hard disk object associated with this attachment.</desc>
     </attribute>
@@ -8225 +8225 @@
 
   <interface
-    name="IHardDisk2" extends="IMedium"
-    uuid="ed6e2525-c2fd-42a4-917a-7a9045ac9e15"
+    name="IHardDisk" extends="IMedium"
+    uuid="244f89fe-1943-464d-baad-2efd73e5d532"
     wsmap="managed"
   >
     <desc>
-      The IHardDisk2 interface represents a virtual hard disk drive
-      used by a virtual machine.
+      The IHardDisk interface represents a virtual hard disk drive
+      used by a virtual machine. This is a subclass of <link to="IMedium" />; see remarks there.
 
       Virtual hard disk objects virtualize the hard disk hardware and look like
@@ -8277 +8277 @@
 
       New base hard disks are created using
-      <link to="IVirtualBox::createHardDisk2"/>. Existing hard disks are
-      opened using <link to="IVirtualBox::openHardDisk2"/>. Differencing hard
+      <link to="IVirtualBox::createHardDisk"/>. Existing hard disks are
+      opened using <link to="IVirtualBox::openHardDisk"/>. Differencing hard
       disks are usually implicitly created by VirtualBox when needed but may
       also be created explicitly using <link to="#createDiffStorage"/>.
@@ -8285 +8285 @@
       or opened, it becomes a known hard disk (remembered in the internal media
       registry). Known hard disks can be attached to a virtual machine, accessed
-      through <link to="IVirtualBox::getHardDisk2"/> and
-      <link to="IVirtualBox::findHardDisk2"/> methods or enumerated using the
-      <link to="IVirtualBox::hardDisks2"/> array (only for base hard disks).
+      through <link to="IVirtualBox::getHardDisk"/> and
+      <link to="IVirtualBox::findHardDisk"/> methods or enumerated using the
+      <link to="IVirtualBox::hardDisks"/> array (only for base hard disks).
 
       The following methods, besides <link to="IMedium::close"/>,
@@ -8327 +8327 @@
 
       Hard disks are attached to virtual machines using the
-      <link to="IMachine::attachHardDisk2"/> method and detached using the
-      <link to="IMachine::detachHardDisk2"/> method. Depending on their
+      <link to="IMachine::attachHardDisk"/> method and detached using the
+      <link to="IMachine::detachHardDisk"/> method. Depending on their
       <link to="#type"/>, hard disks are attached either
       <i>directly</i> or <i>indirectly</i>.
@@ -8337 +8337 @@
       hard disk linked to it is implicitly created and this differencing hard
       disk is associated with the machine and used for hard disk operations.
-      This also means that if <link to="IMachine::attachHardDisk2"/> performs
+      This also means that if <link to="IMachine::attachHardDisk"/> performs
       a direct attachment then the same hard disk will be returned in response
-      to the subsequent  <link to="IMachine::getHardDisk2"/> call; however if
+      to the subsequent  <link to="IMachine::getHardDisk"/> call; however if
       an indirect attachment is performed then
-      <link to="IMachine::getHardDisk2"/> will return the implicitly created
+      <link to="IMachine::getHardDisk"/> will return the implicitly created
       differencing hard disk, not the original one passed to <link
-      to="IMachine::attachHardDisk2"/>. The following table shows the
+      to="IMachine::attachHardDisk"/>. The following table shows the
       dependency of the attachment type on the hard disk type:
 
@@ -8404 +8404 @@
       Detaching hard disks is performed in a <i>deferred</i> fashion. This means
       that the given hard disk remains associated with the given machine after a
-      successful <link to="IMachine::detachHardDisk2"/> call until
+      successful <link to="IMachine::detachHardDisk"/> call until
       <link to="IMachine::saveSettings"/> is called to save all changes to
       machine settings to disk. This deferring is necessary to guarantee that
@@ -8415 +8415 @@
       <link to="IMachine::saveSettings"/> is made, it will implicitly delete
       all differencing hard disks implicitly created by
-      <link to="IMachine::attachHardDisk2"/> for these indirect attachments.
+      <link to="IMachine::attachHardDisk"/> for these indirect attachments.
       Such implicitly created hard disks will also be immediately deleted when
-      detached explicitly using the <link to="IMachine::detachHardDisk2"/>
+      detached explicitly using the <link to="IMachine::detachHardDisk"/>
       call if it is made before <link to="IMachine::saveSettings"/>. This
       implicit deletion is safe because newly created differencing hard
@@ -8423 +8423 @@
 
       However, keep in mind that detaching differencing hard disks that were
-      implicitly created by <link to="IMachine::attachHardDisk2"/>
+      implicitly created by <link to="IMachine::attachHardDisk"/>
       before the last <link to="IMachine::saveSettings"/> call will
       <b>not</b> implicitly delete them as they may already contain some data
@@ -8541 +8541 @@
     </attribute>
 
-    <attribute name="parent" type="IHardDisk2" readonly="yes">
+    <attribute name="parent" type="IHardDisk" readonly="yes">
       <desc>
         Parent of this hard disk (a hard disk this hard disk is directly based
@@ -8551 +8551 @@
     </attribute>
 
-    <attribute name="children" type="IHardDisk2" safearray="yes" readonly="yes">
+    <attribute name="children" type="IHardDisk" safearray="yes" readonly="yes">
       <desc>
         Children of this hard disk (all differencing hard disks directly based
@@ -8559 +8559 @@
     </attribute>
 
-    <attribute name="root" type="IHardDisk2" readonly="yes">
+    <attribute name="root" type="IHardDisk" readonly="yes">
       <desc>
         Root hard disk of this hard disk.
@@ -8875 +8875 @@
         </result>
       </desc>
-      <param name="target" type="IHardDisk2" dir="in">
+      <param name="target" type="IHardDisk" dir="in">
         <desc>Target hard disk.</desc>
       </param>
@@ -8989 +8989 @@
         </note>
       </desc>
-      <param name="target" type="IHardDisk2" dir="in">
+      <param name="target" type="IHardDisk" dir="in">
         <desc>Target hard disk.</desc>
       </param>
@@ -9022 +9022 @@
         </note>
       </desc>
-      <param name="target" type="IHardDisk2" dir="in">
+      <param name="target" type="IHardDisk" dir="in">
         <desc>Target hard disk.</desc>
       </param>
@@ -9116 +9116 @@
       <desc>
         Supports being used as a format for differencing hard disks (see <link
-        to="IHardDisk2::createDiffStorage"/>).
+        to="IHardDisk::createDiffStorage"/>).
       </desc>
     </const>
@@ -9161 +9161 @@
         Each hard disk format is identified by a string represented by the
         <link to="#id"/> attribute. This string is used in calls like
-        <link to="IVirtualBox::createHardDisk2"/> to specify the desired
+        <link to="IVirtualBox::createHardDisk"/> to specify the desired
         format.
 
@@ -9167 +9167 @@
         <link to="ISystemProperties::hardDiskFormats"/>.
 
-        <see>IHardDisk2</see>
+        <see>IHardDisk</see>
     </desc>
 
@@ -9185 +9185 @@
         This string is used in methods of other interfaces where it is necessary
         to specify a hard disk format, such as
-        <link to="IVirtualBox::createHardDisk2"/>.
+        <link to="IVirtualBox::createHardDisk"/>.
       </desc>
     </attribute>
@@ -9259 +9259 @@
 
   <!--
-  // IFloppyImage2
+  // IFloppyImage
   /////////////////////////////////////////////////////////////////////////
   -->
 
   <interface
-    name="IFloppyImage2" extends="IMedium"
-    uuid="fcdee8f0-03f9-11dd-95ff-0800200c9a66"
+    name="IFloppyImage" extends="IMedium"
+    uuid="faa6101f-078c-4b3a-ab75-75670c8170b3"
     wsmap="managed"
   >
     <desc>
-      The IFloppyImage2 interface represents a medium containing the image
-      of a floppy disk.
+      The IFloppyImage interface represents a medium containing the image
+      of a floppy disk. This is a subclass of <link to="IMedium" />; see remarks there.
     </desc>
 
@@ -9419 +9419 @@
     <method name="getImage">
       <desc>Returns the currently mounted floppy image.</desc>
-      <param name="image" type="IFloppyImage2" dir="return"/>
+      <param name="image" type="IFloppyImage" dir="return"/>
     </method>
 

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

@@ -56 +56 @@
 
         BOOL enabled;
-        ComObjPtr <FloppyImage2> image;
+        ComObjPtr<FloppyImage> image;
         ComPtr <IHostFloppyDrive> hostDrive;
         DriveState_T state;
@@ -94 +94 @@
     STDMETHOD(CaptureHostDrive) (IHostFloppyDrive *aHostFloppyDrive);
     STDMETHOD(Unmount)();
-    STDMETHOD(GetImage) (IFloppyImage2 **aFloppyImage);
+    STDMETHOD(GetImage) (IFloppyImage **aFloppyImage);
     STDMETHOD(GetHostDrive) (IHostFloppyDrive **aHostFloppyDrive);
 

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

@@ -25 +25 @@
 #include "VirtualBoxBase.h"
 
-#include "HardDisk2Impl.h"
+#include "HardDiskImpl.h"
 
-class ATL_NO_VTABLE HardDisk2Attachment :
+class ATL_NO_VTABLE HardDiskAttachment :
     public VirtualBoxBaseNEXT,
-    public com::SupportErrorInfoImpl <HardDisk2Attachment, IHardDisk2Attachment>,
-    public VirtualBoxSupportTranslation <HardDisk2Attachment>,
-    public IHardDisk2Attachment
+    public com::SupportErrorInfoImpl<HardDiskAttachment, IHardDiskAttachment>,
+    public VirtualBoxSupportTranslation<HardDiskAttachment>,
+    public IHardDiskAttachment
 {
 public:
@@ -37 +37 @@
     /** Equality predicate for stdc++. */
     struct EqualsTo
-        : public std::unary_function <ComObjPtr <HardDisk2Attachment>, bool>
+        : public std::unary_function <ComObjPtr<HardDiskAttachment>, bool>
     {
         explicit EqualsTo (StorageBus_T aBus, LONG aChannel, LONG aDevice)
@@ -55 +55 @@
     /** Hard disk reference predicate for stdc++. */
     struct RefersTo
-        : public std::unary_function <ComObjPtr <HardDisk2Attachment>, bool>
+        : public std::unary_function< ComObjPtr<HardDiskAttachment>, bool>
     {
-        explicit RefersTo (HardDisk2 *aHardDisk) : hardDisk (aHardDisk) {}
+        explicit RefersTo (HardDisk *aHardDisk) : hardDisk (aHardDisk) {}
 
         bool operator() (const argument_type &aThat) const
@@ -64 +64 @@
         }
 
-        const ComObjPtr <HardDisk2> hardDisk;
+        const ComObjPtr <HardDisk> hardDisk;
     };
 
-    DECLARE_NOT_AGGREGATABLE(HardDisk2Attachment)
+    DECLARE_NOT_AGGREGATABLE(HardDiskAttachment)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP (HardDisk2Attachment)
+    BEGIN_COM_MAP (HardDiskAttachment)
         COM_INTERFACE_ENTRY(ISupportErrorInfo)
-        COM_INTERFACE_ENTRY(IHardDisk2Attachment)
+        COM_INTERFACE_ENTRY(IHardDiskAttachment)
     END_COM_MAP()
 
@@ -82 +82 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init (HardDisk2 *aHD, StorageBus_T aBus, LONG aChannel,
-                  LONG aDevice, bool aImplicit = false);
+    HRESULT init(HardDisk *aHD, StorageBus_T aBus, LONG aChannel,
+                 LONG aDevice, bool aImplicit = false);
     void uninit();
 
-    // IHardDisk2Attachment properties
-    STDMETHOD(COMGETTER(HardDisk))   (IHardDisk2 **aHardDisk);
+    // IHardDiskAttachment properties
+    STDMETHOD(COMGETTER(HardDisk))   (IHardDisk **aHardDisk);
     STDMETHOD(COMGETTER(Bus))        (StorageBus_T *aBus);
     STDMETHOD(COMGETTER(Channel))    (LONG *aChannel);
@@ -98 +98 @@
     void setImplicit (bool aImplicit) { m.implicit = aImplicit; }
 
-    const ComObjPtr <HardDisk2> &hardDisk() const { return m.hardDisk; }
+    const ComObjPtr<HardDisk> &hardDisk() const { return m.hardDisk; }
     StorageBus_T bus() const { return m.bus; }
     LONG channel() const { return m.channel; }
@@ -104 +104 @@
 
     /** Must be called from under this object's write lock.  */
-    void updateHardDisk (const ComObjPtr <HardDisk2> &aHardDisk, bool aImplicit)
+    void updateHardDisk (const ComObjPtr<HardDisk> &aHardDisk, bool aImplicit)
     {
         m.hardDisk = aHardDisk;
@@ -111 +111 @@
 
     /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "HardDisk2Attachment"; }
+    static const char *ComponentName() { return "HardDiskAttachment"; }
 
 private:
@@ -122 +122 @@
         /// @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;
+        ComObjPtr<HardDisk> hardDisk;
         const StorageBus_T bus;
         const LONG channel;

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

@@ -37 +37 @@
  * (IHardDiskFormat interface).
  *
- * @note Instances of this class are permanently caller-referenced by HardDisk2
+ * @note Instances of this class are permanently caller-referenced by HardDisk
  * objects (through addCaller()) so that an attempt to uninitialize or delete
- * them before all HardDisk2 objects are uninitialized will produce an endless
+ * them before all HardDisk objects are uninitialized will produce an endless
  * wait!
  */

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

@@ -22 +22 @@
  */
 
-#ifndef ____H_HARDDISK2IMPL
-#define ____H_HARDDISK2IMPL
+#ifndef ____H_HARDDISKIMPL
+#define ____H_HARDDISKIMPL
 
 #include "VirtualBoxBase.h"
@@ -42 +42 @@
 
 /**
- * The HardDisk2 component class implements the IHardDisk2 interface.
+ * The HardDisk component class implements the IHardDisk interface.
  */
-class ATL_NO_VTABLE HardDisk2
-    : public com::SupportErrorInfoDerived <MediumBase, HardDisk2, IHardDisk2>
-    , public VirtualBoxBaseWithTypedChildrenNEXT <HardDisk2>
-    , public VirtualBoxSupportTranslation <HardDisk2>
-    , public IHardDisk2
+class ATL_NO_VTABLE HardDisk
+    : public com::SupportErrorInfoDerived<MediumBase, HardDisk, IHardDisk>
+    , public VirtualBoxBaseWithTypedChildrenNEXT<HardDisk>
+    , public VirtualBoxSupportTranslation<HardDisk>
+    , public IHardDisk
 {
 public:
 
-    typedef VirtualBoxBaseWithTypedChildrenNEXT <HardDisk2>::DependentChildren
+    typedef VirtualBoxBaseWithTypedChildrenNEXT <HardDisk>::DependentChildren
         List;
 
     class MergeChain;
 
-    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (HardDisk2)
-
-    DECLARE_NOT_AGGREGATABLE (HardDisk2)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (HardDisk)
+
+    DECLARE_NOT_AGGREGATABLE (HardDisk)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP (HardDisk2)
+    BEGIN_COM_MAP (HardDisk)
         COM_INTERFACE_ENTRY (ISupportErrorInfo)
         COM_INTERFACE_ENTRY2 (IMedium, MediumBase)
-        COM_INTERFACE_ENTRY (IHardDisk2)
+        COM_INTERFACE_ENTRY (IHardDisk)
     END_COM_MAP()
 
     NS_DECL_ISUPPORTS
 
-    DECLARE_EMPTY_CTOR_DTOR (HardDisk2)
+    DECLARE_EMPTY_CTOR_DTOR (HardDisk)
 
     HRESULT FinalConstruct();
@@ -81 +81 @@
     HRESULT init (VirtualBox *aVirtualBox,
                   CBSTR aLocation);
-    HRESULT init (VirtualBox *aVirtualBox, HardDisk2 *aParent,
+    HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
                   const settings::Key &aNode);
     void uninit();
@@ -88 +88 @@
     COM_FORWARD_IMedium_TO_BASE (MediumBase)
 
-    // IHardDisk2 properties
+    // IHardDisk properties
     STDMETHOD(COMGETTER(Format)) (BSTR *aFormat);
     STDMETHOD(COMGETTER(Type)) (HardDiskType_T *aType);
     STDMETHOD(COMSETTER(Type)) (HardDiskType_T aType);
-    STDMETHOD(COMGETTER(Parent)) (IHardDisk2 **aParent);
-    STDMETHOD(COMGETTER(Children)) (ComSafeArrayOut (IHardDisk2 *, aChildren));
-    STDMETHOD(COMGETTER(Root)) (IHardDisk2 **aRoot);
+    STDMETHOD(COMGETTER(Parent)) (IHardDisk **aParent);
+    STDMETHOD(COMGETTER(Children)) (ComSafeArrayOut (IHardDisk *, aChildren));
+    STDMETHOD(COMGETTER(Root)) (IHardDisk **aRoot);
     STDMETHOD(COMGETTER(ReadOnly)) (BOOL *aReadOnly);
     STDMETHOD(COMGETTER(LogicalSize)) (ULONG64 *aLogicalSize);
 
-    // IHardDisk2 methods
+    // IHardDisk methods
     STDMETHOD(GetProperty) (IN_BSTR aName, BSTR *aValue);
     STDMETHOD(SetProperty) (IN_BSTR aName, IN_BSTR aValue);
@@ -109 +109 @@
     STDMETHOD(CreateFixedStorage) (ULONG64 aLogicalSize, IProgress **aProgress);
     STDMETHOD(DeleteStorage) (IProgress **aProgress);
-    STDMETHOD(CreateDiffStorage) (IHardDisk2 *aTarget, IProgress **aProgress);
+    STDMETHOD(CreateDiffStorage) (IHardDisk *aTarget, IProgress **aProgress);
     STDMETHOD(MergeTo) (IN_GUID aTargetId, IProgress **aProgress);
-    STDMETHOD(CloneTo) (IHardDisk2 *aTarget, IProgress **aProgress);
-    STDMETHOD(FlattenTo) (IHardDisk2 *aTarget, IProgress **aProgress);
+    STDMETHOD(CloneTo) (IHardDisk *aTarget, IProgress **aProgress);
+    STDMETHOD(FlattenTo) (IHardDisk *aTarget, IProgress **aProgress);
     STDMETHOD(Compact) (IProgress **aProgress);
 
@@ -124 +124 @@
     void updatePaths (const char *aOldPath, const char *aNewPath);
 
-    ComObjPtr <HardDisk2> root (uint32_t *aLevel = NULL);
+    ComObjPtr<HardDisk> root (uint32_t *aLevel = NULL);
 
     bool isReadOnly();
@@ -150 +150 @@
      * completion and implies the progress object will be used for waiting.
      */
-    HRESULT createDiffStorageNoWait (ComObjPtr <HardDisk2> &aTarget,
+    HRESULT createDiffStorageNoWait (ComObjPtr<HardDisk> &aTarget,
                                      ComObjPtr <Progress> &aProgress)
     { return createDiffStorage (aTarget, &aProgress, false /* aWait */); }
@@ -158 +158 @@
      * blocking the current thread.
      */
-    HRESULT createDiffStorageAndWait (ComObjPtr <HardDisk2> &aTarget,
+    HRESULT createDiffStorageAndWait (ComObjPtr<HardDisk> &aTarget,
                                       ComObjPtr <Progress> *aProgress = NULL)
     { return createDiffStorage (aTarget, aProgress, true /* aWait */); }
 
-    HRESULT prepareMergeTo (HardDisk2 *aTarget, MergeChain * &aChain,
+    HRESULT prepareMergeTo (HardDisk *aTarget, MergeChain * &aChain,
                             bool aIgnoreAttachments = false);
 
@@ -195 +195 @@
     // a caller and a read lock before calling them!)
 
-    ComObjPtr <HardDisk2> parent() const { return static_cast <HardDisk2 *> (mParent); }
+    ComObjPtr <HardDisk> parent() const { return static_cast <HardDisk *> (mParent); }
     HardDiskType_T type() const { return mm.type; }
 
     /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "HardDisk2"; }
+    static const char *ComponentName() { return "HardDisk"; }
 
 protected:
@@ -205 +205 @@
     HRESULT deleteStorage (ComObjPtr <Progress> *aProgress, bool aWait);
 
-    HRESULT createDiffStorage (ComObjPtr <HardDisk2> &aTarget,
+    HRESULT createDiffStorage (ComObjPtr <HardDisk> &aTarget,
                                ComObjPtr <Progress> *aProgress,
                                bool aWait);
@@ -262 +262 @@
 
     /** weak parent */
-    ComObjPtr <HardDisk2, ComWeakRef> mParent;
+    ComObjPtr <HardDisk, ComWeakRef> mParent;
 
     struct Task;
@@ -307 +307 @@
 };
 
-#endif /* ____H_HARDDISK2IMPL */
+#endif /* ____H_HARDDISKIMPL */
 
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -290 +290 @@
         bool operator== (const HDData &that) const;
 
-        typedef std::list <ComObjPtr <HardDisk2Attachment> > AttachmentList;
+        typedef std::list< ComObjPtr<HardDiskAttachment> > AttachmentList;
         AttachmentList mAttachments;
     };
@@ -503 +503 @@
     STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
     STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
-    STDMETHOD(COMGETTER(HardDisk2Attachments))(ComSafeArrayOut (IHardDisk2Attachment *, aAttachments));
+    STDMETHOD(COMGETTER(HardDiskAttachments))(ComSafeArrayOut (IHardDiskAttachment *, aAttachments));
     STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
     STDMETHOD(COMGETTER(DVDDrive))(IDVDDrive **dvdDrive);
@@ -532 +532 @@
     STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
     STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
-    STDMETHOD(AttachHardDisk2) (IN_GUID 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(AttachHardDisk)(IN_GUID 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(GetSerialPort) (ULONG slot, ISerialPort **port);
     STDMETHOD(GetParallelPort) (ULONG slot, IParallelPort **port);
@@ -772 +772 @@
     HRESULT deleteImplicitDiffs();
 
-    void fixupHardDisks2 (bool aCommit, bool aOnline = false);
+    void fixupHardDisks(bool aCommit, bool aOnline = false);
 
     HRESULT lockConfig();

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

@@ -289 +289 @@
 
 /**
- * The FloppyImage2 component class implements the IFloppyImage2 interface.
- */
-class ATL_NO_VTABLE FloppyImage2
-    : public com::SupportErrorInfoDerived <ImageMediumBase, FloppyImage2, IFloppyImage2>
-    , public VirtualBoxSupportTranslation <FloppyImage2>
-    , public IFloppyImage2
+ * The FloppyImage component class implements the IFloppyImage interface.
+ */
+class ATL_NO_VTABLE FloppyImage
+    : public com::SupportErrorInfoDerived <ImageMediumBase, FloppyImage, IFloppyImage>
+    , public VirtualBoxSupportTranslation <FloppyImage>
+    , public IFloppyImage
 {
 public:
@@ -300 +300 @@
     COM_FORWARD_IMedium_TO_BASE (ImageMediumBase)
 
-    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (FloppyImage2)
-
-    DECLARE_NOT_AGGREGATABLE (FloppyImage2)
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE (FloppyImage)
+
+    DECLARE_NOT_AGGREGATABLE (FloppyImage)
 
     DECLARE_PROTECT_FINAL_CONSTRUCT()
 
-    BEGIN_COM_MAP (FloppyImage2)
+    BEGIN_COM_MAP (FloppyImage)
         COM_INTERFACE_ENTRY (ISupportErrorInfo)
         COM_INTERFACE_ENTRY2 (IMedium, ImageMediumBase)
-        COM_INTERFACE_ENTRY (IFloppyImage2)
+        COM_INTERFACE_ENTRY (IFloppyImage)
     END_COM_MAP()
 
     NS_DECL_ISUPPORTS
 
-    DECLARE_EMPTY_CTOR_DTOR (FloppyImage2)
+    DECLARE_EMPTY_CTOR_DTOR (FloppyImage)
 
     // public initializer/uninitializer for internal purposes only
@@ -332 +332 @@
 
     /** For com::SupportErrorInfoImpl. */
-    static const char *ComponentName() { return "FloppyImage2"; }
+    static const char *ComponentName() { return "FloppyImage"; }
 
 private:

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

@@ -43 +43 @@
 class Machine;
 class SessionMachine;
-class HardDisk2;
+class HardDisk;
 class DVDImage;
-class FloppyImage2;
+class FloppyImage;
 class MachineCollection;
 class GuestOSType;
@@ -126 +126 @@
     STDMETHOD(COMGETTER(SystemProperties)) (ISystemProperties **aSystemProperties);
     STDMETHOD(COMGETTER(Machines2)) (ComSafeArrayOut (IMachine *, aMachines));
-    STDMETHOD(COMGETTER(HardDisks2)) (ComSafeArrayOut (IHardDisk2 *, aHardDisks));
+    STDMETHOD(COMGETTER(HardDisks)) (ComSafeArrayOut (IHardDisk *, aHardDisks));
     STDMETHOD(COMGETTER(DVDImages)) (ComSafeArrayOut (IDVDImage *, aDVDImages));
-    STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages));
+    STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage *, aFloppyImages));
     STDMETHOD(COMGETTER(ProgressOperations)) (ComSafeArrayOut (IProgress *, aOperations));
     STDMETHOD(COMGETTER(GuestOSTypes)) (IGuestOSTypeCollection **aGuestOSTypes);
@@ -147 +147 @@
     STDMETHOD(CreateAppliance) (IAppliance **anAppliance);
 
-    STDMETHOD(CreateHardDisk2) (IN_BSTR aFormat, IN_BSTR aLocation,
-                                IHardDisk2 **aHardDisk);
-    STDMETHOD(OpenHardDisk2) (IN_BSTR aLocation, IHardDisk2 **aHardDisk);
-    STDMETHOD(GetHardDisk2) (IN_GUID aId, IHardDisk2 **aHardDisk);
-    STDMETHOD(FindHardDisk2) (IN_BSTR aLocation, IHardDisk2 **aHardDisk);
+    STDMETHOD(CreateHardDisk)(IN_BSTR aFormat, IN_BSTR aLocation,
+                               IHardDisk **aHardDisk);
+    STDMETHOD(OpenHardDisk) (IN_BSTR aLocation, IHardDisk **aHardDisk);
+    STDMETHOD(GetHardDisk) (IN_GUID aId, IHardDisk **aHardDisk);
+    STDMETHOD(FindHardDisk) (IN_BSTR aLocation, IHardDisk **aHardDisk);
 
     STDMETHOD(OpenDVDImage) (IN_BSTR aLocation, IN_GUID aId,
@@ -159 +159 @@
 
     STDMETHOD(OpenFloppyImage) (IN_BSTR aLocation, IN_GUID aId,
-                                IFloppyImage2 **aFloppyImage);
-    STDMETHOD(GetFloppyImage) (IN_GUID aId, IFloppyImage2 **aFloppyImage);
-    STDMETHOD(FindFloppyImage) (IN_BSTR aLocation, IFloppyImage2 **aFloppyImage);
+                                IFloppyImage **aFloppyImage);
+    STDMETHOD(GetFloppyImage) (IN_GUID aId, IFloppyImage **aFloppyImage);
+    STDMETHOD(FindFloppyImage) (IN_BSTR aLocation, IFloppyImage **aFloppyImage);
 
     STDMETHOD(GetGuestOSType) (IN_BSTR aId, IGuestOSType **aType);
@@ -234 +234 @@
                          ComObjPtr <Machine> *machine = NULL);
 
-    HRESULT findHardDisk2 (const Guid *aId, CBSTR aLocation,
-                           bool aSetError, ComObjPtr <HardDisk2> *aHardDisk = NULL);
+    HRESULT findHardDisk(const Guid *aId, CBSTR aLocation,
+                          bool aSetError, ComObjPtr<HardDisk> *aHardDisk = NULL);
     HRESULT findDVDImage(const Guid *aId, CBSTR aLocation,
                          bool aSetError, ComObjPtr<DVDImage> *aImage = NULL);
-    HRESULT findFloppyImage2 (const Guid *aId, CBSTR aLocation,
-                              bool aSetError, ComObjPtr <FloppyImage2> *aImage = NULL);
+    HRESULT findFloppyImage(const Guid *aId, CBSTR aLocation,
+                            bool aSetError, ComObjPtr<FloppyImage> *aImage = NULL);
 
     const ComObjPtr <Host> &host() { return mData.mHost; }
@@ -256 +256 @@
     void calculateRelativePath (const char *aPath, Utf8Str &aResult);
 
-    HRESULT registerHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
-    HRESULT unregisterHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
+    HRESULT registerHardDisk(HardDisk *aHardDisk, bool aSaveRegistry = true);
+    HRESULT unregisterHardDisk(HardDisk *aHardDisk, bool aSaveRegistry = true);
 
     HRESULT registerDVDImage(DVDImage *aImage, bool aSaveRegistry = true);
     HRESULT unregisterDVDImage(DVDImage *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 registerFloppyImage (FloppyImage *aImage, bool aSaveRegistry = true);
+    HRESULT unregisterFloppyImage (FloppyImage *aImage, bool aSaveRegistry = true);
+
+    HRESULT cast (IHardDisk *aFrom, ComObjPtr<HardDisk> &aTo);
 
     HRESULT saveSettings();
@@ -337 +337 @@
     /**
      * Returns a lock handle used to protect changes to the hard disk hierarchy
-     * (e.g. serialize access to the HardDisk2::mParent fields and methods
+     * (e.g. serialize access to the HardDisk::mParent fields and methods
      * adding/removing children). When using this lock, the following rules must
      * be obeyed:
@@ -361 +361 @@
     typedef std::map <Guid, ComPtr <IProgress> > ProgressMap;
 
-    typedef std::list <ComObjPtr <HardDisk2> > HardDisk2List;
+    typedef std::list <ComObjPtr <HardDisk> > HardDiskList;
     typedef std::list <ComObjPtr <DVDImage> > DVDImageList;
-    typedef std::list <ComObjPtr <FloppyImage2> > FloppyImage2List;
+    typedef std::list <ComObjPtr <FloppyImage> > FloppyImageList;
     typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
 
-    typedef std::map <Guid, ComObjPtr <HardDisk2> > HardDisk2Map;
+    typedef std::map <Guid, ComObjPtr<HardDisk> > HardDiskMap;
 
     /**
@@ -428 +428 @@
         ProgressMap mProgressOperations;
 
-        HardDisk2List mHardDisks2;
-        DVDImageList mDVDImages2;
-        FloppyImage2List mFloppyImages2;
+        HardDiskList mHardDisks;
+        DVDImageList mDVDImages;
+        FloppyImageList mFloppyImages;
         SharedFolderList mSharedFolders;
 
         /// @todo NEWMEDIA do we really need this map? Used only in
         /// find() it seems
-        HardDisk2Map mHardDisk2Map;
+        HardDiskMap mHardDiskMap;
 
         CallbackList mCallbacks;

trunk/src/VBox/Main/testcase/tstAPI.cpp

@@ -631 +631 @@
     do
     {
-        ComPtr <IHardDisk2> hd;
+        ComPtr <IHardDisk> hd;
         static const wchar_t *Names[] =
         {
@@ -651 +651 @@
             Bstr src = Names [i];
             printf ("Searching for hard disk '%ls'...\n", src.raw());
-            rc = virtualBox->FindHardDisk2 (src, hd.asOutParam());
+            rc = virtualBox->FindHardDisk (src, hd.asOutParam());
             if (SUCCEEDED (rc))
             {
@@ -901 +901 @@
     {
         {
-            com::SafeIfaceArray <IHardDisk2> disks;
+            com::SafeIfaceArray <IHardDisk> disks;
             CHECK_ERROR_BREAK (virtualBox,
-                               COMGETTER(HardDisks2) (ComSafeArrayAsOutParam (disks)));
+                               COMGETTER(HardDisks)(ComSafeArrayAsOutParam (disks)));
 
             printf ("%u base hard disks registered (disks.isNull()=%d).\n",

trunk/src/VBox/Main/testcase/tstVBoxAPILinux.cpp

@@ -298 +298 @@
      * Create a virtual harddisk
      */
-    nsCOMPtr<IHardDisk2> hardDisk = 0;
-    rc = virtualBox->CreateHardDisk2(NS_LITERAL_STRING("VDI").get(),
-                                     NS_LITERAL_STRING("TestHardDisk.vdi").get(),
-                                     getter_AddRefs(hardDisk));
+    nsCOMPtr<IHardDisk> hardDisk = 0;
+    rc = virtualBox->CreateHardDisk(NS_LITERAL_STRING("VDI").get(),
+                                    NS_LITERAL_STRING("TestHardDisk.vdi").get(),
+                                    getter_AddRefs(hardDisk));
     if (NS_FAILED(rc))
     {
@@ -344 +344 @@
                 nsID *vdiUUID = nsnull;
                 hardDisk->GetId(&vdiUUID);
-                rc = machine->AttachHardDisk2(*vdiUUID,
-                                              StorageBus::IDE, // controler identifier
-                                              0,               // channel number on the controller
-                                              0);              // device number on the controller
+                rc = machine->AttachHardDisk(*vdiUUID,
+                                             StorageBus::IDE, // controler identifier
+                                             0,               // channel number on the controller
+                                             0);              // device number on the controller
                 nsMemory::Free(vdiUUID);
                 if (NS_FAILED(rc))

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

@@ -95 +95 @@
 #include <SnapshotImpl.h>
 #include <MediumImpl.h>
-#include <HardDisk2Impl.h>
+#include <HardDiskImpl.h>
 #include <HardDiskFormatImpl.h>
 #include <ProgressImpl.h>
@@ -147 +147 @@
                                            IMedium, ImageMediumBase,
                                            IDVDImage, DVDImage)
-NS_DECL_CLASSINFO(FloppyImage2)
-NS_IMPL_THREADSAFE_ISUPPORTS2_AMBIGUOUS_CI(FloppyImage2,
+NS_DECL_CLASSINFO(FloppyImage)
+NS_IMPL_THREADSAFE_ISUPPORTS2_AMBIGUOUS_CI(FloppyImage,
                                            IMedium, ImageMediumBase,
-                                           IFloppyImage2, FloppyImage2)
-
-NS_DECL_CLASSINFO(HardDisk2)
-NS_IMPL_THREADSAFE_ISUPPORTS2_AMBIGUOUS_CI(HardDisk2,
+                                           IFloppyImage, FloppyImage)
+
+NS_DECL_CLASSINFO(HardDisk)
+NS_IMPL_THREADSAFE_ISUPPORTS2_AMBIGUOUS_CI(HardDisk,
                                            IMedium, MediumBase,
-                                           IHardDisk2, HardDisk2)
+                                           IHardDisk, HardDisk)
 
 NS_DECL_CLASSINFO(HardDiskFormat)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDiskFormat, IHardDiskFormat)
 
-NS_DECL_CLASSINFO(HardDisk2Attachment)
-NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDisk2Attachment, IHardDisk2Attachment)
+NS_DECL_CLASSINFO(HardDiskAttachment)
+NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDiskAttachment, IHardDiskAttachment)
 
 NS_DECL_CLASSINFO(Progress)