Changeset 28205 in vbox for trunk/src/VBox/Main

Timestamp:

Apr 12, 2010 1:39:18 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

59945

Message:

Main/VirtualBoxCallback: rename OnSnapshotDiscard to OnSnapshotDeleted for consistency, clean up wording and other minor issues

Location:

trunk/src/VBox/Main

Files:

• ConsoleImpl.cpp (modified) (5 diffs)
• VirtualBoxCallbackImpl.cpp (modified) (1 diff)
• VirtualBoxImpl.cpp (modified) (126 diffs)
• idl/VirtualBox.xidl (modified) (13 diffs)
• include/AutoCaller.h (modified) (1 diff)
• include/Global.h (modified) (2 diffs)
• include/Performance.h (modified) (1 diff)
• include/VirtualBoxCallbackImpl.h (modified) (4 diffs)

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1025 +1025 @@
     if (RT_FAILURE(vrc))
         rc = setError(VBOX_E_FILE_ERROR,
-            tr("The saved state file '%ls' is invalid (%Rrc). Discard the saved state and try again"),
+            tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
             savedStateFile.raw(), vrc);
 
@@ -2297 +2297 @@
     if (mMachineState != MachineState_Saved)
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot discard the machine state as the machine is not in the saved state (machine state: %s)"),
+            tr("Cannot delete the machine state as the machine is not in the saved state (machine state: %s)"),
             Global::stringifyMachineState(mMachineState));
 
@@ -2843 +2843 @@
     if (Global::IsOnlineOrTransient(mMachineState))
         return setError(VBOX_E_INVALID_VM_STATE,
-            tr("Cannot discard a snapshot of the running machine (machine state: %s)"),
+            tr("Cannot delete a snapshot of the running machine (machine state: %s)"),
             Global::stringifyMachineState(mMachineState));
 
@@ -2863 +2863 @@
     if (Global::IsOnlineOrTransient(mMachineState))
         return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Cannot discard the current state of the running machine (machine state: %s)"),
+                        tr("Cannot delete the current state of the running machine (machine state: %s)"),
                         Global::stringifyMachineState(mMachineState));
 
@@ -5002 +5002 @@
         if (RT_FAILURE(vrc))
             return setError(VBOX_E_FILE_ERROR,
-                            tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Discard the saved state prior to starting the VM"),
+                            tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
                             savedStateFile.raw(), vrc);
     }

trunk/src/VBox/Main/VirtualBoxCallbackImpl.cpp

@@ -138 +138 @@
 }
 
-STDMETHODIMP CallbackWrapper::OnSnapshotDiscarded(IN_BSTR aMachineId, IN_BSTR aSnapshotId)
-{
-    if (mVBoxCallback.isNull())
-        return S_OK;
-
-    return mVBoxCallback->OnSnapshotDiscarded(aMachineId, aSnapshotId);
+STDMETHODIMP CallbackWrapper::OnSnapshotDeleted(IN_BSTR aMachineId, IN_BSTR aSnapshotId)
+{
+    if (mVBoxCallback.isNull())
+        return S_OK;
+
+    return mVBoxCallback->OnSnapshotDeleted(aMachineId, aSnapshotId);
 }
 

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -308 +308 @@
     m = new Data;
 
-    LogFlow (("===========================================================\n"));
+    LogFlow(("===========================================================\n"));
     LogFlowThisFuncEnter();
 
@@ -376 +376 @@
         unconst(m->pSystemProperties).createObject();
         rc = m->pSystemProperties->init(this);
-        ComAssertComRCThrowRC (rc);
+        ComAssertComRCThrowRC(rc);
 
         rc = m->pSystemProperties->loadSettings(m->pMainConfigFile->systemProperties);
@@ -382 +382 @@
 
         /* guest OS type objects, needed by machines */
-        for (size_t i = 0; i < RT_ELEMENTS (Global::sOSTypes); ++ i)
+        for (size_t i = 0; i < RT_ELEMENTS(Global::sOSTypes); ++ i)
         {
             ComObjPtr <GuestOSType> guestOSTypeObj;
@@ -403 +403 @@
                     m->ollGuestOSTypes.addChild(guestOSTypeObj);
             }
-            ComAssertComRCThrowRC (rc);
+            ComAssertComRCThrowRC(rc);
         }
 
@@ -450 +450 @@
         /* start the client watcher thread */
 #if defined(RT_OS_WINDOWS)
-        unconst(m->updateReq) = ::CreateEvent (NULL, FALSE, FALSE, NULL);
+        unconst(m->updateReq) = ::CreateEvent(NULL, FALSE, FALSE, NULL);
 #elif defined(RT_OS_OS2)
         RTSemEventCreate(&unconst(m->updateReq));
@@ -460 +460 @@
         int vrc = RTThreadCreate(&unconst(m->threadClientWatcher),
                                  ClientWatcher,
-                                 (void *) this,
+                                 (void *)this,
                                  0,
                                  RTTHREADTYPE_MAIN_WORKER,
@@ -470 +470 @@
     }
 
-    if (SUCCEEDED(rc)) do
-    {
-        /* start the async event handler thread */
-        int vrc = RTThreadCreate(&unconst(m->threadAsyncEvent),
-                                 AsyncEventHandler,
-                                 &unconst(m->pAsyncEventQ),
-                                 0,
-                                 RTTHREADTYPE_MAIN_WORKER,
-                                 RTTHREADFLAGS_WAITABLE,
-                                 "EventHandler");
-        ComAssertRCBreak (vrc, rc = E_FAIL);
-
-        /* wait until the thread sets m->pAsyncEventQ */
-        RTThreadUserWait(m->threadAsyncEvent, RT_INDEFINITE_WAIT);
-        ComAssertBreak(m->pAsyncEventQ, rc = E_FAIL);
-    }
-    while (0);
+    if (SUCCEEDED(rc))
+    {
+        try
+        {
+            /* start the async event handler thread */
+            int vrc = RTThreadCreate(&unconst(m->threadAsyncEvent),
+                                     AsyncEventHandler,
+                                     &unconst(m->pAsyncEventQ),
+                                     0,
+                                     RTTHREADTYPE_MAIN_WORKER,
+                                     RTTHREADFLAGS_WAITABLE,
+                                     "EventHandler");
+            ComAssertRCThrow(vrc, E_FAIL);
+
+            /* wait until the thread sets m->pAsyncEventQ */
+            RTThreadUserWait(m->threadAsyncEvent, RT_INDEFINITE_WAIT);
+            ComAssertThrow(m->pAsyncEventQ, E_FAIL);
+        }
+        catch (HRESULT aRC)
+        {
+            rc = aRC;
+        }
+    }
 
     /* Confirm a successful initialization when it's the case */
@@ -494 +500 @@
     LogFlowThisFunc(("rc=%08X\n", rc));
     LogFlowThisFuncLeave();
-    LogFlow (("===========================================================\n"));
+    LogFlow(("===========================================================\n"));
     return rc;
 }
@@ -588 +594 @@
         return;
 
-    LogFlow (("===========================================================\n"));
+    LogFlow(("===========================================================\n"));
     LogFlowThisFuncEnter();
     LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
@@ -634 +640 @@
     {
         /* release all callbacks */
-        LogWarningFunc (("%d unregistered callbacks!\n",
-                         m->llCallbacks.size()));
+        LogWarningFunc(("%d unregistered callbacks!\n",
+                        m->llCallbacks.size()));
         m->llCallbacks.clear();
     }
