Create a child window in SurfaceD3D when needed.

src/libANGLE/renderer/d3d/DisplayD3D.cpp

@@ -140,8 +140,37 @@ egl::Error CreateRendererD3D(egl::Display *display, RendererD3D **outRenderer)
     return result;
 }
 
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+namespace
+{
+
+LRESULT CALLBACK IntermediateWindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch (message)
+    {
+      case WM_ERASEBKGND:
+        // Prevent windows from erasing the background.
+        return 1;
+      case WM_PAINT:
+        // Do not paint anything.
+        PAINTSTRUCT paint;
+        if (BeginPaint(window, &paint))
+        {
+            EndPaint(window, &paint);
+        }
+        return 0;
+    }
+
+    return DefWindowProc(window, message, wParam, lParam);
+}
+
+}
+#endif
+
 DisplayD3D::DisplayD3D()
-    : mRenderer(nullptr),
+    : mDisplay(nullptr),
+      mRenderer(nullptr),
+      mChildWindowClass(0),
       mDevice(nullptr)
 {
 }
@@ -262,13 +291,47 @@ egl::Error DisplayD3D::initialize(egl::Display *display)
 
     ASSERT(mDevice == nullptr);
     mDevice = new DeviceD3D(mRenderer);
-    return error;
+
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    // Work around compile error from not defining "UNICODE" while Chromium does
+    const LPSTR idcArrow = MAKEINTRESOURCEA(32512);
+
+    std::string className = FormatString("ANGLE DisplayD3D 0x%0.8p Child Window Class", mDisplay);
+
+    WNDCLASSA childWindowClassDesc = { 0 };
+    childWindowClassDesc.style = CS_OWNDC;
+    childWindowClassDesc.lpfnWndProc = IntermediateWindowProc;
+    childWindowClassDesc.cbClsExtra = 0;
+    childWindowClassDesc.cbWndExtra = 0;
+    childWindowClassDesc.hInstance = GetModuleHandle(nullptr);
+    childWindowClassDesc.hIcon = nullptr;
+    childWindowClassDesc.hCursor = LoadCursorA(nullptr, idcArrow);
+    childWindowClassDesc.hbrBackground = 0;
+    childWindowClassDesc.lpszMenuName = nullptr;
+    childWindowClassDesc.lpszClassName = className.c_str();
+
+    mChildWindowClass = RegisterClassA(&childWindowClassDesc);
+    if (!mChildWindowClass)
+    {
+        return egl::Error(EGL_NOT_INITIALIZED, "Failed to register child window class.");
+    }
+#endif
+
+    return egl::Error(EGL_SUCCESS);
 }
 
 void DisplayD3D::terminate()
 {
     SafeDelete(mDevice);
     SafeDelete(mRenderer);
+
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    if (mChildWindowClass != 0)
+    {
+        UnregisterClassA(reinterpret_cast<const char*>(mChildWindowClass), NULL);
+        mChildWindowClass = 0;
+    }
+#endif
 }
 
 egl::ConfigSet DisplayD3D::generateConfigs() const
@@ -370,4 +433,9 @@ void DisplayD3D::generateCaps(egl::Caps *outCaps) const
     outCaps->textureNPOT = mRenderer->getRendererExtensions().textureNPOT;
 }
 
+ATOM DisplayD3D::getChildWindowClass() const
+{
+    return mChildWindowClass;
+}
+
 }

src/libANGLE/renderer/d3d/DisplayD3D.h

@@ -50,6 +50,8 @@ class DisplayD3D : public DisplayImpl
 
     std::string getVendorString() const override;
 
+    ATOM getChildWindowClass() const;
+
   private:
     void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
     void generateCaps(egl::Caps *outCaps) const override;
@@ -57,6 +59,7 @@ class DisplayD3D : public DisplayImpl
     egl::Display *mDisplay;
 
     rx::RendererD3D *mRenderer;
+    ATOM mChildWindowClass;
 
     DeviceImpl *mDevice;
 };

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -97,6 +97,7 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     // Direct3D Specific methods
     virtual GUID getAdapterIdentifier() const = 0;
 
