Remove custom memory manager

core/src/fxcrt/fx_basic_maps.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
- 
+
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../include/fxcrt/fx_ext.h"
 #include "plex.h"
 static void ConstructElement(CFX_ByteString* pNewData)
 {
     new (pNewData) CFX_ByteString();
 }
 static void DestructElement(CFX_ByteString* pOldData)
 {
     pOldData->~CFX_ByteString();
 }
-CFX_MapPtrToPtr::CFX_MapPtrToPtr(int nBlockSize, IFX_Allocator* pAllocator)
-    : m_pAllocator(pAllocator)
-    , m_pHashTable(NULL)
+CFX_MapPtrToPtr::CFX_MapPtrToPtr(int nBlockSize)
+    : m_pHashTable(NULL)
     , m_nHashTableSize(17)
     , m_nCount(0)
     , m_pFreeList(NULL)
     , m_pBlocks(NULL)
     , m_nBlockSize(nBlockSize)
 {
     ASSERT(m_nBlockSize > 0);
 }
 void CFX_MapPtrToPtr::RemoveAll()
 {
     if (m_pHashTable) {
-        FX_Allocator_Free(m_pAllocator, m_pHashTable);
+        FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     m_nCount = 0;
     m_pFreeList = NULL;
-    m_pBlocks->FreeDataChain(m_pAllocator);
+    m_pBlocks->FreeDataChain();
     m_pBlocks = NULL;
 }
 CFX_MapPtrToPtr::~CFX_MapPtrToPtr()
 {
     RemoveAll();
     ASSERT(m_nCount == 0);
 }
 FX_DWORD CFX_MapPtrToPtr::HashKey(void* key) const
 {
     return ((FX_DWORD)(FX_UINTPTR)key) >> 4;
@@ skipping 68 matching lines @@
         if (pAssoc->key == key) {
             return pAssoc;
         }
     }
     return NULL;
 }
 CFX_MapPtrToPtr::CAssoc*
 CFX_MapPtrToPtr::NewAssoc()
 {
     if (m_pFreeList == NULL) {
-        CFX_Plex* newBlock = CFX_Plex::Create(m_pAllocator, m_pBlocks, m_nBlockSize, sizeof(CFX_MapPtrToPtr::CAssoc));
+        CFX_Plex* newBlock = CFX_Plex::Create(m_pBlocks, m_nBlockSize, sizeof(CFX_MapPtrToPtr::CAssoc));
         CFX_MapPtrToPtr::CAssoc* pAssoc = (CFX_MapPtrToPtr::CAssoc*)newBlock->data();
         pAssoc += m_nBlockSize - 1;
         for (int i = m_nBlockSize - 1; i >= 0; i--, pAssoc--) {
             pAssoc->pNext = m_pFreeList;
             m_pFreeList = pAssoc;
         }
     }
     ASSERT(m_pFreeList != NULL);
     CFX_MapPtrToPtr::CAssoc* pAssoc = m_pFreeList;
     m_pFreeList = m_pFreeList->pNext;
     m_nCount++;
     ASSERT(m_nCount > 0);
     pAssoc->key = 0;
     pAssoc->value = 0;
     return pAssoc;
 }
 void CFX_MapPtrToPtr::InitHashTable(
     FX_DWORD nHashSize, FX_BOOL bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
     if (m_pHashTable != NULL) {
-        FX_Allocator_Free(m_pAllocator, m_pHashTable);
+        FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     if (bAllocNow) {
-        m_pHashTable = FX_Allocator_Alloc(m_pAllocator, CAssoc*, nHashSize);
+        m_pHashTable = FX_Alloc(CAssoc*, nHashSize);
         if (m_pHashTable) {
             FXSYS_memset32(m_pHashTable, 0, sizeof(CAssoc*) * nHashSize);
         }
     }
     m_nHashTableSize = nHashSize;
 }
 FX_BOOL CFX_MapPtrToPtr::RemoveKey(void* key)
 {
     if (m_pHashTable == NULL) {
         return FALSE;
@@ skipping 14 matching lines @@
 void CFX_MapPtrToPtr::FreeAssoc(CFX_MapPtrToPtr::CAssoc* pAssoc)
 {
     pAssoc->pNext = m_pFreeList;
     m_pFreeList = pAssoc;
     m_nCount--;
     ASSERT(m_nCount >= 0);
     if (m_nCount == 0) {
         RemoveAll();
     }
 }
-CFX_MapByteStringToPtr::CFX_MapByteStringToPtr(int nBlockSize, IFX_Allocator* pAllocator)
-    : m_pAllocator(pAllocator)
-    , m_pHashTable(NULL)
+CFX_MapByteStringToPtr::CFX_MapByteStringToPtr(int nBlockSize)
+    : m_pHashTable(NULL)
     , m_nHashTableSize(17)
     , m_nCount(0)
     , m_pFreeList(NULL)
     , m_pBlocks(NULL)
     , m_nBlockSize(nBlockSize)
 {
     ASSERT(m_nBlockSize > 0);
 }
 void CFX_MapByteStringToPtr::RemoveAll()
 {
     if (m_pHashTable != NULL) {
         for (FX_DWORD nHash = 0; nHash < m_nHashTableSize; nHash++) {
             CAssoc* pAssoc;
             for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL;
                     pAssoc = pAssoc->pNext) {
                 DestructElement(&pAssoc->key);
             }
         }
-        FX_Allocator_Free(m_pAllocator, m_pHashTable);
+        FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     m_nCount = 0;
     m_pFreeList = NULL;
-    m_pBlocks->FreeDataChain(m_pAllocator);
+    m_pBlocks->FreeDataChain();
     m_pBlocks = NULL;
 }
 CFX_MapByteStringToPtr::~CFX_MapByteStringToPtr()
 {
     RemoveAll();
     ASSERT(m_nCount == 0);
 }
 void CFX_MapByteStringToPtr::GetNextAssoc(FX_POSITION& rNextPosition,
         CFX_ByteString& rKey, void*& rValue) const
 {
@@ skipping 55 matching lines @@
         pAssoc->key = key;
         pAssoc->pNext = m_pHashTable[nHash];
         m_pHashTable[nHash] = pAssoc;
     }
     return pAssoc->value;
 }
 CFX_MapByteStringToPtr::CAssoc*
 CFX_MapByteStringToPtr::NewAssoc()
 {
     if (m_pFreeList == NULL) {
-        CFX_Plex* newBlock = CFX_Plex::Create(m_pAllocator, m_pBlocks, m_nBlockSize, sizeof(CFX_MapByteStringToPtr::CAssoc));
+        CFX_Plex* newBlock = CFX_Plex::Create(m_pBlocks, m_nBlockSize, sizeof(CFX_MapByteStringToPtr::CAssoc));
         CFX_MapByteStringToPtr::CAssoc* pAssoc = (CFX_MapByteStringToPtr::CAssoc*)newBlock->data();
         pAssoc += m_nBlockSize - 1;
         for (int i = m_nBlockSize - 1; i >= 0; i--, pAssoc--) {
             pAssoc->pNext = m_pFreeList;
             m_pFreeList = pAssoc;
         }
     }
     ASSERT(m_pFreeList != NULL);
     CFX_MapByteStringToPtr::CAssoc* pAssoc = m_pFreeList;
     m_pFreeList = m_pFreeList->pNext;
@@ skipping 38 matching lines @@
     }
     rValue = pAssoc->value;
     return TRUE;
 }
 void CFX_MapByteStringToPtr::InitHashTable(
     FX_DWORD nHashSize, FX_BOOL bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
     if (m_pHashTable != NULL) {
-        FX_Allocator_Free(m_pAllocator, m_pHashTable);
+        FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     if (bAllocNow) {
-        m_pHashTable = FX_Allocator_Alloc(m_pAllocator, CAssoc*, nHashSize);
+        m_pHashTable = FX_Alloc(CAssoc*, nHashSize);
         if (m_pHashTable) {
             FXSYS_memset32(m_pHashTable, 0, sizeof(CAssoc*) * nHashSize);
         }
     }
     m_nHashTableSize = nHashSize;
 }
 inline FX_DWORD CFX_MapByteStringToPtr::HashKey(FX_BSTR key) const
 {
     FX_DWORD nHash = 0;
     int len = key.GetLength();
@@ skipping 21 matching lines @@
     }
     return FALSE;
 }
 struct _CompactString {
     FX_BYTE             m_CompactLen;
     FX_BYTE             m_LenHigh;
     FX_BYTE             m_LenLow;
     FX_BYTE             m_Unused;
     FX_LPBYTE   m_pBuffer;
 };
-static void _CompactStringRelease(IFX_Allocator* pAllocator, _CompactString* pCompact)
+static void _CompactStringRelease(_CompactString* pCompact)
 {
     if (pCompact->m_CompactLen == 0xff) {
-        FX_Allocator_Free(pAllocator, pCompact->m_pBuffer);
+        FX_Free(pCompact->m_pBuffer);
     }
 }
 static FX_BOOL _CompactStringSame(_CompactString* pCompact, FX_LPCBYTE pStr, int len)
 {
     if (len < sizeof(_CompactString)) {
         if (pCompact->m_CompactLen != len) {
             return FALSE;
         }
         return FXSYS_memcmp32(&pCompact->m_LenHigh, pStr, len) == 0;
     }
     if (pCompact->m_CompactLen != 0xff || pCompact->m_LenHigh * 256 + pCompact->m_LenLow != len) {
         return FALSE;
     }
     return FXSYS_memcmp32(pCompact->m_pBuffer, pStr, len) == 0;
 }
-static void _CompactStringStore(IFX_Allocator* pAllocator, _CompactString* pCompact, FX_LPCBYTE pStr, int len)
+static void _CompactStringStore(_CompactString* pCompact, FX_LPCBYTE pStr, int len)
 {
     if (len < (int)sizeof(_CompactString)) {
         pCompact->m_CompactLen = (FX_BYTE)len;
         FXSYS_memcpy32(&pCompact->m_LenHigh, pStr, len);
         return;
     }
     pCompact->m_CompactLen = 0xff;
     pCompact->m_LenHigh = len / 256;
     pCompact->m_LenLow = len % 256;
-    pCompact->m_pBuffer = FX_Allocator_Alloc(pAllocator, FX_BYTE, len);
+    pCompact->m_pBuffer = FX_Alloc(FX_BYTE, len);
     if (pCompact->m_pBuffer) {
         FXSYS_memcpy32(pCompact->m_pBuffer, pStr, len);
     }
 }
 static CFX_ByteStringC _CompactStringGet(_CompactString* pCompact)
 {
     if (pCompact->m_CompactLen == 0xff) {
         return CFX_ByteStringC(pCompact->m_pBuffer, pCompact->m_LenHigh * 256 + pCompact->m_LenLow);
     }
     if (pCompact->m_CompactLen == 0xfe) {
         return CFX_ByteStringC();
     }
     return CFX_ByteStringC(&pCompact->m_LenHigh, pCompact->m_CompactLen);
 }
 #define CMAP_ALLOC_STEP         8
 #define CMAP_INDEX_SIZE         8
-CFX_CMapByteStringToPtr::CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator)
-    : m_Buffer(sizeof(_CompactString) + sizeof(void*), CMAP_ALLOC_STEP, CMAP_INDEX_SIZE, pAllocator)
+CFX_CMapByteStringToPtr::CFX_CMapByteStringToPtr()
+    : m_Buffer(sizeof(_CompactString) + sizeof(void*), CMAP_ALLOC_STEP, CMAP_INDEX_SIZE)
 {
 }
 CFX_CMapByteStringToPtr::~CFX_CMapByteStringToPtr()
 {
     RemoveAll();
 }
 void CFX_CMapByteStringToPtr::RemoveAll()
 {
-    IFX_Allocator* pAllocator = m_Buffer.m_pAllocator;
     int size = m_Buffer.GetSize();
-    for (int i = 0; i < size; i ++) {
-        _CompactStringRelease(pAllocator, (_CompactString*)m_Buffer.GetAt(i));
+    for (int i = 0; i < size; i++) {
+        _CompactStringRelease((_CompactString*)m_Buffer.GetAt(i));
     }
     m_Buffer.RemoveAll();
 }
 FX_POSITION CFX_CMapByteStringToPtr::GetStartPosition() const
 {
     int size = m_Buffer.GetSize();
     for (int i = 0; i < size; i ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(i);
         if (pKey->m_CompactLen != 0xfe) {
             return (FX_POSITION)(FX_UINTPTR)(i + 1);
@@ skipping 62 matching lines @@
     int index, key_len = key.GetLength();
     int size = m_Buffer.GetSize();
     for (index = 0; index < size; index ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (!_CompactStringSame(pKey, (FX_LPCBYTE)key, key_len)) {
             continue;
         }
         *(void**)(pKey + 1) = value;
         return;
     }
-    IFX_Allocator* pAllocator = m_Buffer.m_pAllocator;
     for (index = 0; index < size; index ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (pKey->m_CompactLen) {
             continue;
         }
-        _CompactStringStore(pAllocator, pKey, (FX_LPCBYTE)key, key_len);
+        _CompactStringStore(pKey, (FX_LPCBYTE)key, key_len);
         *(void**)(pKey + 1) = value;
         return;
     }
     _CompactString* pKey = (_CompactString*)m_Buffer.Add();
-    _CompactStringStore(pAllocator, pKey, (FX_LPCBYTE)key, key_len);
+    _CompactStringStore(pKey, (FX_LPCBYTE)key, key_len);
     *(void**)(pKey + 1) = value;
 }
 void CFX_CMapByteStringToPtr::AddValue(FX_BSTR key, void* value)
 {
     ASSERT(value != NULL);
     _CompactString* pKey = (_CompactString*)m_Buffer.Add();
-    _CompactStringStore(m_Buffer.m_pAllocator, pKey, (FX_LPCBYTE)key, key.GetLength());
+    _CompactStringStore(pKey, (FX_LPCBYTE)key, key.GetLength());
     *(void**)(pKey + 1) = value;
 }
 void CFX_CMapByteStringToPtr::RemoveKey(FX_BSTR key)
 {
     int key_len = key.GetLength();
-    IFX_Allocator* pAllocator = m_Buffer.m_pAllocator;
     int size = m_Buffer.GetSize();
-    for (int index = 0; index < size; index ++) {
+    for (int index = 0; index < size; index++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (!_CompactStringSame(pKey, (FX_LPCBYTE)key, key_len)) {
             continue;
         }
-        _CompactStringRelease(pAllocator, pKey);
+        _CompactStringRelease(pKey);
         pKey->m_CompactLen = 0xfe;
         return;
     }
 }
 int CFX_CMapByteStringToPtr::GetCount() const
 {
     int count = 0;
     int size = m_Buffer.GetSize();
     for (int i = 0; i < size; i ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(i);
@@ skipping 67 matching lines @@
             buf[mid].value = value;
             return;
         }
     }
     m_Buffer.InsertBlock(low * sizeof(_DWordPair), &pair, sizeof(_DWordPair));
 }
 void CFX_CMapDWordToDWord::EstimateSize(FX_DWORD size, FX_DWORD grow_by)
 {
     m_Buffer.EstimateSize(size, grow_by);
 }