Make sure to destroy all resources in DisplayWGL if initialization fails.

src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp

@@ -76,8 +76,7 @@ DisplayWGL::DisplayWGL(const egl::DisplayState &state)
       mDxgiModule(nullptr),
       mD3d11Module(nullptr),
       mD3D11DeviceHandle(nullptr),
-      mD3D11Device(nullptr),
-      mDisplay(nullptr)
+      mD3D11Device(nullptr)
 {
 }
 
@@ -87,8 +86,18 @@ DisplayWGL::~DisplayWGL()
 
 egl::Error DisplayWGL::initialize(egl::Display *display)
 {
-    mDisplay = display;
+    egl::Error error = initializeImpl(display);
+    if (error.isError())
+    {
+        destroy();
+        return error;
+    }
 
+    return DisplayGL::initialize(display);
+}
+
+egl::Error DisplayWGL::initializeImpl(egl::Display *display)
+{
     mOpenGLModule = LoadLibraryA("opengl32.dll");
     if (!mOpenGLModule)
     {
@@ -105,7 +114,7 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
     const LPSTR idcArrow = MAKEINTRESOURCEA(32512);
 
     std::ostringstream stream;
-    stream << "ANGLE DisplayWGL " << gl::FmtHex(mDisplay) << " Intermediate Window Class";
+    stream << "ANGLE DisplayWGL " << gl::FmtHex(display) << " Intermediate Window Class";
     std::string className = stream.str();
 
     WNDCLASSA intermediateClassDesc = { 0 };
@@ -122,22 +131,15 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
     mWindowClass = RegisterClassA(&intermediateClassDesc);
     if (!mWindowClass)
     {
-        return egl::EglNotInitialized() << "Failed to register intermediate OpenGL window class, "
-                                        << gl::FmtErr(HRESULT_CODE(GetLastError()));
-    }
-
-    HWND dummyWindow = CreateWindowExA(0,
-                                       reinterpret_cast<const char *>(mWindowClass),
-                                       "ANGLE Dummy Window",
-                                       WS_OVERLAPPEDWINDOW,
-                                       CW_USEDEFAULT,
-                                       CW_USEDEFAULT,
-                                       CW_USEDEFAULT,
-                                       CW_USEDEFAULT,
-                                       nullptr,
-                                       nullptr,
-                                       nullptr,
-                                       nullptr);
+        return egl::EglNotInitialized()
+               << "Failed to register intermediate OpenGL window class \"" << className.c_str()
+               << "\":" << gl::FmtErr(HRESULT_CODE(GetLastError()));
+    }
+
+    HWND dummyWindow =
+        CreateWindowExA(0, reinterpret_cast<const char *>(mWindowClass), "ANGLE Dummy Window",
+                        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                        CW_USEDEFAULT, nullptr, nullptr, nullptr, nullptr);
     if (!dummyWindow)
     {
         return egl::EglNotInitialized() << "Failed to create dummy OpenGL window.";
@@ -201,18 +203,10 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
     }
 
     // Create the real intermediate context and windows
-    mWindow = CreateWindowExA(0,
-                              reinterpret_cast<const char *>(mWindowClass),
-                              "ANGLE Intermediate Window",
-                              WS_OVERLAPPEDWINDOW,
-                              CW_USEDEFAULT,
-                              CW_USEDEFAULT,
-                              CW_USEDEFAULT,
-                              CW_USEDEFAULT,
-                              nullptr,
-                              nullptr,
-                              nullptr,
-                              nullptr);
+    mWindow = CreateWindowExA(0, reinterpret_cast<const char *>(mWindowClass),
+                              "ANGLE Intermediate Window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
+                              CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, nullptr, nullptr,
+                              nullptr, nullptr);
     if (!mWindow)
     {
         return egl::EglNotInitialized() << "Failed to create intermediate OpenGL window.";
@@ -253,7 +247,6 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
 
     if (mFunctionsWGL->createContextAttribsARB)
     {
-
         mWGLContext = initializeContextAttribs(displayAttributes);
     }
 
@@ -326,34 +319,63 @@ egl::Error DisplayWGL::initialize(egl::Display *display)
         }
     }
 
-    return DisplayGL::initialize(display);
+    return egl::NoError();
 }
 
 void DisplayWGL::terminate()
 {
     DisplayGL::terminate();
+    destroy();
+}
 
