Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 53362)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 53363)
@@ -298,6 +298,7 @@
                     || m_previousState != KMachineState_Teleporting))
             {
-                takePauseShotLive();
-                /* Fully repaint to pick up m_pauseShot: */
+                /* Take live pause-pixmap: */
+                takePausePixmapLive();
+                /* Fully repaint to pick up pause-pixmap: */
                 viewport()->update();
             }
@@ -309,6 +310,7 @@
             if (screenId() == 0)
             {
-                takePauseShotSnapshot();
-                /* Fully repaint to pick up m_pauseShot: */
+                /* Take snapshot pause-pixmap: */
+                takePausePixmapSnapshot();
+                /* Fully repaint to pick up pause-pixmap: */
                 viewport()->update();
             }
@@ -323,6 +325,6 @@
                 if (m_pFrameBuffer)
                 {
-                    /* Reset the pixmap to free memory: */
-                    resetPauseShot();
+                    /* Reset pause-pixmap: */
+                    resetPausePixmap();
                     /* Ask for full guest display update (it will also update
                      * the viewport through IFramebuffer::NotifyUpdate): */
@@ -687,40 +689,65 @@
 }
 
-void UIMachineView::takePauseShotLive()
-{
-    /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
-    QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
-    /* If TakeScreenShot fails or returns no image, just show a black image. */
-    shot.fill(0);
+void UIMachineView::resetPausePixmap()
+{
+    /* Reset pixmap: */
+    m_pausePixmap = QPixmap();
+}
+
+void UIMachineView::takePausePixmapLive()
+{
+    /* Prepare a screen-shot: */
+    QImage screenShot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
+    /* Which will be a 'black image' by default. */
+    screenShot.fill(0);
+
+    /* For separate process: */
     if (vboxGlobal().isSeparateProcess())
     {
-        QVector<BYTE> screenData = display().TakeScreenShotToArray(screenId(), shot.width(), shot.height(), KBitmapFormat_BGR0);
-
-        /* Make sure screen-data is OK: */
+        /* Take screen-data to array: */
+        const QVector<BYTE> screenData = display().TakeScreenShotToArray(screenId(), screenShot.width(), screenShot.height(), KBitmapFormat_BGR0);
+        /* And copy that data to screen-shot if it is Ok: */
         if (display().isOk() && !screenData.isEmpty())
-            memcpy(shot.bits(), screenData.data(), shot.width() * shot.height() * 4);
-    }
+            memcpy(screenShot.bits(), screenData.data(), screenShot.width() * screenShot.height() * 4);
+    }
+    /* For the same process: */
     else
-        display().TakeScreenShot(screenId(), shot.bits(), shot.width(), shot.height(), KBitmapFormat_BGR0);
-    /* TakeScreenShot() may fail if, e.g. the Paused notification was delivered
-     * after the machine execution was resumed. It's not fatal: */
-    if (display().isOk())
-        dimImage(shot);
-    m_pauseShot = QPixmap::fromImage(shot);
-}
-
-void UIMachineView::takePauseShotSnapshot()
-{
-    ULONG width = 0, height = 0;
-    QVector<BYTE> screenData = machine().ReadSavedScreenshotPNGToArray(0, width, height);
-    if (screenData.size() != 0)
-    {
-        ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-        BOOL fEnabled = true;
-        machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
-        QImage shot = QImage::fromData(screenData.data(), screenData.size(), "PNG").scaled(guestWidth > 0 ? QSize(guestWidth, guestHeight) : guestSizeHint());
-        dimImage(shot);
-        m_pauseShot = QPixmap::fromImage(shot);
-    }
+    {
+        /* Take the screen-shot directly: */
+        display().TakeScreenShot(screenId(), screenShot.bits(), screenShot.width(), screenShot.height(), KBitmapFormat_BGR0);
+    }
+
+    /* Dim screen-shot if it is Ok: */
+    if (display().isOk() && !screenShot.isNull())
+        dimImage(screenShot);
+
+    /* Finally copy the screen-shot to pause-pixmap: */
+    m_pausePixmap = QPixmap::fromImage(screenShot);
+}
+
+void UIMachineView::takePausePixmapSnapshot()
+{
+    /* Acquire the screen-data from the saved-state: */
+    ULONG uWidth = 0, uHeight = 0;
+    const QVector<BYTE> screenData = machine().ReadSavedScreenshotPNGToArray(0, uWidth, uHeight);
+
+    /* Make sure there is saved-state screen-data: */
+    if (screenData.isEmpty())
+        return;
+
+    /* Acquire the screen-data properties from the saved-state: */
+    ULONG uGuestOriginX = 0, uGuestOriginY = 0, uGuestWidth = 0, uGuestHeight = 0;
+    BOOL fEnabled = true;
+    machine().QuerySavedGuestScreenInfo(m_uScreenId, uGuestOriginX, uGuestOriginY, uGuestWidth, uGuestHeight, fEnabled);
+
+    /* Create a screen-shot on the basis of the screen-data we have in saved-state: */
+    QImage screenShot = QImage::fromData(screenData.data(), screenData.size(), "PNG").scaled(uGuestWidth > 0 ? QSize(uGuestWidth, uGuestHeight) : guestSizeHint());
+
+    /* Dim screen-shot if it is Ok: */
+    if (machine().isOk() && !screenShot.isNull())
+        dimImage(screenShot);
+
+    /* Finally copy the screen-shot to pause-pixmap: */
+    m_pausePixmap = QPixmap::fromImage(screenShot);
 }
 
