Use stdint.h types throughout PDFium.

core/src/fxcrt/fx_basic_array.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_basic.h"
 #include "../../../third_party/base/numerics/safe_math.h"
 
 CFX_BasicArray::CFX_BasicArray(int unit_size)
@@ skipping 20 matching lines @@
         return 0 == nNewSize;
     }
 
     if (m_pData == NULL) {
         pdfium::base::CheckedNumeric<int> totalSize = nNewSize;
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid()) {
             m_nSize = m_nMaxSize = 0;
             return FALSE;
         }
-        m_pData = FX_Alloc(FX_BYTE, totalSize.ValueOrDie());
+        m_pData = FX_Alloc(uint8_t, totalSize.ValueOrDie());
         m_nSize = m_nMaxSize = nNewSize;
     } else if (nNewSize <= m_nMaxSize) {
         if (nNewSize > m_nSize) {
             FXSYS_memset32(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
         }
         m_nSize = nNewSize;
     } else {
         int nNewMax = nNewSize < m_nMaxSize ? m_nMaxSize : nNewSize;
         pdfium::base::CheckedNumeric<int> totalSize = nNewMax;
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid() || nNewMax < m_nSize) {
             return FALSE;
         }
-        FX_LPBYTE pNewData = FX_Realloc(FX_BYTE, m_pData, totalSize.ValueOrDie());
+        FX_LPBYTE pNewData = FX_Realloc(uint8_t, m_pData, totalSize.ValueOrDie());
         if (pNewData == NULL) {
             return FALSE;
         }
         FXSYS_memset32(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
         m_pData = pNewData;
         m_nSize = nNewSize;
         m_nMaxSize = nNewMax;
     }
     return TRUE;
 }
@@ skipping 112 matching lines @@
     _ClearIndex(m_IndexDepth, m_IndexSize, (void**)m_pIndex);
     m_pIndex = NULL;
     m_IndexDepth = 0;
     m_DataSize = 0;
 }
 void* CFX_BaseSegmentedArray::Add()
 {
     if (m_DataSize % m_SegmentSize) {
         return GetAt(m_DataSize ++);
     }
-    void* pSegment = FX_Alloc2D(FX_BYTE, m_UnitSize, m_SegmentSize);
+    void* pSegment = FX_Alloc2D(uint8_t, m_UnitSize, m_SegmentSize);
     if (m_pIndex == NULL) {
         m_pIndex = pSegment;
         m_DataSize ++;
         return pSegment;
     }
     if (m_IndexDepth == 0) {
         void** pIndex = (void**)FX_Alloc(void*, m_IndexSize);
         pIndex[0] = m_pIndex;
         pIndex[1] = pSegment;
         m_pIndex = pIndex;
@@ skipping 109 matching lines @@
     int seg_index = index / m_SegmentSize;
     return (FX_LPBYTE)GetIndex(seg_index)[seg_index % m_IndexSize] + (index % m_SegmentSize) * m_UnitSize;
 }
 void CFX_BaseSegmentedArray::Delete(int index, int count)
 {
     if(index < 0 || count < 1 || index + count > m_DataSize) {
         return;
     }
     int i;
     for (i = index; i < m_DataSize - count; i ++) {
-        FX_BYTE* pSrc = (FX_BYTE*)GetAt(i + count);
-        FX_BYTE* pDest = (FX_BYTE*)GetAt(i);
+        uint8_t* pSrc = (uint8_t*)GetAt(i + count);
+        uint8_t* pDest = (uint8_t*)GetAt(i);
         for (int j = 0; j < m_UnitSize; j ++) {
             pDest[j] = pSrc[j];
         }
     }
     int new_segs = (m_DataSize - count + m_SegmentSize - 1) / m_SegmentSize;
     int old_segs = (m_DataSize + m_SegmentSize - 1) / m_SegmentSize;
     if (new_segs < old_segs) {
         if(m_IndexDepth) {
             for (i = new_segs; i < old_segs; i ++) {
                 void** pIndex = GetIndex(i);
                 FX_Free(pIndex[i % m_IndexSize]);
                 pIndex[i % m_IndexSize] = NULL;
             }
         } else {
             FX_Free(m_pIndex);
             m_pIndex = NULL;
         }
     }
     m_DataSize -= count;
 }