Fix several WGL test failures.

src/gpu_info_util/SystemInfo_win.cpp

@@ -241,9 +241,20 @@ bool GetSystemInfo(SystemInfo *info)
     }
     ASSERT(foundPrimary);
 
+    ASSERT(GetLastError() == ERROR_SUCCESS);
     // nvd3d9wrap.dll is loaded into all processes when Optimus is enabled.
     HMODULE nvd3d9wrap = GetModuleHandleW(L"nvd3d9wrap.dll");
     info->isOptimus    = nvd3d9wrap != nullptr;
+    // ERROR_MOD_NOT_FOUND is expected from GetModuleHandleW, reset last error if it happens.
+    if (GetLastError() != ERROR_SUCCESS && GetLastError() != ERROR_MOD_NOT_FOUND)
+    {
+        WARN() << "Unexpected error calling GetModuleHandleW: 0x" << std::hex << GetLastError()
+               << std::endl;
+    }
+    else
+    {
+        SetLastError(ERROR_SUCCESS);
+    }
 
     return true;
 }

util/windows/WGLWindow.cpp

@@ -9,9 +9,11 @@
 
 #include "util/windows/WGLWindow.h"
 
+#include "common/debug.h"
 #include "common/string_utils.h"
 #include "util/OSWindow.h"
 #include "util/system_utils.h"
+#include "util/windows/win32/Win32Window.h"
 
 #include <iostream>
 
@@ -39,24 +41,44 @@ HMODULE gCurrentModule                             = nullptr;
 
 angle::GenericProc WINAPI GetProcAddressWithFallback(const char *name)
 {
+    ASSERT(GetLastError() == ERROR_SUCCESS);
     angle::GenericProc proc = reinterpret_cast<angle::GenericProc>(gCurrentWGLGetProcAddress(name));
+    // ERROR_INVALID_HANDLE and ERROR_PROC_NOT_FOUND are expected from wglGetProcAddress,
+    // reset last error if they happen.
+    if (GetLastError() != ERROR_SUCCESS && GetLastError() != ERROR_INVALID_HANDLE &&
+        GetLastError() != ERROR_PROC_NOT_FOUND)
+    {
+        std::cerr << "Unexpected error calling wglGetProcAddress: 0x" << std::hex << GetLastError()
+                  << std::endl;
+    }
+    else
+    {
+        SetLastError(ERROR_SUCCESS);
+    }
+
     if (proc)
     {
         return proc;
     }
 
-    return reinterpret_cast<angle::GenericProc>(GetProcAddress(gCurrentModule, name));
+    proc = reinterpret_cast<angle::GenericProc>(GetProcAddress(gCurrentModule, name));
+    // ERROR_PROC_NOT_FOUND is expected from GetProcAddress, reset last error if it happens.
+    if (GetLastError() != ERROR_SUCCESS && GetLastError() != ERROR_PROC_NOT_FOUND)
+    {
+        std::cerr << "Unexpected error calling GetProcAddress: 0x" << std::hex << GetLastError()
+                  << std::endl;
+    }
+    else
+    {
+        SetLastError(ERROR_SUCCESS);
+    }
+    return proc;
 }
 
 bool HasExtension(const std::vector<std::string> &extensions, const char *ext)
 {
     return std::find(extensions.begin(), extensions.end(), ext) != extensions.end();
 }
-
-void DumpLastWindowsError()
-{
-    std::cerr << "Last Windows error code: 0x" << std::hex << GetLastError() << std::endl;
-}
 }  // namespace
 
 WGLWindow::WGLWindow(int glesMajorVersion, int glesMinorVersion)
