Index: /trunk/include/VBox/VBoxVideo.h
===================================================================
--- /trunk/include/VBox/VBoxVideo.h	(revision 50811)
+++ /trunk/include/VBox/VBoxVideo.h	(revision 50812)
@@ -1749,4 +1749,28 @@
 } VBOXCMDVBVA_CTL_ENABLE;
 
+#define VBOXCMDVBVA3DCTL_TYPE_CONNECT     1
+#define VBOXCMDVBVA3DCTL_TYPE_DISCONNECT  2
+#define VBOXCMDVBVA3DCTL_TYPE_CMD         3
+
+typedef struct VBOXCMDVBVA_3DCTL
+{
+    uint32_t u32Type;
+    uint32_t u32CmdClientId;
+} VBOXCMDVBVA_3DCTL;
+
+typedef struct VBOXCMDVBVA_3DCTL_CONNECT
+{
+    VBOXCMDVBVA_3DCTL Hdr;
+    uint32_t u32MajorVersion;
+    uint32_t u32MinorVersion;
+    uint64_t u64Pid;
+} VBOXCMDVBVA_3DCTL_CONNECT;
+
+typedef struct VBOXCMDVBVA_3DCTL_CMD
+{
+    VBOXCMDVBVA_3DCTL Hdr;
+    VBOXCMDVBVA_HDR Cmd;
+} VBOXCMDVBVA_3DCTL_CMD;
+
 #pragma pack()
 
Index: /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp
===================================================================
--- /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp	(revision 50811)
+++ /trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp	(revision 50812)
@@ -2213,5 +2213,5 @@
 }
 
-static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBOXCMDVBVA_CTL_ENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
+static int vdmaVBVACtlEnableDisableSubmitInternal(PVBOXVDMAHOST pVdma, VBVAENABLE *pEnable, PFNVBVAEXHOSTCTL_COMPLETE pfnComplete, void *pvComplete)
 {
     VBVAEXHOSTCTL* pHCtl = VBoxVBVAExHCtlCreate(&pVdma->CmdVbva, VBVAEXHOSTCTL_TYPE_GH_ENABLE_DISABLE);
@@ -2222,6 +2222,6 @@
     }
 
-    pHCtl->u.cmd.pu8Cmd = (uint8_t*)&pEnable->Enable;
-    pHCtl->u.cmd.cbCmd = sizeof (pEnable->Enable);
+    pHCtl->u.cmd.pu8Cmd = (uint8_t*)pEnable;
+    pHCtl->u.cmd.cbCmd = sizeof (*pEnable);
     int rc = vdmaVBVACtlSubmit(pVdma, pHCtl, VBVAEXHOSTCTL_SOURCE_GUEST, pfnComplete, pvComplete);
     if (!RT_SUCCESS(rc))
@@ -2236,5 +2236,5 @@
 {
     VBoxSHGSMICommandMarkAsynchCompletion(&pEnable->Hdr);
-    int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, pEnable, vboxCmdVBVACmdCtlGuestCompletion, pVdma);
+    int rc = vdmaVBVACtlEnableDisableSubmitInternal(pVdma, &pEnable->Enable, vboxCmdVBVACmdCtlGuestCompletion, pVdma);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
Index: /trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h
===================================================================
--- /trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h	(revision 50811)
+++ /trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h	(revision 50812)
@@ -572,4 +572,6 @@
 extern DECLEXPORT(int32_t) crVBoxServerHgcmDisable();
 
+extern int crVBoxServerHostCtl(VBOXCRCMDCTL *pCtl, uint32_t cbCtl);
+
 #ifdef __cplusplus
 }
Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp	(revision 50811)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp	(revision 50812)
@@ -962,5 +962,5 @@
  * We differentiate between a function handler for the guest and one for the host.
  */