+    virtual bool shouldCreateChildWindowForSurface(EGLNativeWindowType window) const = 0;
     virtual SwapChainD3D *createSwapChain(NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
 
     virtual gl::Error generateSwizzle(gl::Texture *texture) = 0;

src/libANGLE/renderer/d3d/SurfaceD3D.cpp

@@ -10,6 +10,7 @@
 
 #include "libANGLE/Display.h"
 #include "libANGLE/Surface.h"
+#include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/SwapChainD3D.h"
 
@@ -45,6 +46,7 @@ SurfaceD3D::SurfaceD3D(RendererD3D *renderer, egl::Display *display, const egl::
       mNativeWindow(window),
       mWidth(width),
       mHeight(height),
+      mChildWindow(nullptr),
       mSwapInterval(1),
       mShareHandle(reinterpret_cast<HANDLE*>(shareHandle))
 {
@@ -53,6 +55,13 @@ SurfaceD3D::SurfaceD3D(RendererD3D *renderer, egl::Display *display, const egl::
 SurfaceD3D::~SurfaceD3D()
 {
     releaseSwapChain();
+
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    if (mChildWindow.getNativeWindow() != nullptr)
+    {
+        DestroyWindow(mChildWindow.getNativeWindow());
+    }
+#endif
 }
 
 void SurfaceD3D::releaseSwapChain()
@@ -64,6 +73,44 @@ egl::Error SurfaceD3D::initialize()
 {
     if (mNativeWindow.getNativeWindow())
     {
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+        if (mRenderer->shouldCreateChildWindowForSurface(mNativeWindow.getNativeWindow()))
+        {
+            RECT rect;
+            if (!mNativeWindow.getClientRect(&rect))
+            {
+                return egl::Error(EGL_BAD_NATIVE_WINDOW, "Failed to get the size of the native window.");
+            }
+
+            DisplayD3D *displayD3D = GetImplAs<DisplayD3D>(mDisplay);
+            ATOM windowClass = displayD3D->getChildWindowClass();
+
+            HWND childWindow = CreateWindowExA(WS_EX_NOPARENTNOTIFY,
+                                               reinterpret_cast<const char*>(windowClass),
+                                               "ANGLE Intermediate Surface Window",
+                                               WS_CHILDWINDOW | WS_DISABLED | WS_VISIBLE,
+                                               0,
+                                               0,
+                                               rect.right - rect.left,
+                                               rect.bottom - rect.top,
+                                               mNativeWindow.getNativeWindow(),
+                                               nullptr,
+                                               nullptr,
+                                               nullptr);
+            if (!childWindow)
+            {
+                return egl::Error(EGL_NOT_INITIALIZED, "Failed to create child window.");
+            }
+
+            mChildWindow = NativeWindow(childWindow);
+
+            if (!mChildWindow.initialize())
+            {
+                return egl::Error(EGL_BAD_SURFACE);
+            }
+        }
+#endif
+
         if (!mNativeWindow.initialize())
         {
             return egl::Error(EGL_BAD_SURFACE);
@@ -116,7 +163,8 @@ egl::Error SurfaceD3D::resetSwapChain()
         height = mHeight;
     }
 
-    mSwapChain = mRenderer->createSwapChain(mNativeWindow, mShareHandle, mRenderTargetFormat, mDepthStencilFormat);
+    const NativeWindow &window = (mChildWindow.getNativeWindow() != nullptr) ? mChildWindow : mNativeWindow;
+    mSwapChain = mRenderer->createSwapChain(window, mShareHandle, mRenderTargetFormat, mDepthStencilFormat);
     if (!mSwapChain)
     {
         return egl::Error(EGL_BAD_ALLOC);
@@ -152,6 +200,17 @@ egl::Error SurfaceD3D::resizeSwapChain(int backbufferWidth, int backbufferHeight
     mWidth = backbufferWidth;
     mHeight = backbufferHeight;
 
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    if (mChildWindow.getNativeWindow())
+    {
+        // Resize the child window
+        if (!MoveWindow(mChildWindow.getNativeWindow(), 0, 0, mWidth, mHeight, FALSE))
+        {
+            return egl::Error(EGL_BAD_SURFACE, "Failed to move the child window.");
+        }
+    }
+#endif
+
     return egl::Error(EGL_SUCCESS);
 }
 

src/libANGLE/renderer/d3d/SurfaceD3D.h

@@ -77,6 +77,8 @@ class SurfaceD3D : public SurfaceImpl
     EGLint mWidth;
     EGLint mHeight;
 
+    NativeWindow mChildWindow;
+
     EGLint mSwapInterval;
 
     HANDLE mShareHandle;

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -389,42 +389,6 @@ egl::Error Renderer11::initialize()
         ANGLE_HISTOGRAM_TIMES("GPU.ANGLE.D3D11CreateDeviceMS", createDeviceMS);
     }
 
-#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
-#if !ANGLE_SKIP_DXGI_1_2_CHECK
-    {
-        TRACE_EVENT0("gpu.angle", "Renderer11::initialize (DXGICheck)");
-        // In order to create a swap chain for an HWND owned by another process, DXGI 1.2 is required.
-        // The easiest way to check is to query for a IDXGIDevice2.
-        bool requireDXGI1_2 = false;
-        HWND hwnd = WindowFromDC(mDisplay->getNativeDisplayId());
-        if (hwnd)
-        {
-            DWORD currentProcessId = GetCurrentProcessId();
-            DWORD wndProcessId;
-            GetWindowThreadProcessId(hwnd, &wndProcessId);
-            requireDXGI1_2 = (currentProcessId != wndProcessId);
-        }
-        else
-        {
-            requireDXGI1_2 = true;
-        }
-
-        if (requireDXGI1_2)
-        {
-            IDXGIDevice2 *dxgiDevice2 = NULL;
-            result = mDevice->QueryInterface(__uuidof(IDXGIDevice2), (void**)&dxgiDevice2);
-            if (FAILED(result))
-            {
-                return egl::Error(EGL_NOT_INITIALIZED,
-                                  D3D11_INIT_INCOMPATIBLE_DXGI,
-                                  "DXGI 1.2 required to present to HWNDs owned by another process.");
-            }
-            SafeRelease(dxgiDevice2);
-        }
-    }
-#endif
-#endif
-
     {
         TRACE_EVENT0("gpu.angle", "Renderer11::initialize (ComQueries)");
         // Cast the DeviceContext to a DeviceContext1.
@@ -714,6 +678,35 @@ gl::Error Renderer11::finish()
     return gl::Error(GL_NO_ERROR);
 }
 
+bool Renderer11::shouldCreateChildWindowForSurface(EGLNativeWindowType window) const
+{
+#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
+    // In order to create a swap chain for an HWND owned by another process, DXGI 1.2 is required.
+    // The easiest way to check is to query for a IDXGIDevice2.
+    DWORD currentProcessId = GetCurrentProcessId();
+    DWORD wndProcessId;
+    GetWindowThreadProcessId(window, &wndProcessId);
+    if (currentProcessId == wndProcessId)
+    {
+        // Window is from this process, can always create a swap chain for it
+        return false;
+    }
+
+    IDXGIDevice2 *dxgiDevice2 = d3d11::DynamicCastComObject<IDXGIDevice2>(mDevice);
+    if (dxgiDevice2 != nullptr)
+    {
+        // DXGI 1.2 is available, can create a swap chain for this cross-process window
+        SafeRelease(dxgiDevice2);
+        return false;
+    }
+
+    // DXGI 1.2 is not available, need to create a child window.
+    return true;
+#else
+    return false;
+#endif
+}
+
 SwapChainD3D *Renderer11::createSwapChain(NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat)
 {
     return new SwapChain11(this, nativeWindow, shareHandle, backBufferFormat, depthBufferFormat);

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -95,6 +95,7 @@ class Renderer11 : public RendererD3D
     gl::Error flush() override;
     gl::Error finish() override;
 
+    bool shouldCreateChildWindowForSurface(EGLNativeWindowType window) const override;
     virtual SwapChainD3D *createSwapChain(NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
 
     virtual gl::Error generateSwizzle(gl::Texture *texture);

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -637,6 +637,12 @@ gl::Error Renderer9::finish()
     return gl::Error(GL_NO_ERROR);
 }
 
+bool Renderer9::shouldCreateChildWindowForSurface(EGLNativeWindowType window) const
+{
+    // D3D9 never needs to create child windows
+    return false;
+}
+
 SwapChainD3D *Renderer9::createSwapChain(NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat)
 {
     return new SwapChain9(this, nativeWindow, shareHandle, backBufferFormat, depthBufferFormat);

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -75,6 +75,7 @@ class Renderer9 : public RendererD3D
     gl::Error flush() override;
     gl::Error finish() override;
 
+    bool shouldCreateChildWindowForSurface(EGLNativeWindowType window) const override;
     virtual SwapChainD3D *createSwapChain(NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat);
 
     gl::Error allocateEventQuery(IDirect3DQuery9 **outQuery);