@@ -82,30 +104,15 @@ bool WGLWindow::initializeGL(OSWindow *osWindow, angle::Library *glWindowingLibr
     gCurrentModule = reinterpret_cast<HMODULE>(glWindowingLibrary->getNative());
     angle::LoadWGL(GetProcAddressWithFallback);
 
-    mWindow                                           = osWindow->getNativeWindow();
-    mDeviceContext                                    = GetDC(mWindow);
-    const PIXELFORMATDESCRIPTOR pixelFormatDescriptor = GetDefaultPixelFormatDescriptor();
-
-    int pixelFormat = ChoosePixelFormat(mDeviceContext, &pixelFormatDescriptor);
-    if (pixelFormat == 0)
+    Win32Window *win32Window = static_cast<Win32Window *>(osWindow);
+    if (!win32Window->setPixelFormat(GetDefaultPixelFormatDescriptor()))
     {
-        std::cerr << "Could not find a compatible pixel format." << std::endl;
-        DumpLastWindowsError();
+        std::cerr << "Failed to set default pixel format." << std::endl;
         return false;
     }
 
-    // According to the Windows docs, it is an error to set a pixel format twice.
-    int currentPixelFormat = GetPixelFormat(mDeviceContext);
-    if (currentPixelFormat != pixelFormat)
-    {
-        if (SetPixelFormat(mDeviceContext, pixelFormat, &pixelFormatDescriptor) != TRUE)
-        {
-            std::cerr << "Failed to set the pixel format." << std::endl;
-            DumpLastWindowsError();
-            return false;
-        }
-    }
-
+    mWindow        = osWindow->getNativeWindow();
+    mDeviceContext = GetDC(mWindow);
     mWGLContext = _wglCreateContext(mDeviceContext);
     if (!mWGLContext)
     {

util/windows/win32/Win32Window.cpp

@@ -8,10 +8,13 @@
 
 #include "util/windows/win32/Win32Window.h"
 
+#include <iostream>
 #include <sstream>
 
 #include "common/debug.h"
 
+namespace
+{
 Key VirtualKeyCodeToKey(WPARAM key, LPARAM flags)
 {
     switch (key)
@@ -228,6 +231,12 @@ Key VirtualKeyCodeToKey(WPARAM key, LPARAM flags)
     return Key(0);
 }
 
+void DumpLastWindowsError()
+{
+    std::cerr << "Last Windows error code: 0x" << std::hex << GetLastError() << std::endl;
+}
+}  // namespace
+
 LRESULT CALLBACK Win32Window::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
     switch (message)
@@ -485,7 +494,10 @@ LRESULT CALLBACK Win32Window::WndProc(HWND hWnd, UINT message, WPARAM wParam, LP
 }
 
 Win32Window::Win32Window()
-    : mIsVisible(false),
+    : mParentClassRegistered(false),
+      mChildClassRegistered(false),
+      mPixelFormatIsSet(false),
+      mIsVisible(false),
       mSetVisibleTimer(CreateTimer()),
       mIsMouseInWindow(false),
       mNativeWindow(0),
@@ -531,6 +543,7 @@ bool Win32Window::initialize(const std::string &name, size_t width, size_t heigh
     {
         return false;
     }
+    mParentClassRegistered = true;
 
     WNDCLASSEXA childWindowClass   = {0};
     childWindowClass.cbSize        = sizeof(WNDCLASSEXA);
@@ -548,6 +561,7 @@ bool Win32Window::initialize(const std::string &name, size_t width, size_t heigh
     {
         return false;
     }
+    mChildClassRegistered = true;
 
     DWORD parentStyle = WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SYSMENU;
     DWORD parentExtendedStyle = WS_EX_APPWINDOW;
@@ -560,7 +574,10 @@ bool Win32Window::initialize(const std::string &name, size_t width, size_t heigh
                                     sizeRect.right - sizeRect.left, sizeRect.bottom - sizeRect.top,
                                     nullptr, nullptr, GetModuleHandle(nullptr), this);
 
-    mNativeWindow = CreateWindowExA(0, mChildClassName.c_str(), name.c_str(), WS_CHILD, 0, 0,
+    // An OpenGL window should be created with the WS_CLIPCHILDREN and WS_CLIPSIBLINGS styles.
+    // Additionally, the window class attribute should not include the CS_PARENTDC style.
+    mNativeWindow = CreateWindowExA(WS_EX_NOPARENTNOTIFY, mChildClassName.c_str(), name.c_str(),
+                                    WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0, 0,
                                     static_cast<int>(width), static_cast<int>(height),
                                     mParentWindow, nullptr, GetModuleHandle(nullptr), this);
 
@@ -594,8 +611,16 @@ void Win32Window::destroy()
         mParentWindow = 0;
     }
 
-    UnregisterClassA(mParentClassName.c_str(), nullptr);
-    UnregisterClassA(mChildClassName.c_str(), nullptr);
+    if (mParentClassRegistered)
+    {
+        UnregisterClassA(mParentClassName.c_str(), nullptr);
+        mParentClassRegistered = false;
+    }
+    if (mChildClassRegistered)
+    {
+        UnregisterClassA(mChildClassName.c_str(), nullptr);
+        mChildClassRegistered = false;
+    }
 }
 
 bool Win32Window::takeScreenshot(uint8_t *pixelData)
@@ -809,6 +834,52 @@ void Win32Window::setVisible(bool isVisible)
     }
 }
 
+bool Win32Window::setPixelFormat(const PIXELFORMATDESCRIPTOR pixelFormatDescriptor)
+{
+    HDC deviceContext = GetDC(getNativeWindow());
+    int pixelFormat   = ChoosePixelFormat(deviceContext, &pixelFormatDescriptor);
+    if (pixelFormat == 0)
+    {
+        std::cerr << "Could not find a compatible pixel format." << std::endl;
+        DumpLastWindowsError();
+        return false;
+    }
+
+    ASSERT(GetLastError() == ERROR_SUCCESS);
+    int currentPixelFormat = GetPixelFormat(deviceContext);
+    if (GetLastError() != ERROR_SUCCESS)
+    {
+        // ERROR_INVALID_PIXEL_FORMAT is expected from GetPixelFormat, when !mPixelFormatIsSet,
+        // reset last error if it happens.
+        if (mPixelFormatIsSet || GetLastError() != ERROR_INVALID_PIXEL_FORMAT)
+        {
+            std::cerr << "Unexpected error calling GetPixelFormat: 0x" << std::hex << GetLastError()
+                      << std::endl;
+            return false;
+        }
+        else
+        {
+            SetLastError(ERROR_SUCCESS);
+        }
+    }
+
+    // According to the Windows docs, it is an error to set a pixel format twice.
+    if (mPixelFormatIsSet)
+    {
+        return currentPixelFormat == pixelFormat;
+    }
+
+    if (SetPixelFormat(deviceContext, pixelFormat, &pixelFormatDescriptor) != TRUE)
+    {
+        std::cerr << "Failed to set the pixel format." << std::endl;
+        DumpLastWindowsError();
+        return false;
+    }
+
+    mPixelFormatIsSet = true;
+    return true;
+}
+
 void Win32Window::pushEvent(Event event)
 {
     OSWindow::pushEvent(event);
@@ -816,7 +887,10 @@ void Win32Window::pushEvent(Event event)
     switch (event.Type)
     {
         case Event::EVENT_RESIZED:
-            MoveWindow(mNativeWindow, 0, 0, mWidth, mHeight, FALSE);
+            if (mNativeWindow)
+            {
+                MoveWindow(mNativeWindow, 0, 0, mWidth, mHeight, FALSE);
+            }
             break;
         default:
             break;

util/windows/win32/Win32Window.h

@@ -38,6 +38,7 @@ class Win32Window : public OSWindow
     bool setPosition(int x, int y) override;
     bool resize(int width, int height) override;
     void setVisible(bool isVisible) override;
+    bool setPixelFormat(const PIXELFORMATDESCRIPTOR pixelFormatDescriptor);
 
     void signalTestEvent() override;
 
@@ -46,6 +47,9 @@ class Win32Window : public OSWindow
 
     std::string mParentClassName;
     std::string mChildClassName;
+    bool mParentClassRegistered;
+    bool mChildClassRegistered;
+    bool mPixelFormatIsSet;
 
     bool mIsVisible;
     Timer *mSetVisibleTimer;