-static int svcHostCallPerform(void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+static int svcHostCallPerform(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     int rc = VINF_SUCCESS;
@@ -1473,5 +1473,16 @@
 }
 
-static DECLCALLBACK(int) svcHostCall (void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int crVBoxServerHostCtl(VBOXCRCMDCTL *pCtl, uint32_t cbCtl)
+{
+    if ((cbCtl - sizeof (VBOXCRCMDCTL)) % sizeof(VBOXHGCMSVCPARM))
+    {
+        WARN(("invalid param size"));
+        return VERR_INVALID_PARAMETER;
+    }
+    uint32_t cParams = (cbCtl - sizeof (VBOXCRCMDCTL)) / sizeof (VBOXHGCMSVCPARM);
+    return svcHostCallPerform(pCtl->u32Function, cParams, (VBOXHGCMSVCPARM*)(pCtl + 1));
+}
+
+static DECLCALLBACK(int) svcHostCall(void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     switch (u32Function)
@@ -1497,24 +1508,34 @@
             }
 
-            if ((paParms->u.pointer.size - sizeof (VBOXCRCMDCTL)) % sizeof(VBOXHGCMSVCPARM))
-            {
-                WARN(("invalid param size"));
-                return VERR_INVALID_PARAMETER;
-            }
-
             VBOXCRCMDCTL *pCtl = (VBOXCRCMDCTL*)paParms->u.pointer.addr;
-            uint32_t cParams = (paParms->u.pointer.size - sizeof (VBOXCRCMDCTL)) / sizeof (VBOXHGCMSVCPARM);
-            return svcHostCallPerform(NULL, pCtl->u32Function, cParms, (VBOXHGCMSVCPARM*)(pCtl + 1));
-        }
-        case VBOXCRCMDCTL_TYPE_DISABLE:
-            AssertMsgFailed(("VBOXCRCMDCTL_TYPE_DISABLE\n"));
-            return VERR_NOT_IMPLEMENTED;
-        case VBOXCRCMDCTL_TYPE_ENABLE:
-            AssertMsgFailed(("VBOXCRCMDCTL_TYPE_ENABLE\n"));
-            return VERR_NOT_IMPLEMENTED;
+            switch (pCtl->enmType)
+            {
+                case VBOXCRCMDCTL_TYPE_HGCM:
+                {
+                    return crVBoxServerHostCtl(pCtl, paParms->u.pointer.size);
+                }
+                case VBOXCRCMDCTL_TYPE_DISABLE:
+                {
+                    if (paParms->u.pointer.size != sizeof (VBOXCRCMDCTL))
+                        WARN(("invalid param size"));
+                    return crVBoxServerHgcmDisable();
+                }
+                case VBOXCRCMDCTL_TYPE_ENABLE:
+                {
+                    if (paParms->u.pointer.size != sizeof (VBOXCRCMDCTL_ENABLE))
+                        WARN(("invalid param size"));
+                    VBOXCRCMDCTL_ENABLE *pEnable = (VBOXCRCMDCTL_ENABLE*)pCtl;
+                    return crVBoxServerHgcmEnable(pEnable->hRHCmd, pEnable->pfnRHCmd);
+                }
+                default:
+                    WARN(("invalid function"));
+                    return VERR_INVALID_PARAMETER;
+            }
+            WARN(("should not be here!"));
+            return VERR_INTERNAL_ERROR;
+        }
         default:
-            return svcHostCallPerform(NULL, u32Function, cParms, paParms);
-    }
-
+            return svcHostCallPerform(u32Function, cParms, paParms);
+    }
 }
 
Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h	(revision 50811)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h	(revision 50812)
@@ -116,5 +116,5 @@
 GLint crServerDispatchCreateContextEx(const char *dpyName, GLint visualBits, GLint shareCtx, GLint preloadCtxID, int32_t internalID);
 GLint crServerDispatchWindowCreateEx(const char *dpyName, GLint visBits, GLint preloadWinID);
-GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID);
+GLint crServerMuralInit(CRMuralInfo *mural, GLboolean fGuestWindow, GLint visBits, GLint preloadWinID);
 void crServerMuralTerm(CRMuralInfo *mural);
 GLboolean crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);
Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c	(revision 50811)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c	(revision 50812)
@@ -60,4 +60,6 @@
 int tearingdown = 0; /* can't be static */
 
+static DECLCALLBACK(int) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd);
+
 DECLINLINE(int32_t) crVBoxServerClientGet(uint32_t u32ClientID, CRClient **ppClient)
 {
@@ -528,4 +530,36 @@
 
     return GL_TRUE;
+}
+
+static int32_t crVBoxServerAddClientObj(uint32_t u32ClientID, CRClient **ppNewClient)
+{
+    CRClient *newClient;
+
+    if (cr_server.numClients>=CR_MAX_CLIENTS)
+    {
+        if (ppNewClient)
+            *ppNewClient = NULL;
+        return VERR_MAX_THRDS_REACHED;
+    }
+
+    newClient = (CRClient *) crCalloc(sizeof(CRClient));
+    crDebug("crServer: AddClient u32ClientID=%d", u32ClientID);
+
+    newClient->spu_id = 0;
+    newClient->currentCtxInfo = &cr_server.MainContextInfo;
+    newClient->currentContextNumber = -1;
+    newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
+                                        cr_server.tcpip_port,
+                                        cr_server.mtu, 0);
+    newClient->conn->u32ClientID = u32ClientID;
+
+    cr_server.clients[cr_server.numClients++] = newClient;
+
+    crServerAddToRunQueue(newClient);
+
+    if (ppNewClient)
+        *ppNewClient = newClient;
+
+    return VINF_SUCCESS;
 }
 
@@ -745,4 +779,15 @@
 }
 
+static int32_t crVBoxServerClientObjSetVersion(CRClient *pClient, uint32_t vMajor, uint32_t vMinor)
+{
+    pClient->conn->vMajor = vMajor;
+    pClient->conn->vMinor = vMinor;
+
+    if (vMajor != CR_PROTOCOL_VERSION_MAJOR
+        || vMinor != CR_PROTOCOL_VERSION_MINOR)
+        return VERR_NOT_SUPPORTED;
+    return VINF_SUCCESS;
+}
+
 int32_t crVBoxServerClientSetVersion(uint32_t u32ClientID, uint32_t vMajor, uint32_t vMinor)
 {
@@ -761,13 +806,12 @@
     if (!pClient) return VERR_INVALID_PARAMETER;
 
-    pClient->conn->vMajor = vMajor;
-    pClient->conn->vMinor = vMinor;
-
-    if (vMajor != CR_PROTOCOL_VERSION_MAJOR
-        || vMinor != CR_PROTOCOL_VERSION_MINOR)
-    {
-        return VERR_NOT_SUPPORTED;
-    }
-    else return VINF_SUCCESS;
+    return crVBoxServerClientObjSetVersion(pClient, vMajor, vMinor);
+}
+
+static int32_t crVBoxServerClientObjSetPID(CRClient *pClient, uint64_t pid)
+{
+    pClient->pid = pid;
+
+    return VINF_SUCCESS;
 }
 
@@ -788,7 +832,5 @@
     if (!pClient) return VERR_INVALID_PARAMETER;
 
-    pClient->pid = pid;
-
-    return VINF_SUCCESS;
+    return crVBoxServerClientObjSetPID(pClient, pid);
 }
 
@@ -1005,12 +1047,5 @@
             return NULL;
         }
-        id = crServerMuralInit(pMural,
-#ifdef RT_OS_DARWIN
-                /* tested on darwin only so far */
-                NULL
-#else
-                ""
-#endif
-                , visualBits, 0);
+        id = crServerMuralInit(pMural, GL_FALSE, visualBits, 0);
         if (id < 0)
         {
@@ -2891,8 +2926,35 @@
 }
 
