Remove custom memory manager

core/include/fxcrt/fx_basic.h

 // 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
 
 #ifndef _FX_BASIC_H_
 #define _FX_BASIC_H_
 #ifndef _FX_SYSTEM_H_
 #include "fx_system.h"
 #endif
 #ifndef _FX_MEMORY_H_
 #include "fx_memory.h"
 #endif
 #ifndef _FX_STRING_H_
 #include "fx_string.h"
 #endif
 #ifndef _FX_STREAM_H_
 #include "fx_stream.h"
 #endif
 class CFX_BinaryBuf : public CFX_Object
 {
 public:
-
-    CFX_BinaryBuf(IFX_Allocator* pAllocator = NULL);
-
-    CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
+    CFX_BinaryBuf();
+    CFX_BinaryBuf(FX_STRSIZE size);
 
     ~CFX_BinaryBuf();
 
     void                                        Clear();
 
     void                                        EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);
 
     void                                        AppendBlock(const void* pBuf, FX_STRSIZE size);
 
     void                                        AppendFill(FX_BYTE byte, FX_STRSIZE count);
@@ skipping 25 matching lines @@
     {
         return m_pBuffer;
     }
 
     FX_STRSIZE                          GetSize() const
     {
         return m_DataSize;
     }
 
     CFX_ByteStringC                     GetByteString() const;
-    void                                        GetByteStringL(CFX_ByteStringL &str) const;
 
     void                                        DetachBuffer();
-
-    IFX_Allocator*                      m_pAllocator;
 protected:
 
     FX_STRSIZE                          m_AllocStep;
 
     FX_LPBYTE                           m_pBuffer;
 
     FX_STRSIZE                          m_DataSize;
 
     FX_STRSIZE                          m_AllocSize;
 
     void                                        ExpandBuf(FX_STRSIZE size);
 };
 class CFX_ByteTextBuf : public CFX_BinaryBuf
 {
 public:
 
-    CFX_ByteTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
-
     void                                        operator = (FX_BSTR str);
 
     void                                        AppendChar(int ch)
     {
         AppendByte((FX_BYTE)ch);
     }
 
     CFX_ByteTextBuf&            operator << (int i);
 
     CFX_ByteTextBuf&            operator << (FX_DWORD i);
 
     CFX_ByteTextBuf&            operator << (double f);
 
     CFX_ByteTextBuf&            operator << (FX_BSTR lpsz);
 
     CFX_ByteTextBuf&            operator << (const CFX_ByteTextBuf& buf);
 
     FX_STRSIZE                          GetLength() const
     {
         return m_DataSize;
     }
 };
 class CFX_WideTextBuf : public CFX_BinaryBuf
 {
 public:
 
-    CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
-
     void                                        operator = (FX_LPCWSTR lpsz);
 
     void                                        operator = (FX_WSTR str);
 
     void                                        AppendChar(FX_WCHAR wch);
 
     CFX_WideTextBuf&            operator << (int i);
 
     CFX_WideTextBuf&            operator << (double f);
 
@@ skipping 13 matching lines @@
     {
         return (FX_LPWSTR)m_pBuffer;
     }
 
     void                                        Delete(int start_index, int count)
     {
         CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));
     }
 
     CFX_WideStringC                     GetWideString() const;
-    void                                        GetWideStringL(CFX_WideStringL& wideText) const;
 };
 class CFX_ArchiveSaver : public CFX_Object
 {
 public:
-
-    CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}
+    CFX_ArchiveSaver() : m_pStream(NULL) {}
 
     CFX_ArchiveSaver&           operator << (FX_BYTE i);
 
     CFX_ArchiveSaver&           operator << (int i);
 
     CFX_ArchiveSaver&           operator << (FX_DWORD i);
 
     CFX_ArchiveSaver&           operator << (FX_FLOAT i);
 
     CFX_ArchiveSaver&           operator << (double i);