@@ -643 +649 @@
     {
         /* signal to exit the event loop */
-        if (m->pAsyncEventQ->postEvent (NULL))
+        if (m->pAsyncEventQ->postEvent(NULL))
         {
             /*
@@ -677 +683 @@
     if (m->updateReq != NULL)
     {
-        ::CloseHandle (m->updateReq);
+        ::CloseHandle(m->updateReq);
         unconst(m->updateReq) = NULL;
     }
@@ -683 +689 @@
     if (m->updateReq != NIL_RTSEMEVENT)
     {
-        RTSemEventDestroy (m->updateReq);
+        RTSemEventDestroy(m->updateReq);
         unconst(m->updateReq) = NIL_RTSEMEVENT;
     }
@@ -689 +695 @@
     if (m->updateReq != NIL_RTSEMEVENT)
     {
-        RTSemEventDestroy (m->updateReq);
+        RTSemEventDestroy(m->updateReq);
         unconst(m->updateReq) = NIL_RTSEMEVENT;
     }
@@ -703 +709 @@
 
     LogFlowThisFuncLeave();
-    LogFlow (("===========================================================\n"));
+    LogFlow(("===========================================================\n"));
 }
 
@@ -709 +715 @@
 /////////////////////////////////////////////////////////////////////////////
 
-STDMETHODIMP VirtualBox::COMGETTER(Version) (BSTR *aVersion)
+STDMETHODIMP VirtualBox::COMGETTER(Version)(BSTR *aVersion)
 {
     CheckComArgNotNull(aVersion);
@@ -720 +726 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(Revision) (ULONG *aRevision)
+STDMETHODIMP VirtualBox::COMGETTER(Revision)(ULONG *aRevision)
 {
     CheckComArgNotNull(aRevision);
@@ -731 +737 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(PackageType) (BSTR *aPackageType)
+STDMETHODIMP VirtualBox::COMGETTER(PackageType)(BSTR *aPackageType)
 {
     CheckComArgNotNull(aPackageType);
@@ -742 +748 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(HomeFolder) (BSTR *aHomeFolder)
+STDMETHODIMP VirtualBox::COMGETTER(HomeFolder)(BSTR *aHomeFolder)
 {
     CheckComArgNotNull(aHomeFolder);
@@ -754 +760 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(SettingsFilePath) (BSTR *aSettingsFilePath)
+STDMETHODIMP VirtualBox::COMGETTER(SettingsFilePath)(BSTR *aSettingsFilePath)
 {
     CheckComArgNotNull(aSettingsFilePath);
@@ -766 +772 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(Host) (IHost **aHost)
+STDMETHODIMP VirtualBox::COMGETTER(Host)(IHost **aHost)
 {
     CheckComArgOutSafeArrayPointerValid(aHost);
@@ -779 +785 @@
 
 STDMETHODIMP
-VirtualBox::COMGETTER(SystemProperties) (ISystemProperties **aSystemProperties)
+VirtualBox::COMGETTER(SystemProperties)(ISystemProperties **aSystemProperties)
 {
     CheckComArgOutSafeArrayPointerValid(aSystemProperties);
@@ -792 +798 @@
 
 STDMETHODIMP
-VirtualBox::COMGETTER(Machines) (ComSafeArrayOut(IMachine *, aMachines))
+VirtualBox::COMGETTER(Machines)(ComSafeArrayOut(IMachine *, aMachines))
 {
     if (ComSafeArrayOutIsNull(aMachines))
@@ -807 +813 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(HardDisks) (ComSafeArrayOut(IMedium *, aHardDisks))
+STDMETHODIMP VirtualBox::COMGETTER(HardDisks)(ComSafeArrayOut(IMedium *, aHardDisks))
 {
     if (ComSafeArrayOutIsNull(aHardDisks))
@@ -822 +828 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(DVDImages) (ComSafeArrayOut(IMedium *, aDVDImages))
+STDMETHODIMP VirtualBox::COMGETTER(DVDImages)(ComSafeArrayOut(IMedium *, aDVDImages))
 {
     if (ComSafeArrayOutIsNull(aDVDImages))
@@ -837 +843 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut(IMedium *, aFloppyImages))
+STDMETHODIMP VirtualBox::COMGETTER(FloppyImages)(ComSafeArrayOut(IMedium *, aFloppyImages))
 {
     if (ComSafeArrayOutIsNull(aFloppyImages))
@@ -852 +858 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(ProgressOperations) (ComSafeArrayOut(IProgress *, aOperations))
+STDMETHODIMP VirtualBox::COMGETTER(ProgressOperations)(ComSafeArrayOut(IProgress *, aOperations))
 {
     CheckComArgOutSafeArrayPointerValid(aOperations);
@@ -867 +873 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(GuestOSTypes) (ComSafeArrayOut(IGuestOSType *, aGuestOSTypes))
+STDMETHODIMP VirtualBox::COMGETTER(GuestOSTypes)(ComSafeArrayOut(IGuestOSType *, aGuestOSTypes))
 {
     CheckComArgOutSafeArrayPointerValid(aGuestOSTypes);
@@ -881 +887 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(SharedFolders) (ComSafeArrayOut(ISharedFolder *, aSharedFolders))
+STDMETHODIMP VirtualBox::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
 {
 #ifndef RT_OS_WINDOWS
@@ -896 +902 @@
 
 STDMETHODIMP
-VirtualBox::COMGETTER(PerformanceCollector) (IPerformanceCollector **aPerformanceCollector)
+VirtualBox::COMGETTER(PerformanceCollector)(IPerformanceCollector **aPerformanceCollector)
 {
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
@@ -914 +920 @@
 
 STDMETHODIMP
-VirtualBox::COMGETTER(DHCPServers) (ComSafeArrayOut(IDHCPServer *, aDHCPServers))
+VirtualBox::COMGETTER(DHCPServers)(ComSafeArrayOut(IDHCPServer *, aDHCPServers))
 {
     if (ComSafeArrayOutIsNull(aDHCPServers))
@@ -923 +929 @@
 
     AutoReadLock al(m->ollDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IDHCPServer> svrs (m->ollDHCPServers.getList());
+    SafeIfaceArray<IDHCPServer> svrs(m->ollDHCPServers.getList());
     svrs.detachTo(ComSafeArrayOutArg(aDHCPServers));
 
@@ -1033 +1039 @@
     LogFlowThisFunc(("aName=\"%ls\",aOsTypeId =\"%ls\",aBaseFolder=\"%ls\"\n", aName, aOsTypeId, aBaseFolder));
 
-    CheckComArgStrNotEmptyOrNull (aName);
+    CheckComArgStrNotEmptyOrNull(aName);
     /** @todo tighten checks on aId? */
     CheckComArgOutPointerValid(aMachine);
@@ -1087 +1093 @@
         /* set the return value */
         rc = machine.queryInterfaceTo(aMachine);
-        AssertComRC (rc);
+        AssertComRC(rc);
     }
 
@@ -1101 +1107 @@
                                              IMachine **aMachine)
 {
-    CheckComArgStrNotEmptyOrNull (aName);
-    CheckComArgStrNotEmptyOrNull (aSettingsFile);
+    CheckComArgStrNotEmptyOrNull(aName);
+    CheckComArgStrNotEmptyOrNull(aSettingsFile);
     /** @todo tighten checks on aId? */
     CheckComArgOutPointerValid(aMachine);
@@ -1142 +1148 @@
         /* set the return value */
         rc = machine.queryInterfaceTo(aMachine);
-        AssertComRC (rc);
+        AssertComRC(rc);
     }
 
@@ -1172 +1178 @@
             /* set the return value */
             rc = machine.queryInterfaceTo(aMachine);
-            ComAssertComRC (rc);
+            ComAssertComRC(rc);
         }
     }
@@ -1190 +1196 @@
 
     Bstr name;
-    rc = aMachine->COMGETTER(Name) (name.asOutParam());
+    rc = aMachine->COMGETTER(Name)(name.asOutParam());
     if (FAILED(rc)) return rc;
 
@@ -1217 +1223 @@
 
     ComObjPtr<Machine> machine;
-    HRESULT rc = findMachine (Guid (aId), true /* setError */, &machine);
+    HRESULT rc = findMachine(Guid(aId), true /* setError */, &machine);
 
     /* the below will set *aMachine to NULL if machine is null */
