[SHIMGVW] Use HeapAlloc/HeapFree instead of malloc/calloc/free

malloc/free are slow. CORE-19358

dll/win32/shimgvw/anime.c

···
 {
     if (pAnime->m_pDelayItem)
     {
-        free(pAnime->m_pDelayItem);
+        QuickFree(pAnime->m_pDelayItem);
         pAnime->m_pDelayItem = NULL;
     }
     pAnime->m_nFrameIndex = 0;
···
     GdipImageGetFrameDimensionsCount(g_pImage, &nDimCount);
     if (nDimCount)
     {
-        GUID *dims = (GUID *)calloc(nDimCount, sizeof(GUID));
+        GUID *dims = (GUID *)QuickAlloc(nDimCount * sizeof(GUID), TRUE);
         if (dims)
         {
             GdipImageGetFrameDimensionsList(g_pImage, dims, nDimCount);
             GdipImageGetFrameCount(g_pImage, dims, &result);
             pAnime->m_nFrameCount = result;
-            free(dims);
+            QuickFree(dims);
         }
     }
 
···
     cbItem = result;
     if (cbItem)
     {
-        pAnime->m_pDelayItem = (PropertyItem *)malloc(cbItem);
+        pAnime->m_pDelayItem = (PropertyItem *)QuickAlloc(cbItem, FALSE);
         GdipGetPropertyItem(g_pImage, PropertyTagFrameDelay, cbItem, pAnime->m_pDelayItem);
     }
 
···
     cbItem = result;
     if (cbItem)
     {
-        PropertyItem *pItem = (PropertyItem *)malloc(cbItem);
+        PropertyItem *pItem = (PropertyItem *)QuickAlloc(cbItem, FALSE);
         if (pItem)
         {
             if (GdipGetPropertyItem(g_pImage, PropertyTagLoopCount, cbItem, pItem) == Ok)
             {
                 pAnime->m_nLoopCount = *(WORD *)pItem->value;
             }
-            free(pItem);
+            QuickFree(pItem);
         }
     }
 

dll/win32/shimgvw/shimgvw.c

···
         return;
 
     GdipGetImageEncodersSize(&num, &size);
-    codecInfo = malloc(size);
+    codecInfo = QuickAlloc(size, FALSE);
     if (!codecInfo)
     {
-        DPRINT1("malloc() failed in pSaveImageAs()\n");
+        DPRINT1("QuickAlloc() failed in pSaveImageAs()\n");
         return;
     }
 
···
     /* Add two more chars for the last terminator */
     sizeRemain += (sizeof(WCHAR) * 2);
 
-    szFilterMask = malloc(sizeRemain);
+    szFilterMask = QuickAlloc(sizeRemain, FALSE);
     if (!szFilterMask)
     {
         DPRINT1("cannot allocate memory for filter mask in pSaveImageAs()");
-        free(codecInfo);
+        QuickFree(codecInfo);
         return;
     }
 
···
         Anime_Start(&g_Anime, 0);
     }
 
-    free(szFilterMask);
-    free(codecInfo);
+    QuickFree(szFilterMask);
+    QuickFree(codecInfo);
 }
 
 static VOID
···
     PathRemoveFileSpecW(szSearchPath);
 
     GdipGetImageDecodersSize(&num, &size);
-    codecInfo = malloc(size);
+    codecInfo = QuickAlloc(size, FALSE);
     if (!codecInfo)
     {
-        DPRINT1("malloc() failed in pLoadFileList()\n");
+        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
         return NULL;
     }
 
     GdipGetImageDecoders(num, size, codecInfo);
 
-    root = malloc(sizeof(SHIMGVW_FILENODE));
+    root = QuickAlloc(sizeof(SHIMGVW_FILENODE), FALSE);
     if (!root)
     {
-        DPRINT1("malloc() failed in pLoadFileList()\n");
-        free(codecInfo);
+        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
+        QuickFree(codecInfo);
         return NULL;
     }
 
···
                         currentNode = conductor;
                     }
 
-                    conductor->Next = malloc(sizeof(SHIMGVW_FILENODE));
+                    conductor->Next = QuickAlloc(sizeof(SHIMGVW_FILENODE), FALSE);
 
-                    // if malloc fails, make circular what we have and return it
+                    // if QuickAlloc fails, make circular what we have and return it
                     if (!conductor->Next)
                     {
-                        DPRINT1("malloc() failed in pLoadFileList()\n");
+                        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
 
                         conductor->Next = root;
                         root->Prev = conductor;
 
                         FindClose(hFindHandle);
-                        free(codecInfo);
+                        QuickFree(codecInfo);
                         return conductor;
                     }
 
···
     else
     {
         conductor = conductor->Prev;
-        free(conductor->Next);
+        QuickFree(conductor->Next);
     }
 
     // link the last node with the first one to make the list circular
···
     root->Prev = conductor;
     conductor = currentNode;
 
-    free(codecInfo);
+    QuickFree(codecInfo);
 
     return conductor;
 }
···
     {
         conductor = root;
         root = conductor->Next;
-        free(conductor);
+        QuickFree(conductor);
     }
 }
 

dll/win32/shimgvw/shimgvw.h

···
 void Anime_Start(PANIME pAnime, DWORD dwDelay);
 void Anime_Pause(PANIME pAnime);
 BOOL Anime_OnTimer(PANIME pAnime, WPARAM wParam);
+
+static inline LPVOID QuickAlloc(SIZE_T cbSize, BOOL bZero)
+{
+    return HeapAlloc(GetProcessHeap(), (bZero ? HEAP_ZERO_MEMORY : 0), cbSize);
+}
+
+static inline VOID QuickFree(LPVOID ptr)
+{
+    HeapFree(GetProcessHeap(), 0, ptr);
+}