@@ skipping 53 matching lines @@
 
     FX_DWORD                            m_LoadingPos;
 
     FX_LPCBYTE                          m_pLoadingBuf;
 
     FX_DWORD                            m_LoadingSize;
 };
 class IFX_BufferArchive
 {
 public:
-
-    IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
+    IFX_BufferArchive(FX_STRSIZE size);
 
 
     virtual void                        Clear();
 
 
     FX_BOOL                                     Flush();
 
 
     FX_INT32                            AppendBlock(const void* pBuf, size_t size);
 
     FX_INT32                            AppendByte(FX_BYTE byte);
 
     FX_INT32                            AppendDWord(FX_DWORD i);
 
 
     FX_INT32                            AppendString(FX_BSTR lpsz);
 
 protected:
 
     virtual     FX_BOOL                 DoWork(const void* pBuf, size_t size) = 0;
 
-
-    IFX_Allocator*                      m_pAllocator;
-
     FX_STRSIZE                          m_BufSize;
 
     FX_LPBYTE                           m_pBuffer;
 
     FX_STRSIZE                          m_Length;
 };
 class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
 {
 public:
-    CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);
+    CFX_FileBufferArchive(FX_STRSIZE size = 32768);
     ~CFX_FileBufferArchive();
     virtual void                        Clear();
 
     FX_BOOL                                     AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = FALSE);
 
     FX_BOOL                                     AttachFile(FX_LPCWSTR filename);
 
     FX_BOOL                                     AttachFile(FX_LPCSTR filename);
 private:
 
@@ skipping 10 matching lines @@
 
     CFX_WideString      (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);
 
     CFX_ByteString      (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);
 
     FX_INT32            (*m_GetCodePage)();
 };
 class CFX_UTF8Decoder
 {
 public:
-
-    CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)
+    CFX_UTF8Decoder()
     {
         m_PendingBytes = 0;
     }
 
     void                        Clear();
 
     void                        Input(FX_BYTE byte);
 
     void                        AppendChar(FX_DWORD ch);
 
     void                        ClearStatus()
     {
         m_PendingBytes = 0;
     }
 
     CFX_WideStringC     GetResult() const
     {
         return m_Buffer.GetWideString();
     }
-    void                        GetResult(CFX_WideStringL &result) const
-    {
-        m_Buffer.GetWideStringL(result);
-    }
 protected:
 
     int                         m_PendingBytes;
 
     FX_DWORD            m_PendingChar;
 
     CFX_WideTextBuf     m_Buffer;
 };
 class CFX_UTF8Encoder
 {
 public:
-
-    CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)
+    CFX_UTF8Encoder()
     {
         m_UTF16First = 0;
     }
 
     void                        Input(FX_WCHAR unicode);
 
     void                        AppendStr(FX_BSTR str)
     {
         m_UTF16First = 0;
         m_Buffer << str;
     }
 
     CFX_ByteStringC     GetResult() const
     {
         return m_Buffer.GetByteString();
     }