@@ -1488 +1494 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::GetDVDImage (IN_BSTR aId, IMedium **aDVDImage)
+STDMETHODIMP VirtualBox::GetDVDImage(IN_BSTR aId, IMedium **aDVDImage)
 {
     CheckComArgOutSafeArrayPointerValid(aDVDImage);
@@ -1497 +1503 @@
     Guid id(aId);
     ComObjPtr<Medium> image;
-    HRESULT rc = findDVDImage (&id, NULL, true /* setError */, &image);
+    HRESULT rc = findDVDImage(&id, NULL, true /* setError */, &image);
 
     /* the below will set *aDVDImage to NULL if image is null */
@@ -1506 +1512 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::FindDVDImage (IN_BSTR aLocation, IMedium **aDVDImage)
+STDMETHODIMP VirtualBox::FindDVDImage(IN_BSTR aLocation, IMedium **aDVDImage)
 {
     CheckComArgStrNotEmptyOrNull(aLocation);
@@ -1515 +1521 @@
 
     ComObjPtr<Medium> image;
-    HRESULT rc = findDVDImage (NULL, aLocation, true /* setError */, &image);
+    HRESULT rc = findDVDImage(NULL, aLocation, true /* setError */, &image);
 
     /* the below will set *aDVDImage to NULL if dvd is null */
@@ -1524 +1530 @@
 
 /** @note Doesn't lock anything. */
-STDMETHODIMP VirtualBox::OpenFloppyImage (IN_BSTR aLocation, IN_BSTR aId,
-                                          IMedium **aFloppyImage)
+STDMETHODIMP VirtualBox::OpenFloppyImage(IN_BSTR aLocation, IN_BSTR aId,
+                                         IMedium **aFloppyImage)
 {
     CheckComArgStrNotEmptyOrNull(aLocation);
@@ -1542 +1548 @@
     ComObjPtr<Medium> image;
     image.createObject();
-    rc = image->init (this, aLocation, Medium::OpenReadWrite, DeviceType_Floppy, true, id, false, Guid());
+    rc = image->init(this, aLocation, Medium::OpenReadWrite, DeviceType_Floppy, true, id, false, Guid());
     if (SUCCEEDED(rc))
     {
@@ -1564 +1570 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::GetFloppyImage (IN_BSTR aId,
-                                         IMedium **aFloppyImage)
+STDMETHODIMP VirtualBox::GetFloppyImage(IN_BSTR aId, IMedium **aFloppyImage)
 
 {
@@ -1575 +1580 @@
     Guid id(aId);
     ComObjPtr<Medium> image;
-    HRESULT rc = findFloppyImage (&id, NULL, true /* setError */, &image);
+    HRESULT rc = findFloppyImage(&id, NULL, true /* setError */, &image);
 
     /* the below will set *aFloppyImage to NULL if image is null */
@@ -1584 +1589 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::FindFloppyImage (IN_BSTR aLocation,
-                                          IMedium **aFloppyImage)
+STDMETHODIMP VirtualBox::FindFloppyImage(IN_BSTR aLocation,
+                                         IMedium **aFloppyImage)
 {
     CheckComArgStrNotEmptyOrNull(aLocation);
@@ -1603 +1608 @@
 
 /** @note Locks this object for reading. */
-STDMETHODIMP VirtualBox::GetGuestOSType (IN_BSTR aId, IGuestOSType **aType)
+STDMETHODIMP VirtualBox::GetGuestOSType(IN_BSTR aId, IGuestOSType **aType)
 {
     /* Old ID to new ID conversion table. See r39691 for a source */
@@ -1631 +1636 @@
     /* first, look for a substitution */
     Bstr id = aId;
-    for (size_t i = 0; i < RT_ELEMENTS (kOldNewIDs) / 2; i += 2)
+    for (size_t i = 0; i < RT_ELEMENTS(kOldNewIDs) / 2; i += 2)
     {
         if (id == kOldNewIDs[i])
@@ -1817 +1822 @@
  *  @note Locks objects!
  */
-STDMETHODIMP VirtualBox::OpenSession (ISession *aSession, IN_BSTR aMachineId)
+STDMETHODIMP VirtualBox::OpenSession(ISession *aSession, IN_BSTR aMachineId)
 {
     CheckComArgNotNull(aSession);
@@ -1827 +1832 @@
     ComObjPtr<Machine> machine;
 
-    HRESULT rc = findMachine (id, true /* setError */, &machine);
+    HRESULT rc = findMachine(id, true /* setError */, &machine);
     if (FAILED(rc)) return rc;
 
     /* check the session state */
     SessionState_T state;
-    rc = aSession->COMGETTER(State) (&state);
+    rc = aSession->COMGETTER(State)(&state);
     if (FAILED(rc)) return rc;
 
@@ -1841 +1846 @@
     /* get the IInternalSessionControl interface */
     ComPtr<IInternalSessionControl> control = aSession;
-    ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
-                     E_INVALIDARG);
-
-    rc = machine->openSession (control);
+    ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
+                    E_INVALIDARG);
+
+    rc = machine->openSession(control);
 
     if (SUCCEEDED(rc))
@@ -1855 +1860 @@
 
         /* fire an event */
-        onSessionStateChange (id, SessionState_Open);
+        onSessionStateChange(id, SessionState_Open);
     }
 
@@ -1864 +1869 @@
  *  @note Locks objects!
  */
-STDMETHODIMP VirtualBox::OpenRemoteSession (ISession *aSession,
-                                            IN_BSTR aMachineId,
-                                            IN_BSTR aType,
-                                            IN_BSTR aEnvironment,
-                                            IProgress **aProgress)
+STDMETHODIMP VirtualBox::OpenRemoteSession(ISession *aSession,
+                                           IN_BSTR aMachineId,
+                                           IN_BSTR aType,
+                                           IN_BSTR aEnvironment,
+                                           IProgress **aProgress)
 {
     LogRel(("remotesession=%s\n", Utf8Str(aMachineId).c_str()));
@@ -1883 +1888 @@
     ComObjPtr<Machine> machine;
 
-    HRESULT rc = findMachine (id, true /* setError */, &machine);
+    HRESULT rc = findMachine(id, true /* setError */, &machine);
     if (FAILED(rc)) return rc;
 
     /* check the session state */
     SessionState_T state;
-    rc = aSession->COMGETTER(State) (&state);
+    rc = aSession->COMGETTER(State)(&state);
     if (FAILED(rc)) return rc;
 
@@ -1897 +1902 @@
     /* get the IInternalSessionControl interface */
     ComPtr<IInternalSessionControl> control = aSession;
-    ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
-                     E_INVALIDARG);
+    ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
+                    E_INVALIDARG);
 
     /* create a progress object */
     ComObjPtr<Progress> progress;
     progress.createObject();
-    progress->init (this, static_cast <IMachine *> (machine),
-                    Bstr (tr ("Spawning session")),
-                    FALSE /* aCancelable */);
-
-    rc = machine->openRemoteSession (control, aType, aEnvironment, progress);
+    progress->init(this, static_cast <IMachine *>(machine),
+                   Bstr(tr("Spawning session")),
+                   FALSE /* aCancelable */);
+
+    rc = machine->openRemoteSession(control, aType, aEnvironment, progress);
 
     if (SUCCEEDED(rc))
@@ -1917 +1922 @@
 
         /* fire an event */
-        onSessionStateChange (id, SessionState_Spawning);
+        onSessionStateChange(id, SessionState_Spawning);
     }
 
@@ -1926 +1931 @@
  *  @note Locks objects!
  */
-STDMETHODIMP VirtualBox::OpenExistingSession (ISession *aSession,
-                                              IN_BSTR  aMachineId)
+STDMETHODIMP VirtualBox::OpenExistingSession(ISession *aSession,
+                                             IN_BSTR  aMachineId)
 {
     CheckComArgNotNull(aSession);
@@ -1937 +1942 @@
     ComObjPtr<Machine> machine;
 
-    HRESULT rc = findMachine (id, true /* setError */, &machine);
+    HRESULT rc = findMachine(id, true /* setError */, &machine);
     if (FAILED(rc)) return rc;
 
     /* check the session state */
     SessionState_T state;
-    rc = aSession->COMGETTER(State) (&state);
+    rc = aSession->COMGETTER(State)(&state);
     if (FAILED(rc)) return rc;
 
@@ -1951 +1956 @@
     /* get the IInternalSessionControl interface */
     ComPtr<IInternalSessionControl> control = aSession;
-    ComAssertMsgRet (!!control, ("No IInternalSessionControl interface"),
-                     E_INVALIDARG);
-
-    rc = machine->openExistingSession (control);
+    ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
+                    E_INVALIDARG);
+
+    rc = machine->openExistingSession(control);
 
     return rc;
@@ -1962 +1967 @@
  *  @note Locks this object for writing.
  */
-STDMETHODIMP VirtualBox::RegisterCallback (IVirtualBoxCallback *aCallback)
+STDMETHODIMP VirtualBox::RegisterCallback(IVirtualBoxCallback *aCallback)
 {
     LogFlowThisFunc(("aCallback=%p\n", aCallback));
@@ -1980 +1985 @@
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->llCallbacks.push_back (CallbackList::value_type (aCallback));
+    m->llCallbacks.push_back(CallbackList::value_type(aCallback));
 
     return S_OK;
@@ -1988 +1993 @@
  *  @note Locks this object for writing.
  */
-STDMETHODIMP VirtualBox::UnregisterCallback (IVirtualBoxCallback *aCallback)
+STDMETHODIMP VirtualBox::UnregisterCallback(IVirtualBoxCallback *aCallback)
 {
     CheckComArgNotNull(aCallback);
@@ -2000 +2005 @@
 
     CallbackList::iterator it;
-    it = std::find (m->llCallbacks.begin(),
-                    m->llCallbacks.end(),
-                    CallbackList::value_type (aCallback));
+    it = std::find(m->llCallbacks.begin(),
+                   m->llCallbacks.end(),
+                   CallbackList::value_type(aCallback));
     if (it == m->llCallbacks.end())
         rc = E_INVALIDARG;
     else
-        m->llCallbacks.erase (it);
+        m->llCallbacks.erase(it);
 
     LogFlowThisFunc(("aCallback=%p, rc=%08X\n", aCallback, rc));
@@ -2072 +2077 @@
     if (autoCaller.state() != Ready)
     {
-        LogWarningFunc (("VirtualBox has been uninitialized (state=%d), "
-                         "the event is discarded!\n",
-                         autoCaller.state()));
+        LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the event is discarded!\n",
+                        autoCaller.state()));
         return S_OK;
     }
@@ -2103 +2107 @@
 
     Bstr id;
-    HRESULT rc = aProgress->COMGETTER(Id) (id.asOutParam());
+    HRESULT rc = aProgress->COMGETTER(Id)(id.asOutParam());
     AssertComRCReturnRC(rc);
 
@@ -2109 +2113 @@
     AutoWriteLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
 
-    m->mapProgressOperations.insert (ProgressMap::value_type (Guid(id), aProgress));
+    m->mapProgressOperations.insert(ProgressMap::value_type(Guid(id), aProgress));
     return S_OK;
 }
@@ -2197 +2201 @@
  *  @note Doesn't lock anything.
  */
-HRESULT VirtualBox::startSVCHelperClient (bool aPrivileged,
-                                          SVCHelperClientFunc aFunc,
-                                          void *aUser, Progress *aProgress)
+HRESULT VirtualBox::startSVCHelperClient(bool aPrivileged,
+                                         SVCHelperClientFunc aFunc,
+                                         void *aUser, Progress *aProgress)
 {
     AssertReturn(aFunc, E_POINTER);
@@ -2209 +2213 @@
     /* create the SVCHelperClientThread() argument */
     std::auto_ptr <StartSVCHelperClientData>
-        d (new StartSVCHelperClientData());
+        d(new StartSVCHelperClientData());
     AssertReturn(d.get(), E_OUTOFMEMORY);
 
@@ -2219 +2223 @@
 
     RTTHREAD tid = NIL_RTTHREAD;
-    int vrc = RTThreadCreate (&tid, SVCHelperClientThread,
-                              static_cast <void *> (d.get()),
-                              0, RTTHREADTYPE_MAIN_WORKER,
-                              RTTHREADFLAGS_WAITABLE, "SVCHelper");
-
-    ComAssertMsgRCRet (vrc, ("Could not create SVCHelper thread (%Rrc)", vrc),
+    int vrc = RTThreadCreate(&tid, SVCHelperClientThread,
+                             static_cast <void *>(d.get()),
+                             0, RTTHREADTYPE_MAIN_WORKER,
+                             RTTHREADFLAGS_WAITABLE, "SVCHelper");
+
+    ComAssertMsgRCRet(vrc, ("Could not create SVCHelper thread (%Rrc)", vrc),
                        E_FAIL);
 
@@ -2238 +2242 @@
 /* static */
 DECLCALLBACK(int)
-VirtualBox::SVCHelperClientThread (RTTHREAD aThread, void *aUser)
+VirtualBox::SVCHelperClientThread(RTTHREAD aThread, void *aUser)
 {
     LogFlowFuncEnter();
 
     std::auto_ptr <StartSVCHelperClientData>
-        d (static_cast <StartSVCHelperClientData *> (aUser));
+        d(static_cast <StartSVCHelperClientData *>(aUser));
 
     HRESULT rc = S_OK;
@@ -2250 +2254 @@
     do
     {
-        AssertBreakStmt (d.get(), rc = E_POINTER);
+        AssertBreakStmt(d.get(), rc = E_POINTER);
         AssertReturn(!d->progress.isNull(), E_POINTER);
 
@@ -2278 +2282 @@
         /* get the path to the executable */
         char exePathBuf[RTPATH_MAX];
-        char *exePath = RTProcGetExecutableName (exePathBuf, RTPATH_MAX);
-        ComAssertBreak (exePath, E_FAIL);
-
-        Utf8Str argsStr = Utf8StrFmt ("/Helper %s", client.name().raw());
-
-        LogFlowFunc (("Starting '\"%s\" %s'...\n", exePath, argsStr.raw()));
+        char *exePath = RTProcGetExecutableName(exePathBuf, RTPATH_MAX);
+        ComAssertBreak(exePath, E_FAIL);
+
+        Utf8Str argsStr = Utf8StrFmt("/Helper %s", client.name().raw());
+
+        LogFlowFunc(("Starting '\"%s\" %s'...\n", exePath, argsStr.raw()));
 
         RTPROCESS pid = NIL_RTPROCESS;
@@ -2296 +2300 @@
             SHELLEXECUTEINFO shExecInfo;
 
-            shExecInfo.cbSize = sizeof (SHELLEXECUTEINFO);
+            shExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
 
             shExecInfo.fMask = NULL;
@@ -2307 +2311 @@
             shExecInfo.hInstApp = NULL;
 
-            if (!ShellExecuteEx (&shExecInfo))
+            if (!ShellExecuteEx(&shExecInfo))
             {
-                int vrc2 = RTErrConvertFromWin32 (GetLastError());
+                int vrc2 = RTErrConvertFromWin32(GetLastError());
                 /* hide excessive details in case of a frequent error
                  * (pressing the Cancel button to close the Run As dialog) */
@@ -2325 +2329 @@
         {
             const char *args[] = { exePath, "/Helper", client.name().c_str(), 0 };
-            vrc = RTProcCreate (exePath, args, RTENV_DEFAULT, 0, &pid);
+            vrc = RTProcCreate(exePath, args, RTENV_DEFAULT, 0, &pid);
             if (RT_FAILURE(vrc))
             {
@@ -2339 +2343 @@
         {
             /* start the user supplied function */
-            rc = d->func (&client, d->progress, d->user, &vrc);
+            rc = d->func(&client, d->progress, d->user, &vrc);
             userFuncCalled = true;
         }
@@ -2345 +2349 @@
         /* send the termination signal to the process anyway */
         {
-            int vrc2 = client.write (SVCHlpMsg::Null);
+            int vrc2 = client.write(SVCHlpMsg::Null);
             if (RT_SUCCESS(vrc))
                 vrc = vrc2;
@@ -2363 +2367 @@
         /* call the user function in the "cleanup only" mode
          * to let it free resources passed to in aUser */
-        d->func (NULL, NULL, d->user, NULL);
-    }
-
-    d->progress->notifyComplete (rc);
+        d->func(NULL, NULL, d->user, NULL);
+    }
+
+    d->progress->notifyComplete(rc);
 
     LogFlowFuncLeave();
@@ -2383 +2387 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), (void) 0);
-
-    AssertReturn(m->threadClientWatcher != NIL_RTTHREAD, (void) 0);
+    AssertComRCReturnVoid(autoCaller.rc());
+
+    AssertReturnVoid(m->threadClientWatcher != NIL_RTTHREAD);
 
     /* sent an update request */
 #if defined(RT_OS_WINDOWS)
-    ::SetEvent (m->updateReq);
+    ::SetEvent(m->updateReq);
 #elif defined(RT_OS_OS2)
-    RTSemEventSignal (m->updateReq);
+    RTSemEventSignal(m->updateReq);
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    RTSemEventSignal (m->updateReq);
+    RTSemEventSignal(m->updateReq);
 #else
 # error "Port me!"
@@ -2403 +2407 @@
  *  This call should be followed by #updateClientWatcher() to take the effect.
  */
-void VirtualBox::addProcessToReap (RTPROCESS pid)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), (void) 0);
+void VirtualBox::addProcessToReap(RTPROCESS pid)
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.rc());
 
     /// @todo (dmik) Win32?
 #ifndef RT_OS_WINDOWS
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->llProcesses.push_back (pid);
+    m->llProcesses.push_back(pid);
 #endif
 }
@@ -2420 +2424 @@
     enum What { DataChanged, StateChanged, Registered };
 
-    MachineEvent (VirtualBox *aVB, const Guid &aId)
-        : CallbackEvent (aVB), what (DataChanged), id (aId)
+    MachineEvent(VirtualBox *aVB, const Guid &aId)
+        : CallbackEvent(aVB), what(DataChanged), id(aId)
         {}
 
-    MachineEvent (VirtualBox *aVB, const Guid &aId, MachineState_T aState)
-        : CallbackEvent (aVB), what (StateChanged), id (aId)
-        , state (aState)
+    MachineEvent(VirtualBox *aVB, const Guid &aId, MachineState_T aState)
+        : CallbackEvent(aVB), what(StateChanged), id(aId)
+        , state(aState)
         {}
 
-    MachineEvent (VirtualBox *aVB, const Guid &aId, BOOL aRegistered)
-        : CallbackEvent (aVB), what (Registered), id (aId)
-        , registered (aRegistered)
+    MachineEvent(VirtualBox *aVB, const Guid &aId, BOOL aRegistered)
+        : CallbackEvent(aVB), what(Registered), id(aId)
+        , registered(aRegistered)
         {}
 
-    void handleCallback (const ComPtr<IVirtualBoxCallback> &aCallback)
+    void handleCallback(const ComPtr<IVirtualBoxCallback> &aCallback)
     {
         switch (what)
         {
             case DataChanged:
-                LogFlow (("OnMachineDataChange: id={%RTuuid}\n", id.ptr()));
-                aCallback->OnMachineDataChange (id.toUtf16());
+                LogFlow(("OnMachineDataChange: id={%RTuuid}\n", id.ptr()));
+                aCallback->OnMachineDataChange(id.toUtf16());
                 break;
 
             case StateChanged:
-                LogFlow (("OnMachineStateChange: id={%RTuuid}, state=%d\n",
+                LogFlow(("OnMachineStateChange: id={%RTuuid}, state=%d\n",
                           id.ptr(), state));
-                aCallback->OnMachineStateChange (id.toUtf16(), state);
+                aCallback->OnMachineStateChange(id.toUtf16(), state);
                 break;
 
             case Registered:
-                LogFlow (("OnMachineRegistered: id={%RTuuid}, registered=%d\n",
+                LogFlow(("OnMachineRegistered: id={%RTuuid}, registered=%d\n",
                           id.ptr(), registered));
-                aCallback->OnMachineRegistered (id.toUtf16(), registered);
+                aCallback->OnMachineRegistered(id.toUtf16(), registered);
                 break;
         }
@@ -2469 +2473 @@
 void VirtualBox::onMachineStateChange(const Guid &aId, MachineState_T aState)
 {
-    postEvent (new MachineEvent (this, aId, aState));
+    postEvent(new MachineEvent(this, aId, aState));
 }
 
@@ -2477 +2481 @@
 void VirtualBox::onMachineDataChange(const Guid &aId)
 {
-    postEvent (new MachineEvent (this, aId));
+    postEvent(new MachineEvent(this, aId));
 }
 
@@ -2483 +2487 @@
  *  @note Locks this object for reading.
  */
-BOOL VirtualBox::onExtraDataCanChange (const Guid &aId, IN_BSTR aKey, IN_BSTR aValue,
+BOOL VirtualBox::onExtraDataCanChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue,
                                        Bstr &aError)
 {
@@ -2503 +2507 @@
     while ((it != list.end()) && allowChange)
     {
-        HRESULT rc = (*it++)->OnExtraDataCanChange (id, aKey, aValue,
-                                                    aError.asOutParam(), &allowChange);
+        HRESULT rc = (*it++)->OnExtraDataCanChange(id, aKey, aValue,
+                                                   aError.asOutParam(),
+                                                   &allowChange);
         if (FAILED(rc))
         {
@@ -2523 +2528 @@
 struct ExtraDataEvent : public VirtualBox::CallbackEvent
 {
-    ExtraDataEvent (VirtualBox *aVB, const Guid &aMachineId,
+    ExtraDataEvent(VirtualBox *aVB, const Guid &aMachineId,
                     IN_BSTR aKey, IN_BSTR aVal)
-        : CallbackEvent (aVB), machineId (aMachineId)
-        , key (aKey), val (aVal)
+        : CallbackEvent(aVB), machineId(aMachineId)
+        , key(aKey), val(aVal)
         {}
 
-    void handleCallback (const ComPtr<IVirtualBoxCallback> &aCallback)
-    {
-        LogFlow (("OnExtraDataChange: machineId={%RTuuid}, key='%ls', val='%ls'\n",
-                  machineId.ptr(), key.raw(), val.raw()));
-        aCallback->OnExtraDataChange (machineId.toUtf16(), key, val);
+    void handleCallback(const ComPtr<IVirtualBoxCallback> &aCallback)
+    {
+        LogFlow(("OnExtraDataChange: machineId={%RTuuid}, key='%ls', val='%ls'\n",
+                 machineId.ptr(), key.raw(), val.raw()));
+        aCallback->OnExtraDataChange(machineId.toUtf16(), key, val);
     }
 
@@ -2543 +2548 @@
  *  @note Doesn't lock any object.
  */
-void VirtualBox::onExtraDataChange (const Guid &aId, IN_BSTR aKey, IN_BSTR aValue)
-{
-    postEvent (new ExtraDataEvent (this, aId, aKey, aValue));
+void VirtualBox::onExtraDataChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue)
+{
+    postEvent(new ExtraDataEvent(this, aId, aKey, aValue));
 }
 
@@ -2551 +2556 @@
  *  @note Doesn't lock any object.
  */
-void VirtualBox::onMachineRegistered (const Guid &aId, BOOL aRegistered)
-{
-    postEvent (new MachineEvent (this, aId, aRegistered));
+void VirtualBox::onMachineRegistered(const Guid &aId, BOOL aRegistered)
+{
+    postEvent(new MachineEvent(this, aId, aRegistered));
 }
 
@@ -2559 +2564 @@
 struct SessionEvent : public VirtualBox::CallbackEvent
 {
-    SessionEvent (VirtualBox *aVB, const Guid &aMachineId, SessionState_T aState)
-        : CallbackEvent (aVB), machineId (aMachineId), sessionState (aState)
+    SessionEvent(VirtualBox *aVB, const Guid &aMachineId, SessionState_T aState)
+        : CallbackEvent(aVB), machineId(aMachineId), sessionState(aState)
         {}
 
-    void handleCallback (const ComPtr<IVirtualBoxCallback> &aCallback)
-    {
-        LogFlow (("OnSessionStateChange: machineId={%RTuuid}, sessionState=%d\n",
-                  machineId.ptr(), sessionState));
-        aCallback->OnSessionStateChange (machineId.toUtf16(), sessionState);
+    void handleCallback(const ComPtr<IVirtualBoxCallback> &aCallback)
+    {
+        LogFlow(("OnSessionStateChange: machineId={%RTuuid}, sessionState=%d\n",
+                 machineId.ptr(), sessionState));
+        aCallback->OnSessionStateChange(machineId.toUtf16(), sessionState);
     }
 
@@ -2577 +2582 @@
  *  @note Doesn't lock any object.
  */
-void VirtualBox::onSessionStateChange (const Guid &aId, SessionState_T aState)
-{
-    postEvent (new SessionEvent (this, aId, aState));
-}
-
-/** Event for onSnapshotTaken(), onSnapshotRemoved() and onSnapshotChange() */
+void VirtualBox::onSessionStateChange(const Guid &aId, SessionState_T aState)
+{
+    postEvent(new SessionEvent(this, aId, aState));
+}
+
+/** Event for onSnapshotTaken(), onSnapshotDeleted() and onSnapshotChange() */
 struct SnapshotEvent : public VirtualBox::CallbackEvent
 {
-    enum What { Taken, Discarded, Changed };
-
-    SnapshotEvent (VirtualBox *aVB, const Guid &aMachineId, const Guid &aSnapshotId,
+    enum What { Taken, Deleted, Changed };
+
+    SnapshotEvent(VirtualBox *aVB, const Guid &aMachineId, const Guid &aSnapshotId,
                    What aWhat)
-        : CallbackEvent (aVB)
-        , what (aWhat)
-        , machineId (aMachineId), snapshotId (aSnapshotId)
+        : CallbackEvent(aVB)
+        , what(aWhat)
+        , machineId(aMachineId), snapshotId(aSnapshotId)
         {}
 
-    void handleCallback (const ComPtr<IVirtualBoxCallback> &aCallback)
+    void handleCallback(const ComPtr<IVirtualBoxCallback> &aCallback)
     {
         Bstr mid = machineId.toUtf16();
@@ -2602 +2607 @@
         {
             case Taken:
-                LogFlow (("OnSnapshotTaken: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
+                LogFlow(("OnSnapshotTaken: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
                           machineId.ptr(), snapshotId.ptr()));
-                aCallback->OnSnapshotTaken (mid, sid);
+                aCallback->OnSnapshotTaken(mid, sid);
                 break;
 
-            case Discarded:
-                LogFlow (("OnSnapshotDiscarded: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
+            case Deleted:
+                LogFlow(("OnSnapshotDeleted: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
                           machineId.ptr(), snapshotId.ptr()));
-                aCallback->OnSnapshotDiscarded (mid, sid);
+                aCallback->OnSnapshotDeleted(mid, sid);
                 break;
 
             case Changed:
-                LogFlow (("OnSnapshotChange: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
+                LogFlow(("OnSnapshotChange: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
                           machineId.ptr(), snapshotId.ptr()));
-                aCallback->OnSnapshotChange (mid, sid);
+                aCallback->OnSnapshotChange(mid, sid);
                 break;
         }
@@ -2630 +2635 @@
  *  @note Doesn't lock any object.
  */
-void VirtualBox::onSnapshotTaken (const Guid &aMachineId, const Guid &aSnapshotId)
+void VirtualBox::onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId)
 {
     postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId, SnapshotEvent::Taken));
@@ -2640 +2645 @@
 void VirtualBox::onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId)
 {
-    postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId, SnapshotEvent::Discarded));
+    postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId, SnapshotEvent::Deleted));
 }
 
@@ -2667 +2672 @@
         LogFlow(("OnGuestPropertyChange: machineId={%RTuuid}, name='%ls', value='%ls', flags='%ls'\n",
                  machineId.ptr(), name.raw(), value.raw(), flags.raw()));
-        aCallback->OnGuestPropertyChange (machineId.toUtf16(), name, value, flags);
+        aCallback->OnGuestPropertyChange(machineId.toUtf16(), name, value, flags);
     }
 
@@ -2718 +2723 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     aMachines.clear();
@@ -3157 +3162 @@
 {
     AutoCaller autoCaller(this);
-    AssertComRCReturnVoid (autoCaller.rc());
+    AssertComRCReturnVoid(autoCaller.rc());
 
     /* no need to lock since mHomeDir is const */
@@ -3422 +3427 @@
     catch (...)
     {
-        rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
+        rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
     }
 
@@ -3568 +3573 @@
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    AutoCaller hardDiskCaller (aHardDisk);
+    AutoCaller hardDiskCaller(aHardDisk);
     AssertComRCReturn(hardDiskCaller.rc(), hardDiskCaller.rc());
 
@@ -3838 +3843 @@
                                  COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE |
                                  COINIT_SPEED_OVER_MEMORY);
-    AssertComRC (hrc);
+    AssertComRC(hrc);
 
     /// @todo (dmik) processes reaping!
@@ -3913 +3918 @@
                 {
                     /// @todo handle situations with more than 64 objects
-                    AssertMsgBreak ((1 + cnt) <= MAXIMUM_WAIT_OBJECTS,
-                                    ("MAXIMUM_WAIT_OBJECTS reached"));
+                    AssertMsgBreak((1 + cnt) <= MAXIMUM_WAIT_OBJECTS,
+                                   ("MAXIMUM_WAIT_OBJECTS reached"));
 
                     ComObjPtr<SessionMachine> sm;
@@ -3926 +3931 @@
                 }
 
-                LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
+                LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
 
                 /* obtain a new set of spawned machines */
@@ -3937 +3942 @@
                 {
                     /// @todo handle situations with more than 64 objects
-                    AssertMsgBreak ((1 + cnt + cntSpawned) <= MAXIMUM_WAIT_OBJECTS,
-                                    ("MAXIMUM_WAIT_OBJECTS reached"));
+                    AssertMsgBreak((1 + cnt + cntSpawned) <= MAXIMUM_WAIT_OBJECTS,
+                                   ("MAXIMUM_WAIT_OBJECTS reached"));
 
                     RTPROCESS pid;
@@ -3944 +3949 @@
                     {
                         HANDLE ph = OpenProcess(SYNCHRONIZE, FALSE, pid);
-                        AssertMsg (ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
-                                                pid, GetLastError()));
+                        AssertMsg(ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
+                                               pid, GetLastError()));
                         if (rc == 0)
                         {
@@ -3955 +3960 @@
                 }
 
-                LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
+                LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
 
                 // machines lock unwinds here
@@ -3966 +3971 @@
     /* close old process handles */
     for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
-        CloseHandle (handles[i]);
+        CloseHandle(handles[i]);
 
     /* release sets of machines if any */
@@ -3974 +3979 @@
     ::CoUninitialize();
 
-#elif defined (RT_OS_OS2)
+#elif defined(RT_OS_OS2)
 
     /// @todo (dmik) processes reaping!
@@ -4014 +4019 @@
             else
             {
-                AssertMsg (vrc == VERR_TIMEOUT || vrc == VERR_INTERRUPTED,
-                           ("RTSemEventWait returned %Rrc\n", vrc));
+                AssertMsg(vrc == VERR_TIMEOUT || vrc == VERR_INTERRUPTED,
+                          ("RTSemEventWait returned %Rrc\n", vrc));
 
                 /* are there any mutexes? */
@@ -4023 +4028 @@
 
                     unsigned long semId = 0;
-                    APIRET arc = ::DosWaitMuxWaitSem (muxSem,
-                                                      SEM_IMMEDIATE_RETURN, &semId);
+                    APIRET arc = ::DosWaitMuxWaitSem(muxSem,
+                                                     SEM_IMMEDIATE_RETURN, &semId);
 
                     if (arc == NO_ERROR)
@@ -4035 +4040 @@
                             {
                                 AutoReadLock machineLock(machines[semId] COMMA_LOCKVAL_SRC_POS);
-                                LogFlowFunc (("released mutex: machine='%ls'\n",
-                                              machines[semId]->name().raw()));
+                                LogFlowFunc(("released mutex: machine='%ls'\n",
+                                             machines[semId]->name().raw()));
                             }
 #endif
@@ -4075 +4080 @@
                     }
                     else
-                        AssertMsg (arc == ERROR_INTERRUPT || arc == ERROR_TIMEOUT,
-                                   ("DosWaitMuxWaitSem returned %d\n", arc));
+                        AssertMsg(arc == ERROR_INTERRUPT || arc == ERROR_TIMEOUT,
+                                  ("DosWaitMuxWaitSem returned %d\n", arc));
                 }
 
@@ -4096 +4101 @@
                     /* close the old muxsem */
                     if (muxSem != NULLHANDLE)
-                        ::DosCloseMuxWaitSem (muxSem);
+                        ::DosCloseMuxWaitSem(muxSem);
 
                     /* obtain a new set of opened machines */
@@ -4106 +4111 @@
                     {
                         /// @todo handle situations with more than 64 objects
-                        AssertMsg (cnt <= 64 /* according to PMREF */,
-                                   ("maximum of 64 mutex semaphores reached (%d)",
-                                    cnt));
+                        AssertMsg(cnt <= 64 /* according to PMREF */,
+                                  ("maximum of 64 mutex semaphores reached (%d)",
+                                   cnt));
 
                         ComObjPtr<SessionMachine> sm;
                         HMTX ipcSem;
-                        if ((*it)->isSessionOpenOrClosing (sm, NULL, &ipcSem))
+                        if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
                         {
-                            machines.push_back (sm);
-                            handles[cnt].hsemCur = (HSEM) ipcSem;
+                            machines.push_back(sm);
+                            handles[cnt].hsemCur = (HSEM)ipcSem;
                             handles[cnt].ulUser = cnt;
                             ++ cnt;
@@ -4121 +4126 @@
                     }
 
-                    LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
+                    LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
 
                     if (cnt > 0)
                     {
                         /* create a new muxsem */
-                        APIRET arc = ::DosCreateMuxWaitSem (NULL, &muxSem, cnt,
-                                                            handles,
-                                                            DCMW_WAIT_ANY);
-                        AssertMsg (arc == NO_ERROR,
-                                   ("DosCreateMuxWaitSem returned %d\n", arc));
+                        APIRET arc = ::DosCreateMuxWaitSem(NULL, &muxSem, cnt,
+                                                           handles,
+                                                           DCMW_WAIT_ANY);
+                        AssertMsg(arc == NO_ERROR,
+                                  ("DosCreateMuxWaitSem returned %d\n", arc));
                         NOREF(arc);
                     }
@@ -4144 +4149 @@
                     {
                         if ((*it)->isSessionSpawning())
-                            spawnedMachines.push_back (*it);
+                            spawnedMachines.push_back(*it);
                     }
 
                     cntSpawned = spawnedMachines.size();
-                    LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
+                    LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
                 }
             }
@@ -4158 +4163 @@
     /* close the muxsem */
     if (muxSem != NULLHANDLE)
-        ::DosCloseMuxWaitSem (muxSem);
+        ::DosCloseMuxWaitSem(muxSem);
 
     /* release sets of machines if any */
@@ -4248 +4253 @@
                 if (that->m->llProcesses.size())
                 {
-                    LogFlowFunc (("UPDATE: child process count = %d\n",
-                                  that->m->llProcesses.size()));
+                    LogFlowFunc(("UPDATE: child process count = %d\n",
+                                 that->m->llProcesses.size()));
                     VirtualBox::Data::ProcessList::iterator it = that->m->llProcesses.begin();
                     while (it != that->m->llProcesses.end())
@@ -4258 +4263 @@
                         if (vrc == VINF_SUCCESS)
                         {
-                            LogFlowFunc (("pid %d (%x) was reaped, "
-                                          "status=%d, reason=%d\n",
-                                          pid, pid, status.iStatus,
-                                          status.enmReason));
+                            LogFlowFunc(("pid %d (%x) was reaped, status=%d, reason=%d\n",
+                                         pid, pid, status.iStatus,
+                                         status.enmReason));
                             it = that->m->llProcesses.erase(it);
                         }
                         else
                         {
-                            LogFlowFunc (("pid %d (%x) was NOT reaped, vrc=%Rrc\n",
-                                          pid, pid, vrc));
+                            LogFlowFunc(("pid %d (%x) was NOT reaped, vrc=%Rrc\n",
+                                         pid, pid, vrc));
                             if (vrc != VERR_PROCESS_RUNNING)
                             {
@@ -4300 +4304 @@
  */
 // static
-DECLCALLBACK(int) VirtualBox::AsyncEventHandler (RTTHREAD thread, void *pvUser)
+DECLCALLBACK(int) VirtualBox::AsyncEventHandler(RTTHREAD thread, void *pvUser)
 {
     LogFlowFuncEnter();
@@ -4311 +4315 @@
 
     // return the queue to the one who created this thread
-    *(static_cast <EventQueue **> (pvUser)) = eventQ;
+    *(static_cast <EventQueue **>(pvUser)) = eventQ;
     // signal that we're ready
-    RTThreadUserSignal (thread);
+    RTThreadUserSignal(thread);
 
     BOOL ok = TRUE;
     Event *event = NULL;
 
-    while ((ok = eventQ->waitForEvent (&event)) && event)
-        eventQ->handleEvent (event);
+    while ((ok = eventQ->waitForEvent(&event)) && event)
+        eventQ->handleEvent(event);
 
     AssertReturn(ok, VERR_GENERAL_FAILURE);
@@ -4348 +4352 @@
     if (!autoCaller.isOk())
     {
-        LogWarningFunc (("VirtualBox has been uninitialized (state=%d), "
-                         "the callback event is discarded!\n",
-                         autoCaller.state()));
+        LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the callback event is discarded!\n",
+                        autoCaller.state()));
         /* We don't need mVirtualBox any more, so release it */
         mVirtualBox = NULL;
@@ -4373 +4376 @@
 }
 
-//STDMETHODIMP VirtualBox::CreateDHCPServerForInterface (/*IHostNetworkInterface * aIinterface,*/ IDHCPServer ** aServer)
+//STDMETHODIMP VirtualBox::CreateDHCPServerForInterface(/*IHostNetworkInterface * aIinterface,*/ IDHCPServer ** aServer)
 //{
 //    return E_NOTIMPL;
 //}
 
-STDMETHODIMP VirtualBox::CreateDHCPServer (IN_BSTR aName, IDHCPServer ** aServer)
+STDMETHODIMP VirtualBox::CreateDHCPServer(IN_BSTR aName, IDHCPServer ** aServer)
 {
     CheckComArgStrNotEmptyOrNull(aName);
@@ -4388 +4391 @@
     ComObjPtr<DHCPServer> dhcpServer;
     dhcpServer.createObject();
-    HRESULT rc = dhcpServer->init (this, aName);
+    HRESULT rc = dhcpServer->init(this, aName);
     if (FAILED(rc)) return rc;
 
@@ -4433 +4436 @@
 }
 
-STDMETHODIMP VirtualBox::RemoveDHCPServer (IDHCPServer * aServer)
+STDMETHODIMP VirtualBox::RemoveDHCPServer(IDHCPServer * aServer)
 {
     CheckComArgNotNull(aServer);
@@ -4522 +4525 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    AutoCaller dhcpServerCaller (aDHCPServer);
+    AutoCaller dhcpServerCaller(aDHCPServer);
     AssertComRCReturn(dhcpServerCaller.rc(), dhcpServerCaller.rc());
 

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

@@ -568 +568 @@
 
       The next two diagrams demonstrate the process of taking a snapshot of a
-      powered off virtual machine and performing one of the "discard..."
-      operations, respectively.
+      powered off virtual machine, restoring the state to that as of a snapshot
+      or deleting a snapshot, respectively.
 
       <pre>
@@ -1249 +1249 @@
   <interface
      name="IVirtualBoxCallback" extends="$unknown"
-     uuid="9a65adf2-3ee6-406b-bca2-2b1fa05f0d0b"
+     uuid="7f6a65b6-ad5d-4a67-8872-0b11cb7ea95c"
      wsmap="suppress"
      >
@@ -1417 +1417 @@
     </method>
 
-    <method name="onSnapshotDiscarded">
-      <desc>
-        Snapshot of the given machine has been discarded.
+    <method name="onSnapshotDeleted">
+      <desc>
+        Snapshot of the given machine has been deleted.
 
         <note>
@@ -1434 +1434 @@
       <param name="snapshotId" type="uuid" mod="string" dir="in">
         <desc>
-          ID of the discarded snapshot. @c null means the current machine
-          state has been discarded (restored from the current snapshot).
+          ID of the deleted snapshot. @c null means the current machine
+          state has been deleted (restored from the current snapshot).
         </desc>
       </param>
@@ -3973 +3973 @@
       </param>
       <param name="id" type="uuid" mod="string" dir="in">
-        <desc>UUID of the snapshot to discard.</desc>
+        <desc>UUID of the snapshot to delete.</desc>
       </param>
       <param name="machineState" type="MachineState" dir="out">
@@ -4595 +4595 @@
         <ul>
           <li>settings of the machine are changed</li>
-          <li>the saved state is discarded</li>
-          <li>the current snapshot is discarded</li>
+          <li>the saved state is deleted</li>
+          <li>the current snapshot is deleted</li>
           <li>an attempt to execute the machine is made</li>
         </ul>
@@ -7134 +7134 @@
         this snapshot will be merged with the contents of their dependent child
         media to keep the medium chain valid (in other words, all changes
-        represented by media being discarded will be propagated to their child
+        represented by media being deleted will be propagated to their child
         medium). After that, this snapshot's differencing medium will be
         deleted. The parent of this snapshot will become a new parent for all
@@ -7142 +7142 @@
         become a new current snapshot. The current machine state is not directly
         affected in this case, except that currently attached differencing
-        media based on media of the discarded snapshot will be also merged as
+        media based on media of the deleted snapshot will be also merged as
         described above.
 
@@ -7153 +7153 @@
 
         <ul>
-          <li>Child media of all normal media of the discarded snapshot
+          <li>Child media of all normal media of the deleted snapshot
             must be accessible (see <link to="IMedium::state"/>) for this
             operation to succeed.  In particular, this means that all virtual
             machines, whose media are directly or indirectly based on the
-            media of discarded snapshot, must be powered off.</li>
+            media of deleted snapshot, must be powered off.</li>
 
           <li>You cannot delete the snapshot if a medium attached to it has
@@ -7174 +7174 @@
           Merging medium contents can be very time and disk space
           consuming, if these media are big in size and have many
-          children. However, if the snapshot being discarded is the last
+          children. However, if the snapshot being deleted is the last
           (head) snapshot on the branch, the operation will be rather
           quick.
@@ -7183 +7183 @@
       </desc>
       <param name="id" type="uuid" mod="string" dir="in">
-        <desc>UUID of the snapshot to discard.</desc>
+        <desc>UUID of the snapshot to delete.</desc>
       </param>
       <param name="progress" type="IProgress" dir="return">
@@ -7213 +7213 @@
           If the machine state is <link to="MachineState_Saved">Saved</link>
           prior to this operation, the saved state file will be implicitly
-          discarded (as if <link to="IConsole::forgetSavedState"/> were
+          deleted (as if <link to="IConsole::forgetSavedState"/> were
           called).
         </note>
@@ -8872 +8872 @@
       to the last snapshot in the chain. In a future version of VirtualBox,
       it will be possible to reset a machine's current state to that of an
-      earlier snapshot without discarding the current state so that it will be
+      earlier snapshot without deleting the current state so that it will be
       possible to create alternative snapshot paths in a snapshot tree.
 

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

@@ -141 +141 @@
             if (mObj && SUCCEEDED(mRC))
                 release();
+            else if (!mObj)
+            {
+                /* Fix up the success state when nothing is attached. Otherwise
+                 * there are a couple of assertion which would trigger. */
+                mRC = E_FAIL;
+            }
             mObj = aObj;
             add();

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2008 Sun Microsystems, Inc.
+ * Copyright (C) 2008-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -113 +113 @@
      * Returns @c true if the given machine state is a transient state. This is
      * a recommended way to detect if the VM is performing some potentially
-     * lengthy operation (such as starting, stopping, saving, discarding
+     * lengthy operation (such as starting, stopping, saving, deleting
      * snapshot, etc.). Note some (but not all) transitional states are also
      * online states (see #IsOnline()).

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

@@ -356 +356 @@
         SubMetric *mUsed;
         SubMetric *mAvailable;
-        SubMetric *mAllocVMM; 
-        SubMetric *mFreeVMM; 
+        SubMetric *mAllocVMM;
+        SubMetric *mFreeVMM;
         SubMetric *mBalloonVMM;
     };

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

@@ -1 +1 @@
 /*
- * Copyright (C) 2009 Sun Microsystems, Inc.
+ * Copyright (C) 2009-2010 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -56 +56 @@
     // public initializers/uninitializers only for internal purposes
     HRESULT init();
-    void uninit (bool aFinalRelease);
+    void uninit(bool aFinalRelease);
 
     // ILocalOwner methods
@@ -67 +67 @@
                                     BSTR *error, BOOL *changeAllowed);
     STDMETHOD(OnExtraDataChange)(IN_BSTR machineId, IN_BSTR key, IN_BSTR value);
-    STDMETHOD(OnMediumRegistered) (IN_BSTR mediaId, DeviceType_T mediaType,
-                                   BOOL registered);
+    STDMETHOD(OnMediumRegistered)(IN_BSTR mediaId, DeviceType_T mediaType,
+                                  BOOL registered);
     STDMETHOD(OnMachineRegistered)(IN_BSTR machineId, BOOL registered);
     STDMETHOD(OnSessionStateChange)(IN_BSTR machineId, SessionState_T state);
-    STDMETHOD(OnSnapshotTaken) (IN_BSTR aMachineId, IN_BSTR aSnapshotId);
-    STDMETHOD(OnSnapshotDiscarded) (IN_BSTR aMachineId, IN_BSTR aSnapshotId);
-    STDMETHOD(OnSnapshotChange) (IN_BSTR aMachineId, IN_BSTR aSnapshotId);
+    STDMETHOD(OnSnapshotTaken)(IN_BSTR aMachineId, IN_BSTR aSnapshotId);
+    STDMETHOD(OnSnapshotDeleted)(IN_BSTR aMachineId, IN_BSTR aSnapshotId);
+    STDMETHOD(OnSnapshotChange)(IN_BSTR aMachineId, IN_BSTR aSnapshotId);
     STDMETHOD(OnGuestPropertyChange)(IN_BSTR machineId, IN_BSTR key, IN_BSTR value, IN_BSTR flags);
 
@@ -83 +83 @@
     STDMETHOD(OnStateChange)(MachineState_T machineState);
     STDMETHOD(OnAdditionsStateChange)();
-    STDMETHOD(OnNetworkAdapterChange) (INetworkAdapter *aNetworkAdapter);
-    STDMETHOD(OnSerialPortChange) (ISerialPort *aSerialPort);
-    STDMETHOD(OnParallelPortChange) (IParallelPort *aParallelPort);
+    STDMETHOD(OnNetworkAdapterChange)(INetworkAdapter *aNetworkAdapter);
+    STDMETHOD(OnSerialPortChange)(ISerialPort *aSerialPort);
+    STDMETHOD(OnParallelPortChange)(IParallelPort *aParallelPort);
     STDMETHOD(OnVRDPServerChange)();
     STDMETHOD(OnRemoteDisplayInfoChange)();
     STDMETHOD(OnUSBControllerChange)();
-    STDMETHOD(OnUSBDeviceStateChange) (IUSBDevice *aDevice, BOOL aAttached,
+    STDMETHOD(OnUSBDeviceStateChange)(IUSBDevice *aDevice, BOOL aAttached,
                                        IVirtualBoxErrorInfo *aError);
-    STDMETHOD(OnSharedFolderChange) (Scope_T aScope);
-    STDMETHOD(OnStorageControllerChange) ();
+    STDMETHOD(OnSharedFolderChange)(Scope_T aScope);
+    STDMETHOD(OnStorageControllerChange)();
     STDMETHOD(OnMediumChange)(IMediumAttachment *iMediumAttachment);
     STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove);
     STDMETHOD(OnRuntimeError)(BOOL fFatal, IN_BSTR id, IN_BSTR message);
     STDMETHOD(OnCanShowWindow)(BOOL *canShow);
-    STDMETHOD(OnShowWindow) (ULONG64 *winId);
+    STDMETHOD(OnShowWindow)(ULONG64 *winId);
 
     // for VirtualBoxSupportErrorInfoImpl