+static void crVBoxServerDefaultContextSet()
+{
+    GLint spuWindow, spuCtx;
+
+    if (cr_server.MainContextInfo.SpuContext)
+    {
+        CRMuralInfo *pMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
+        if (!pMural)
+        {
+            WARN(("dummy mural is NULL"));
+            spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
+            spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
+        }
+        else
+        {
+            spuCtx = cr_server.MainContextInfo.SpuContext;
+            spuWindow = pMural->CreateInfo.realVisualBits;
+        }
+    }
+    else
+    {
+        spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
+        spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
+    }
+
+    cr_server.head_spu->dispatch_table.MakeCurrent(spuWindow, 0, spuCtx);
+}
 
 #ifdef VBOX_WITH_CRHGSMI
 
-static int32_t crVBoxServerCmdVbvaCrCmdProcess(struct VBOXCMDVBVA_CRCMD_CMD *pCmd)
+static int32_t crVBoxServerCmdVbvaCrCmdProcess(struct VBOXCMDVBVA_CRCMD_CMD *pCmd, uint32_t cbCmd)
 {
     int32_t rc;
@@ -2907,5 +2969,5 @@
     if (!g_pvVRamBase)
     {
-        crWarning("g_pvVRamBase is not initialized");
+        WARN(("g_pvVRamBase is not initialized"));
         return VERR_INVALID_STATE;
     }
@@ -2913,9 +2975,15 @@
     if (!cBuffers)
     {
-        crWarning("zero buffers passed in!");
+        WARN(("zero buffers passed in!"));
         return VERR_INVALID_PARAMETER;
     }
 
     cParams = cBuffers-1;
+
+    if (cbCmd != RT_OFFSETOF(VBOXCMDVBVA_CRCMD_CMD, aBuffers[cBuffers]))
+    {
+        WARN(("invalid buffer size"));
+        return VERR_INVALID_PARAMETER;
+    }
 
     cbHdr = pCmd->aBuffers[0].cbBuffer;
@@ -2923,5 +2991,5 @@
     if (!pHdr)
     {
-        crWarning("invalid header buffer!");
+        WARN(("invalid header buffer!"));
         return VERR_INVALID_PARAMETER;
     }
@@ -2929,5 +2997,5 @@
     if (cbHdr < sizeof (*pHdr))
     {
-        crWarning("invalid header buffer size!");
+        WARN(("invalid header buffer size!"));
         return VERR_INVALID_PARAMETER;
     }
@@ -3196,16 +3264,71 @@
 {
     cr_server.CrCmdClientInfo = *pInfo;
+
+    crVBoxServerDefaultContextSet();
+
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) crVBoxCrCmdDisable(HVBOXCRCMDSVR hSvr)
+{
+    cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
+
+    memset(&cr_server.CrCmdClientInfo, 0, sizeof (cr_server.CrCmdClientInfo));
+
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) crVBoxCrCmdHostCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
+{
+    return crVBoxServerHostCtl((VBOXCRCMDCTL*)pCmd, cbCmd);
+}
+
+static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
+{
+    VBOXCMDVBVA_3DCTL *pCtl = (VBOXCMDVBVA_3DCTL*)pCmd;
+    if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL))
+    {
+        WARN(("invalid buffer size"));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    switch (pCtl->u32Type)
+    {
+        case VBOXCMDVBVA3DCTL_TYPE_CONNECT:
+        {
+            VBOXCMDVBVA_3DCTL_CONNECT *pConnect = (VBOXCMDVBVA_3DCTL_CONNECT*)pCtl;
+
+            return VERR_NOT_SUPPORTED;
+        }
+        case VBOXCMDVBVA3DCTL_TYPE_DISCONNECT:
+        {
+            return VERR_NOT_SUPPORTED;
+        }
+        case VBOXCMDVBVA3DCTL_TYPE_CMD:
+        {
+            VBOXCMDVBVA_3DCTL_CMD *p3DCmd;
+            if (cbCmd < sizeof (VBOXCMDVBVA_3DCTL_CMD))
+            {
+                WARN(("invalid size"));
+                return VERR_INVALID_PARAMETER;
+            }
+
+            p3DCmd = (VBOXCMDVBVA_3DCTL_CMD*)pCmd;
+
+            return crVBoxCrCmdCmd(NULL, &p3DCmd->Cmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_3DCTL_CMD, Cmd));
+        }
+        default:
+            WARN(("invalid function"));
+            return VERR_INVALID_PARAMETER;
+    }
+}
+
+static DECLCALLBACK(int) crVBoxCrCmdSaveState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM)
+{
     AssertFailed();
     return VERR_NOT_IMPLEMENTED;
 }
 