@@ -810,6 +837,6 @@
 {
     /* Use pause-image if exists: */
-    if (!m_pauseShot.isNull())
-        return darwinToCGImageRef(&m_pauseShot);
+    if (!pausePixmap().isNull())
+        return darwinToCGImageRef(&pausePixmap());
 
     /* Create the image ref out of the frame-buffer: */
@@ -956,11 +983,11 @@
 {
     /* Use pause-image if exists: */
-    if (!m_pauseShot.isNull())
+    if (!pausePixmap().isNull())
     {
         /* We have a snapshot for the paused state: */
         QRect rect = pPaintEvent->rect().intersect(viewport()->rect());
         QPainter painter(viewport());
-        painter.drawPixmap(rect, m_pauseShot, QRect(rect.x() + contentsX(), rect.y() + contentsY(),
-                                                    rect.width(), rect.height()));
+        painter.drawPixmap(rect, pausePixmap(), QRect(rect.x() + contentsX(), rect.y() + contentsY(),
+                                                      rect.width(), rect.height()));
 #ifdef Q_WS_MAC
         /* Update the dock icon: */
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h	(revision 53362)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h	(revision 53363)
@@ -173,5 +173,4 @@
     ulong screenId() const { return m_uScreenId; }
     UIFrameBuffer* frameBuffer() const { return m_pFrameBuffer; }
-    const QPixmap& pauseShot() const { return m_pauseShot; }
     /** Atomically store the maximum guest resolution which we currently wish
      * to handle for @a maxGuestSize() to read.  Should be called if anything
@@ -193,8 +192,13 @@
     void storeGuestSizeHint(const QSize &size);
 
-    /* Protected helpers: */
-    virtual void takePauseShotLive();
-    virtual void takePauseShotSnapshot();
-    virtual void resetPauseShot() { m_pauseShot = QPixmap(); }
+    /** Returns the pause-pixmap: */
+    const QPixmap& pausePixmap() const { return m_pausePixmap; }
+    /** Resets the pause-pixmap. */
+    virtual void resetPausePixmap();
+    /** Acquires live pause-pixmap. */
+    virtual void takePausePixmapLive();
+    /** Acquires snapshot pause-pixmap. */
+    virtual void takePausePixmapSnapshot();
+
     /** The available area on the current screen for application windows. */
     virtual QRect workingArea() const = 0;
@@ -269,5 +273,6 @@
 #endif /* VBOX_WITH_VIDEOHWACCEL */
 
-    QPixmap m_pauseShot;
+    /** Holds the pause-pixmap. */
+    QPixmap m_pausePixmap;
 
     /* Friend classes: */
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 53362)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 53363)
@@ -71,5 +71,5 @@
 }
 
-void UIMachineViewScale::takePauseShotLive()
+void UIMachineViewScale::takePausePixmapLive()
 {
     /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
@@ -82,5 +82,5 @@
 }
 
-void UIMachineViewScale::takePauseShotSnapshot()
+void UIMachineViewScale::takePausePixmapSnapshot()
 {
     ULONG width = 0, height = 0;
@@ -97,8 +97,8 @@
 }
 
-void UIMachineViewScale::resetPauseShot()
+void UIMachineViewScale::resetPausePixmap()
 {
     /* Call the base class */
-    UIMachineView::resetPauseShot();
+    UIMachineView::resetPausePixmap();
 
     if (m_pPauseImage)
@@ -118,5 +118,5 @@
             QImage tmpImg = m_pPauseImage->scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
             dimImage(tmpImg);
-            m_pauseShot = QPixmap::fromImage(tmpImg);
+            m_pausePixmap = QPixmap::fromImage(tmpImg);
         }
     }
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.h
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.h	(revision 53362)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.h	(revision 53363)
@@ -37,7 +37,7 @@
     virtual ~UIMachineViewScale();
 
-    virtual void takePauseShotLive();
-    virtual void takePauseShotSnapshot();
-    virtual void resetPauseShot();
+    virtual void takePausePixmapLive();
+    virtual void takePausePixmapSnapshot();
+    virtual void resetPausePixmap();
     void scalePauseShot();