+void DisplayWGL::destroy()
+{
     releaseD3DDevice(mD3D11DeviceHandle);
 
+    if (mFunctionsWGL)
+    {
+        if (mDeviceContext)
+        {
             mFunctionsWGL->makeCurrent(mDeviceContext, nullptr);
-    mCurrentDC = nullptr;
+        }
+        if (mWGLContext)
+        {
             mFunctionsWGL->deleteContext(mWGLContext);
+        }
+    }
+    mCurrentDC = nullptr;
     mWGLContext = nullptr;
 
+    SafeDelete(mFunctionsWGL);
+    SafeDelete(mFunctionsGL);
+
+    if (mDeviceContext)
+    {
         ReleaseDC(mWindow, mDeviceContext);
         mDeviceContext = nullptr;
+    }
 
+    if (mWindow)
+    {
         DestroyWindow(mWindow);
         mWindow = nullptr;
+    }
 
-    UnregisterClassA(reinterpret_cast<const char *>(mWindowClass), nullptr);
+    if (mWindowClass)
+    {
+        if (!UnregisterClassA(reinterpret_cast<const char *>(mWindowClass),
+                              GetModuleHandle(nullptr)))
+        {
+            WARN() << "Failed to unregister OpenGL window class: " << gl::FmtHex(mWindowClass);
+        }
         mWindowClass = NULL;
+    }
 
-    SafeDelete(mFunctionsWGL);
-    SafeDelete(mFunctionsGL);
-
+    if (mOpenGLModule)
+    {
         FreeLibrary(mOpenGLModule);
         mOpenGLModule = nullptr;
+    }
 
     SafeRelease(mD3D11Device);
 
@@ -456,10 +478,10 @@ egl::ConfigSet DisplayWGL::generateConfigs()
     bool supportsES3 = maxVersion >= gl::Version(3, 0);
 
     PIXELFORMATDESCRIPTOR pixelFormatDescriptor;
-    DescribePixelFormat(mDeviceContext, mPixelFormat, sizeof(pixelFormatDescriptor), &pixelFormatDescriptor);
+    DescribePixelFormat(mDeviceContext, mPixelFormat, sizeof(pixelFormatDescriptor),
+                        &pixelFormatDescriptor);
 
-    auto getAttrib = [this](int attrib)
-    {
+    auto getAttrib = [this](int attrib) {
         return wgl::QueryWGLFormatAttrib(mDeviceContext, mPixelFormat, attrib, mFunctionsWGL);
     };
 
@@ -468,7 +490,8 @@ egl::ConfigSet DisplayWGL::generateConfigs()
 
     egl::Config config;
     config.renderTargetFormat = GL_RGBA8;  // TODO: use the bit counts to determine the format
-    config.depthStencilFormat = GL_DEPTH24_STENCIL8; // TODO: use the bit counts to determine the format
+    config.depthStencilFormat =
+        GL_DEPTH24_STENCIL8;  // TODO: use the bit counts to determine the format
     config.bufferSize        = pixelFormatDescriptor.cColorBits;
     config.redSize           = pixelFormatDescriptor.cRedBits;
     config.greenSize         = pixelFormatDescriptor.cGreenBits;
@@ -543,7 +566,7 @@ egl::Error DisplayWGL::validateClientBuffer(const egl::Config *configuration,
     {
         case EGL_D3D_TEXTURE_ANGLE:
         case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
-            ANGLE_TRY(const_cast<DisplayWGL*>(this)->initializeD3DDevice());
+            ANGLE_TRY(const_cast<DisplayWGL *>(this)->initializeD3DDevice());
             return D3DTextureSurfaceWGL::ValidateD3DTextureClientBuffer(buftype, clientBuffer,
                                                                         mD3D11Device);
 
@@ -554,7 +577,7 @@ egl::Error DisplayWGL::validateClientBuffer(const egl::Config *configuration,
 
 std::string DisplayWGL::getVendorString() const
 {
-    //UNIMPLEMENTED();
+    // UNIMPLEMENTED();
     return "";
 }
 

src/libANGLE/renderer/gl/wgl/DisplayWGL.h

@@ -67,6 +67,9 @@ class DisplayWGL : public DisplayGL
     void releaseD3DDevice(HANDLE handle);
 
   private:
+    egl::Error initializeImpl(egl::Display *display);
+    void destroy();
+
     const FunctionsGL *getFunctionsGL() const override;
 
     egl::Error initializeD3DDevice();
@@ -108,8 +111,6 @@ class DisplayWGL : public DisplayGL
         size_t refCount;
     };
     std::map<IUnknown *, D3DObjectHandle> mRegisteredD3DDevices;
-
-    egl::Display *mDisplay;
 };
 
 }