-    void                        GetResult(CFX_ByteStringL &result) const
-    {
-        m_Buffer.GetByteStringL(result);
-    }
 protected:
 
     CFX_ByteTextBuf     m_Buffer;
 
     FX_DWORD            m_UTF16First;
 };
 CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);
 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
 class CFX_BasicArray : public CFX_Object
 {
-public:
-
-    IFX_Allocator*      m_pAllocator;
 protected:
-
-    CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
+    CFX_BasicArray(int unit_size);
 
     ~CFX_BasicArray();
 
     FX_BOOL                     SetSize(int nNewSize, int nGrowBy);
 
     FX_BOOL                     Append(const CFX_BasicArray& src);
 
     FX_BOOL                     Copy(const CFX_BasicArray& src);
 
     FX_LPBYTE           InsertSpaceAt(int nIndex, int nCount);
@@ skipping 12 matching lines @@
     int                         m_nMaxSize;
 
     int                         m_nGrowBy;
 
     int                         m_nUnitSize;
 };
 template<class TYPE>
 class CFX_ArrayTemplate : public CFX_BasicArray
 {
 public:
-
-    CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
+    CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
 
     int                 GetSize() const
     {
         return m_nSize;
     }
 
     int                 GetUpperBound() const
     {
         return m_nSize - 1;
     }
@@ skipping 145 matching lines @@
 typedef CFX_ArrayTemplate<FX_WORD>              CFX_WordArray;
 typedef CFX_ArrayTemplate<FX_DWORD>             CFX_DWordArray;
 typedef CFX_ArrayTemplate<void*>                CFX_PtrArray;
 typedef CFX_ArrayTemplate<FX_FILESIZE>  CFX_FileSizeArray;
 typedef CFX_ArrayTemplate<FX_FLOAT>             CFX_FloatArray;
 typedef CFX_ArrayTemplate<FX_INT32>             CFX_Int32Array;
 template <class ObjectClass>
 class CFX_ObjectArray : public CFX_BasicArray
 {
 public:
-
-    CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}
+    CFX_ObjectArray() : CFX_BasicArray(sizeof(ObjectClass)) {}
 
     ~CFX_ObjectArray()
     {
         RemoveAll();
     }
 
     void                        Add(const ObjectClass& data)
     {
         new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
     }
@@ skipping 95 matching lines @@
             ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
         }
         CFX_BasicArray::SetSize(0, -1);
     }
 };
 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
 class CFX_BaseSegmentedArray : public CFX_Object
 {
 public:
-
-    CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);
+    CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8);
 
     ~CFX_BaseSegmentedArray();
 
     void        SetUnitSize(int unit_size, int segment_units, int index_size = 8);
 
     void*       Add();
 
     void*       GetAt(int index) const;
 
     void        RemoveAll();
 
     void        Delete(int index, int count = 1);
 
     int         GetSize() const
     {
         return m_DataSize;
     }
 
     int         GetSegmentSize() const
     {
         return m_SegmentSize;
     }
 
     int         GetUnitSize() const
     {
         return m_UnitSize;
     }
 
     void*       Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
-
-    IFX_Allocator*      m_pAllocator;
 private:
 
     int                         m_UnitSize;
 
     short                       m_SegmentSize;
 
     FX_BYTE                     m_IndexSize;
 
     FX_BYTE                     m_IndexDepth;
 
     int                         m_DataSize;
 
     void*                       m_pIndex;
     void**      GetIndex(int seg_index) const;
     void*       IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
     void*       IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
 };
 template <class ElementType>
 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
 {
 public:
-
-    CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
-        : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
+    CFX_SegmentedArray(int segment_units, int index_size = 8)
+        : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size)
     {}
 
     void        Add(ElementType data)
     {
         *(ElementType*)CFX_BaseSegmentedArray::Add() = data;
     }
 
     ElementType& operator [] (int index)
     {
         return *(ElementType*)CFX_BaseSegmentedArray::GetAt(index);
     }
 };
 template <class DataType, int FixedSize>
 class CFX_FixedBufGrow : public CFX_Object
 {
 public:
-    CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)
-        : m_pAllocator(pAllocator)
-        , m_pData(NULL)
+    CFX_FixedBufGrow() : m_pData(NULL)
     {}
-    CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
-        : m_pAllocator(pAllocator)
-        , m_pData(NULL)
+    CFX_FixedBufGrow(int data_size) : m_pData(NULL)
     {
         if (data_size > FixedSize) {
-            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
+            m_pData = FX_Alloc(DataType, data_size);
         } else {
             FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
         }
     }
     void SetDataSize(int data_size)
     {
         if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
+            FX_Free(m_pData);
         }
         m_pData = NULL;
         if (data_size > FixedSize) {
-            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
+            m_pData = FX_Alloc(DataType, data_size);
         } else {
             FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
         }
     }
     ~CFX_FixedBufGrow()
     {
         if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
+            FX_Free(m_pData);
         }
     }
     operator DataType*()
     {
         return m_pData ? m_pData : m_Data;
     }
 private:
