In Windows10, EnumICMProfiles API leaks handles

Question

The Windows API EnumICMProfiles enumerates ICC profiles associated with the display devicer for a given DC. There might be a custom profile for a particular monitor, just sRGB, or both. At some point in Windows 10, this API started leaking handles. Every call leaks 8 handles on several computers I tested. Not a major problem unless an app calls it multiple times and is used extensively over many days. Eventually the leak can cause problems with other handle allocation.

The problem was not present in Windows 7, Windows 8.1, or Windows 10 build 1607. See code comments for more info. It appears to be a registry handle leak from within the windows API source, so maybe some RegCloseKey's not called.

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#pragma comment(lib,"user32.lib")
#pragma comment(lib,"gdi32.lib")

int CALLBACK TestEnumProfilesFunc(LPTSTR lpszFilename, LPARAM lParam)
{
    if (lpszFilename && *lpszFilename && lParam)
    {
        unsigned *pCount = (unsigned *)lParam;
        (*pCount)++;
    }
    return TRUE; // TRUE==keep enumerating.  Even if we enumerate one profile and return FALSE, it still leaks same # of handles
}

int main(void)
{
    TCHAR szMsg[256];
    HANDLE hProcess = GetCurrentProcess();

    HDC hScreenDC = ::GetDC(NULL);  // Get screen DC and release it before establishing baseline handle count
    if (hScreenDC != 0)
        ::ReleaseDC(NULL, hScreenDC);

    DWORD nOrigHandles = 0;
    GetProcessHandleCount(hProcess, &nOrigHandles);
    DWORD LastHandleCount = nOrigHandles;
    int nIterations = 100;

    for (int i = 0; i < nIterations; i++)
    {
        hScreenDC = ::GetDC(NULL);
        if (hScreenDC == 0)
            break;

        unsigned nProfiles = 0;
        EnumICMProfiles(hScreenDC, TestEnumProfilesFunc, (LPARAM)&nProfiles);
        // Also, both EnumICMProfilesA and EnumICMProfilesW leak the same
        // Return value is -1,0,1 result code so there's nothing the caller can close
        ::ReleaseDC(NULL, hScreenDC);

        // First call will leave many handles open, those may be okay as they may be cached and released later
        // Subsequent calls leak 8 handles per two enumerated profiles 

        // No leaked handles if we don't call EnumICMProfiles
        // No leak in Windows 7 or Windows 8.1 
        // No leak in Windows 10 1607
        // leaks in Windows 10 1809 build 17763.379
        // leaks in Windows 10 1903 and 1909

        // Leaks 2 handles if no ICM profiles associated with display device
        // Leaks 8 handles if 1 or more ICM profiles set for display device
        // Using Windows SysInternals ProcessExplorer or similar to view handles, the leaked handles appear to be 
        //     registry handles to the display driver associated with the DC.  The leak might be missing RegCloseKey's.

        DWORD nHandles = 0;
        GetProcessHandleCount(hProcess, &nHandles);

        wsprintf(szMsg,_T("%8u Iterations\n"
            "%8u Total Current Handles  Orig=%u\n"
            "%8u Leaked Handles\n"
            "%8u Profiles on DC\n"
            ),
            i + 1, nHandles, nOrigHandles,
            nHandles > LastHandleCount ? nHandles-LastHandleCount : 0,nProfiles);
        if (MessageBox(NULL, szMsg, _T("EnumICMProfiles"), MB_ICONINFORMATION | MB_OKCANCEL)==IDCANCEL)
            break;

        LastHandleCount = nHandles;
    }

    // The handles will go away when the process terminates, but the problem is an application that regularly calls this may build up many leaked handles.
    //     Other handle allocation may fail once the # of leaked handles gets too high.

    return 0;
}

The workaround is to just not call it very often. Posting here b/c Microsoft has no easy, free place to report bugs.