Index: trunk/src/VBox/Main/src-all/EventImpl.cpp
===================================================================
--- trunk/src/VBox/Main/src-all/EventImpl.cpp	(revision 39712)
+++ trunk/src/VBox/Main/src-all/EventImpl.cpp	(revision 39713)
@@ -430,5 +430,5 @@
 class EventMapList
 {
-    EventMapRecord* mHead;
+    EventMapRecord *mHead;
     uint32_t        mSize;
 public:
@@ -440,10 +440,10 @@
     ~EventMapList()
     {
-        EventMapRecord* aCur = mHead;
-        while (aCur)
-        {
-            EventMapRecord* aNext = aCur->mNext;
-            aCur->release();
-            aCur = aNext;
+        EventMapRecord *pCur = mHead;
+        while (pCur)
+        {
+            EventMapRecord *pNext = pCur->mNext;
+            pCur->release();
+            pCur = pNext;
         }
     }
@@ -454,11 +454,11 @@
      * will always complete.
      */
-    void add(ListenerRecord* aRec)
-    {
-        EventMapRecord* aNew = new EventMapRecord(aRec);
-        aNew->mNext = mHead;
+    void add(ListenerRecord *aRec)
+    {
+        EventMapRecord *pNew = new EventMapRecord(aRec);
+        pNew->mNext = mHead;
         if (mHead)
-            mHead->mPrev = aNew;
-        mHead = aNew;
+            mHead->mPrev = pNew;
+        mHead = pNew;
         mSize++;
     }
@@ -469,19 +469,19 @@
      * enough for iterators to allow long and probably intrusive callbacks.
      */
-    void remove(ListenerRecord* aRec)
-    {
-        EventMapRecord* aCur = mHead;
-        while (aCur)
-        {
-            EventMapRecord* aNext = aCur->mNext;
-            if (aCur->ref() == aRec)
+    void remove(ListenerRecord *aRec)
+    {
+        EventMapRecord *pCur = mHead;
+        while (pCur)
+        {
+            EventMapRecord* aNext = pCur->mNext;
+            if (pCur->ref() == aRec)
             {
-                if (aCur == mHead)
+                if (pCur == mHead)
                     mHead = aNext;
-                aCur->kill();
+                pCur->kill();
                 mSize--;
                 // break?
             }
-            aCur = aNext;
+            pCur = aNext;
         }
     }
@@ -494,60 +494,60 @@
     struct iterator
     {
-      EventMapRecord* mCur;
-
-      iterator()
-      : mCur(0)
-      {}
-
-      explicit
-      iterator(EventMapRecord* aCur)
-      : mCur(aCur)
-      {
-          // Prevent element removal, till we're at it
-          if (mCur)
-              mCur->addRef();
-      }
-
-      ~iterator()
-      {
-          if (mCur)
-              mCur->release();
-      }
-
-      ListenerRecord*
-      operator*() const
-      {
-          return mCur->ref();
-      }
-
-      EventMapList::iterator&
-      operator++()
-      {
-          EventMapRecord* aPrev = mCur;
-          do {
-              mCur = mCur->mNext;
-          } while (mCur && !mCur->mAlive);
-
-          // now we can safely release previous element
-          aPrev->release();
-
-          // And grab the new current
-          if (mCur)
-              mCur->addRef();
-
-          return *this;
-      }
-
-      bool
-      operator==(const EventMapList::iterator& aOther) const
-      {
-          return mCur == aOther.mCur;
-      }
-
-      bool
-      operator!=(const EventMapList::iterator& aOther) const
-      {
-          return mCur != aOther.mCur;
-      }
+        EventMapRecord *mCur;
+
+        iterator()
+            : mCur(0)
+        {}
+
+        explicit
+        iterator(EventMapRecord *aCur)
+            : mCur(aCur)
+        {
+            // Prevent element removal, till we're at it
+            if (mCur)
+                mCur->addRef();
+        }
+
+        ~iterator()
+        {
+            if (mCur)
+                mCur->release();
+        }
+
+        ListenerRecord *
+        operator*() const
+        {
+            return mCur->ref();
+        }
+
+        EventMapList::iterator &
+        operator++()
+        {
+            EventMapRecord *pPrev = mCur;
+            do {
+                mCur = mCur->mNext;
+            } while (mCur && !mCur->mAlive);
+
+            // now we can safely release previous element
+            pPrev->release();
+
+            // And grab the new current
+            if (mCur)
+                mCur->addRef();
+
+            return *this;
+        }
+
+        bool
+        operator==(const EventMapList::iterator& aOther) const
+        {
+            return mCur == aOther.mCur;
+        }
+
+        bool
+        operator!=(const EventMapList::iterator& aOther) const
+        {
+            return mCur != aOther.mCur;
+        }
     };
 
@@ -803,5 +803,5 @@
         {
             aAlock.release();
-            rc =  mListener->HandleEvent(aEvent);
+            rc = mListener->HandleEvent(aEvent);
 #ifdef RT_OS_WINDOWS
             Assert(rc != RPC_E_WRONG_THREAD);
@@ -813,6 +813,5 @@
         return rc;
     }
-    else
-        return enqueue(aEvent);
+    return enqueue(aEvent);
 }
 
@@ -1032,5 +1031,5 @@
         AssertComRCReturn(hrc, hrc);
 
-        EventMapList& listeners = m->mEvMap[(int)evType-FirstEvent];
+        EventMapList &listeners = m->mEvMap[(int)evType - FirstEvent];
 
         /* Anyone interested in this event? */
@@ -1051,6 +1050,7 @@
             pit = m->mPendingMap.find(aEvent);
         }
-        for(EventMapList::iterator it = listeners.begin();
-            it != listeners.end(); ++it)
+        for (EventMapList::iterator it = listeners.begin();
+             it != listeners.end();
+             ++it)
         {
             HRESULT cbRc;