-    IFX_Allocator*      m_pAllocator;
     DataType            m_Data[FixedSize];
     DataType*           m_pData;
 };
 template <class DataType>
 class CFX_TempBuf
 {
 public:
-    CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
+    CFX_TempBuf(int size)
     {
-        m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
+        m_pData = FX_Alloc(DataType, size);
     }
     ~CFX_TempBuf()
     {
         if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
+            FX_Free(m_pData);
         }
     }
     DataType&   operator[](int i)
     {
         FXSYS_assert(m_pData != NULL);
         return m_pData[i];
     }
     operator DataType*()
     {
         return m_pData;
     }
 private:
-    IFX_Allocator*      m_pAllocator;
     DataType*           m_pData;
 };
 class CFX_MapPtrToPtr : public CFX_Object
 {
 protected:
 
     struct CAssoc {
 
         CAssoc* pNext;
 
         void* key;
 
         void* value;
     };
 public:
-
-    CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_MapPtrToPtr(int nBlockSize = 10);
 
     ~CFX_MapPtrToPtr();
 
     int GetCount() const
     {
         return m_nCount;
     }
 
     FX_BOOL IsEmpty() const
     {
@@ skipping 23 matching lines @@
     void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;
 
     FX_DWORD GetHashTableSize() const
     {
         return m_nHashTableSize;
     }
 
     void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
 protected:
 
-    IFX_Allocator*      m_pAllocator;
-
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
 
     int m_nCount;
 
     CAssoc* m_pFreeList;
 
     struct CFX_Plex* m_pBlocks;
 
     int m_nBlockSize;
 
     FX_DWORD HashKey(void* key) const;
 
     CAssoc* NewAssoc();
 
     void FreeAssoc(CAssoc* pAssoc);
 
     CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
 };
 template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
 {
 public:
-
-    CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}
+    CFX_MapPtrTemplate() : CFX_MapPtrToPtr(10) {}
 
     FX_BOOL     Lookup(KeyType key, ValueType& rValue) const
     {
         FX_LPVOID pValue = NULL;
         if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue)) {
             return FALSE;
         }
         rValue = (ValueType)(FX_UINTPTR)pValue;
         return TRUE;
     }
@@ skipping 19 matching lines @@
         void* pValue = NULL;
         CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
         rKey = (KeyType)(FX_UINTPTR)pKey;
         rValue = (ValueType)(FX_UINTPTR)pValue;
     }
 };
 class CFX_CMapDWordToDWord : public CFX_Object
 {
 public:
 
-    CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}
-
     FX_BOOL                     Lookup(FX_DWORD key, FX_DWORD& value) const;
 
     void                        SetAt(FX_DWORD key, FX_DWORD value);
 
     void                        EstimateSize(FX_DWORD size, FX_DWORD grow_by);
 
     FX_POSITION         GetStartPosition() const;
 
     void                        GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
 protected:
 
     CFX_BinaryBuf       m_Buffer;
 };
 class CFX_MapByteStringToPtr : public CFX_Object
 {
 protected:
 
     struct CAssoc {
 
         CAssoc* pNext;
 
         FX_DWORD nHashValue;
 
         CFX_ByteString key;
 
         void* value;
     };
 public:
-
-    CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_MapByteStringToPtr(int nBlockSize = 10);
 
     int GetCount() const
     {
         return m_nCount;
     }
 
     FX_BOOL IsEmpty() const
     {
         return m_nCount == 0;
     }
@@ skipping 23 matching lines @@
     FX_DWORD GetHashTableSize() const
     {
         return m_nHashTableSize;
     }
 
     void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
 
     FX_DWORD HashKey(FX_BSTR key) const;
 protected:
 
-    IFX_Allocator*      m_pAllocator;
-
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
 
     int m_nCount;
 
     CAssoc* m_pFreeList;
 
     struct CFX_Plex* m_pBlocks;
 
     int m_nBlockSize;
 
     CAssoc* NewAssoc();
 
     void FreeAssoc(CAssoc* pAssoc);
 
     CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
 public:
 
     ~CFX_MapByteStringToPtr();
 };
 class CFX_CMapByteStringToPtr : public CFX_Object
 {
 public:
-
-    CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);
+    CFX_CMapByteStringToPtr();
 
     ~CFX_CMapByteStringToPtr();
 
     void                        RemoveAll();
 
     FX_POSITION         GetStartPosition() const;
 
     void                        GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
 
     FX_LPVOID           GetNextValue(FX_POSITION& rNextPosition) const;