-static DECLCALLBACK(int) crVBoxCrCmdDisable(HVBOXCRCMDSVR hSvr)
-{
-    AssertFailed();
-    memset(&cr_server.CrCmdClientInfo, 0, sizeof (cr_server.CrCmdClientInfo));
-    return VERR_NOT_IMPLEMENTED;
-}
-
-static DECLCALLBACK(int) crVBoxCrCmdHostCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
+static DECLCALLBACK(int) crVBoxCrCmdLoadState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM, uint32_t u32Version)
 {
     AssertFailed();
@@ -3213,22 +3336,4 @@
 }
 
-static DECLCALLBACK(int) crVBoxCrCmdGuestCtl(HVBOXCRCMDSVR hSvr, uint8_t* pCmd, uint32_t cbCmd)
-{
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-static DECLCALLBACK(int) crVBoxCrCmdSaveState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM)
-{
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-static DECLCALLBACK(int) crVBoxCrCmdLoadState(HVBOXCRCMDSVR hSvr, PSSMHANDLE pSSM, uint32_t u32Version)
-{
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
 
 static DECLCALLBACK(int) crVBoxCrCmdCmd(HVBOXCRCMDSVR hSvr, PVBOXCMDVBVA_HDR pCmd, uint32_t cbCmd)
@@ -3239,7 +3344,16 @@
         case VBOXCMDVBVA_OPTYPE_CRCMD:
         {
-            VBOXCMDVBVA_CRCMD *pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
-            VBOXCMDVBVA_CRCMD_CMD *pCrCmd = &pCrCmdDr->Cmd;
-            int rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd);
+            VBOXCMDVBVA_CRCMD *pCrCmdDr;
+            VBOXCMDVBVA_CRCMD_CMD *pCrCmd;
+            int rc;
+            pCrCmdDr = (VBOXCMDVBVA_CRCMD*)pCmd;
+            pCrCmd = &pCrCmdDr->Cmd;
+            if (cbCmd < sizeof (VBOXCMDVBVA_CRCMD))
+            {
+                WARN(("invalid buffer size"));
+                pCmd->u.i8Result = -1;
+                break;
+            }
+            rc = crVBoxServerCmdVbvaCrCmdProcess(pCrCmd, cbCmd - RT_OFFSETOF(VBOXCMDVBVA_CRCMD, Cmd));
             if (RT_SUCCESS(rc))
             {
@@ -3249,5 +3363,5 @@
             else
             {
-                crWarning("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc);
+                WARN(("crVBoxServerCmdVbvaCrCmdProcess failed, rc %d", rc));
                 pCmd->u.i8Result = -1;
             }
@@ -3295,5 +3409,5 @@
     if (!g_pvVRamBase)
     {
-        crWarning("g_pvVRamBase is not initialized");
+        WARN(("g_pvVRamBase is not initialized"));
 
         crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_STATE);
@@ -3303,5 +3417,5 @@
     if (!cBuffers)
     {
-        crWarning("zero buffers passed in!");
+        WARN(("zero buffers passed in!"));
 
         crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
@@ -3310,4 +3424,13 @@
 
     cParams = cBuffers-1;
+
+#if 0
+    if (cbCmd != RT_OFFSETOF(VBOXCMDVBVA_CRCMD_CMD, aBuffers[cBuffers]))
+    {
+        WARN(("invalid buffer size"));
+        crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
+        return VINF_SUCCESS;
+    }
+#endif
 
     cbHdr = pCmd->aBuffers[0].cbBuffer;
@@ -3315,5 +3438,5 @@
     if (!pHdr)
     {
-        crWarning("invalid header buffer!");
+        WARN(("invalid header buffer!"));
 
         crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
@@ -3323,5 +3446,5 @@
     if (cbHdr < sizeof (*pHdr))
     {
-        crWarning("invalid header buffer size!");
+        WARN(("invalid header buffer size!"));
 
         crServerCrHgsmiCmdComplete(pCmd, VERR_INVALID_PARAMETER);
@@ -3658,32 +3781,4 @@
 }
 
-void crVBoxServerDefaultContextSet()
-{
-    GLint spuWindow, spuCtx;
-
-    if (cr_server.MainContextInfo.SpuContext)
-    {
-        CRMuralInfo *pMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.realVisualBits);
-        if (!pMural)
-        {
-            WARN(("dummy mural is NULL"));
-            spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
-            spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
-        }
-        else
-        {
-            spuCtx = cr_server.MainContextInfo.SpuContext;
-            spuWindow = pMural->CreateInfo.realVisualBits;
-        }
-    }
-    else
-    {
-        spuCtx = CR_RENDER_DEFAULT_CONTEXT_ID;
-        spuWindow = CR_RENDER_DEFAULT_WINDOW_ID;
-    }
-
-    cr_server.head_spu->dispatch_table.MakeCurrent(spuWindow, 0, spuCtx);
-}
-
 int32_t crVBoxServerHgcmEnable(HVBOXCRCMDCTL_REMAINING_HOST_COMMAND hRHCmd, PFNVBOXCRCMDCTL_REMAINING_HOST_COMMAND pfnRHCmd)
 {
Index: /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c
===================================================================
--- /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c	(revision 50811)
+++ /trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c	(revision 50812)
@@ -19,5 +19,5 @@
 }
 
-GLint crServerMuralInit(CRMuralInfo *mural, const char *dpyName, GLint visBits, GLint preloadWinID)
+GLint crServerMuralInit(CRMuralInfo *mural, GLboolean fGuestWindow, GLint visBits, GLint preloadWinID)
 {
     CRMuralInfo *defaultMural;
@@ -26,4 +26,5 @@
     GLint spuWindow = 0;
     GLint realVisBits = visBits;
+    const char *dpyName = "";
 
     crMemset(mural, 0, sizeof (*mural));
@@ -32,5 +33,17 @@
         realVisBits = cr_server.fVisualBitsDefault;
 
-    if (!dpyName)
+#ifdef RT_OS_DARWIN
+    if (fGuestWindow)
+    {
+        CRMuralInfo *dummy = crServerGetDummyMural(visBits);
+        if (!dummy)
+        {
+            WARN(("crServerGetDummyMural failed"));
+            return -1;
+        }
+        spuWindow = dummy->spuWindow;
+    }
+    else
+#endif
     {
         /*
@@ -41,14 +54,4 @@
             return spuWindow;
         }
-    }
-    else
-    {
-        CRMuralInfo *dummy = crServerGetDummyMural(visBits);
-        if (!dummy)
-        {
-            WARN(("crServerGetDummyMural failed"));
-            return -1;
-        }
-        spuWindow = dummy->spuWindow;
     }
 
@@ -134,5 +137,5 @@
     }
 
-    windowID = crServerMuralInit(mural, dpyName, visBits, preloadWinID);
+    windowID = crServerMuralInit(mural, GL_TRUE, visBits, preloadWinID);
     if (windowID < 0)
     {