@@ skipping 17 matching lines @@
 
     struct CNode {
 
         CNode* pNext;
 
         CNode* pPrev;
 
         void* data;
     };
 public:
-
-    CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_PtrList(int nBlockSize = 10);
 
     FX_POSITION GetHeadPosition() const
     {
         return (FX_POSITION)m_pNodeHead;
     }
 
     FX_POSITION GetTailPosition() const
     {
         return (FX_POSITION)m_pNodeTail;
     }
@@ skipping 47 matching lines @@
 
     FX_POSITION Find(void* searchValue, FX_POSITION startAfter = NULL ) const;
 
     FX_POSITION FindIndex(int index) const;
 
     void        RemoveAt(FX_POSITION pos);
 
     void        RemoveAll();
 protected:
 
-    IFX_Allocator*      m_pAllocator;
-
     CNode* m_pNodeHead;
 
     CNode* m_pNodeTail;
 
     int m_nCount;
 
     CNode* m_pNodeFree;
 
     struct CFX_Plex* m_pBlocks;
 
@@ skipping 16 matching lines @@
     FX_LPVOID                           m_pData;
 
     PD_CALLBACK_FREEDATA        m_pCallback;
 
     FX_BOOL                                     m_bSelfDestruct;
 };
 class CFX_PrivateData
 {
 public:
 
-    CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}
-
     ~CFX_PrivateData();
 
     void                                        ClearAll();
 
     void                                        SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);
 
     void                                        SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);
 
     FX_LPVOID                           GetPrivateData(FX_LPVOID module_id);
 
@@ skipping 268 matching lines @@
 
     struct DataList {
 
         FX_INT32        start;
 
         FX_INT32        count;
         FX_LPBYTE       data;
     };
 public:
 
-    CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}
+    CFX_SortListArray() : m_CurList(0) {}
 
     ~CFX_SortListArray()
     {
         Clear();
     }
 
 
     void                        Clear()
     {
-        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
         for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--) {
             DataList list = m_DataLists.ElementAt(i);
             if (list.data) {
-                FX_Allocator_Free(pAllocator, list.data);
+                FX_Free(list.data);
             }
         }
         m_DataLists.RemoveAll();
         m_CurList = 0;
     }
 
     void                        Append(FX_INT32 nStart, FX_INT32 nCount)
     {
         if (nStart < 0) {
             return;
         }
-        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
         while (nCount > 0) {
             FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
             DataList list;
-            list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
+            list.data = FX_Alloc(FX_BYTE, temp_count * unit);

[palmer, 2014/07/07 19:17:53]

Potential integer overflow here. Especially since you memset the memory to 0 on
line 1474, it is safer and faster to just use calloc.

(You might resolve the integer overflow in the definition of FX_Alloc by just
making it be a call to calloc.)

(Note that calloc has the potential to (a) check for overflow and (b) be faster
than malloc + memset.)

             if (!list.data) {
                 break;
             }
             FXSYS_memset32(list.data, 0, temp_count * unit);
             list.start = nStart;
             list.count = temp_count;
             Append(list);
             nCount -= temp_count;
             nStart += temp_count;
         }
@@ skipping 94 matching lines @@
     Ready,
     ToBeContinued,
     Found,
     NotFound,
     Failed,
     Done
 } FX_ProgressiveStatus;
 #define ProgressiveStatus       FX_ProgressiveStatus
 #define FX_NAMESPACE_DECLARE(namespace, type)       namespace::type
 #endif