Use stdint.h types throughout PDFium.

core/src/fxcrt/extension.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 CORE_SRC_FXCRT_EXTENSION_H_
 #define CORE_SRC_FXCRT_EXTENSION_H_
 
 #include "../../include/fxcrt/fx_safe_types.h"
@@ skipping 142 matching lines @@
         , m_nCurPos(0)
         , m_nGrowSize(FX_MEMSTREAM_BlockSize)
         , m_bUseRange(FALSE)
     {
         m_Blocks.Add(pBuffer);
         m_dwFlags = FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
     }
     ~CFX_MemoryStream()
     {
         if (m_dwFlags & FX_MEMSTREAM_TakeOver) {
-            for (FX_INT32 i = 0; i < m_Blocks.GetSize(); i++) {
+            for (int32_t i = 0; i < m_Blocks.GetSize(); i++) {
                 FX_Free((FX_LPBYTE)m_Blocks[i]);
             }
         }
         m_Blocks.RemoveAll();
     }
     virtual IFX_FileStream*             Retain()  override
     {
         m_dwCount ++;
         return this;
     }
@@ skipping 89 matching lines @@
         if (m_nCurPos >= m_nCurSize) {
             return 0;
         }
         if (m_bUseRange) {
             size_t availSize = m_nOffset + m_nSize - m_nCurPos;
             if (availSize < size) {
                 size -= size - (size_t)availSize;
             }
         }
         size_t nRead = FX_MIN(size, m_nCurSize - m_nCurPos);
-        if (!ReadBlock(buffer, (FX_INT32)m_nCurPos, nRead)) {
+        if (!ReadBlock(buffer, (int32_t)m_nCurPos, nRead)) {
             return 0;
         }
         return nRead;
     }
     virtual     FX_BOOL                         WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)  override
     {
         if (!buffer || !size) {
             return FALSE;
         }
         if (m_bUseRange) {
             offset += (FX_FILESIZE)m_nOffset;
         }
         if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
             FX_SAFE_SIZE_T newPos = size; 
             newPos += offset;
             if (!newPos.IsValid())
                 return FALSE;
 
             m_nCurPos = newPos.ValueOrDie();
             if (m_nCurPos > m_nTotalSize) {
                 m_nTotalSize = (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_nGrowSize;
                 if (m_Blocks.GetSize() < 1) {
-                    void* block = FX_Alloc(FX_BYTE, m_nTotalSize);
+                    void* block = FX_Alloc(uint8_t, m_nTotalSize);
                     m_Blocks.Add(block);
                 } else {
-                    m_Blocks[0] = FX_Realloc(FX_BYTE, m_Blocks[0], m_nTotalSize);
+                    m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize);
                 }
                 if (!m_Blocks[0]) {
                     m_Blocks.RemoveAll();
                     return FALSE;
                 }
             }
             FXSYS_memcpy32((FX_LPBYTE)m_Blocks[0] + (size_t)offset, buffer, size);
             if (m_nCurSize < m_nCurPos) {
                 m_nCurSize = m_nCurPos;
             }
@@ skipping 30 matching lines @@
         return TRUE;
     }
     virtual FX_BOOL                             IsConsecutive() const  override
     {
         return m_dwFlags & FX_MEMSTREAM_Consecutive;
     }
     virtual void                                EstimateSize(size_t nInitSize, size_t nGrowSize)  override
     {
         if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
             if (m_Blocks.GetSize() < 1) {
-                FX_LPBYTE pBlock = FX_Alloc(FX_BYTE, FX_MAX(nInitSize, 4096));
+                FX_LPBYTE pBlock = FX_Alloc(uint8_t, FX_MAX(nInitSize, 4096));
                 m_Blocks.Add(pBlock);
             }
             m_nGrowSize = FX_MAX(nGrowSize, 4096);
         } else if (m_Blocks.GetSize() < 1) {
             m_nGrowSize = FX_MAX(nGrowSize, 4096);
         }
     }
     virtual FX_LPBYTE                   GetBuffer() const  override
     {
         return m_Blocks.GetSize() ? (FX_LPBYTE)m_Blocks[0] : NULL;
@@ skipping 32 matching lines @@
     size_t                      m_nOffset;
     size_t                      m_nSize;
     FX_BOOL     ExpandBlocks(size_t size)
     {
         if (m_nCurSize < size) {
             m_nCurSize = size;
         }
         if (size <= m_nTotalSize) {
             return TRUE;
         }
-        FX_INT32 iCount = m_Blocks.GetSize();
+        int32_t iCount = m_Blocks.GetSize();
         size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
-        m_Blocks.SetSize(m_Blocks.GetSize() + (FX_INT32)size);
+        m_Blocks.SetSize(m_Blocks.GetSize() + (int32_t)size);
         while (size --) {
-            FX_LPBYTE pBlock = FX_Alloc(FX_BYTE, m_nGrowSize);
+            FX_LPBYTE pBlock = FX_Alloc(uint8_t, m_nGrowSize);
             m_Blocks.SetAt(iCount ++, pBlock);
             m_nTotalSize += m_nGrowSize;
         }
         return TRUE;
     }
 };
 #ifdef __cplusplus
 extern "C" {
 #endif
 #define MT_N                    848
 #define MT_M                    456
 #define MT_Matrix_A             0x9908b0df
 #define MT_Upper_Mask   0x80000000
 #define MT_Lower_Mask   0x7fffffff
 typedef struct _FX_MTRANDOMCONTEXT {
     _FX_MTRANDOMCONTEXT()
     {
         mti = MT_N + 1;
         bHaveSeed = FALSE;
     }
     FX_DWORD mti;
     FX_BOOL      bHaveSeed;
     FX_DWORD mt[MT_N];
 } FX_MTRANDOMCONTEXT, * FX_LPMTRANDOMCONTEXT;
 typedef FX_MTRANDOMCONTEXT const * FX_LPCMTRANDOMCONTEXT;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-FX_BOOL FX_GenerateCryptoRandom(FX_LPDWORD pBuffer, FX_INT32 iCount);
+FX_BOOL FX_GenerateCryptoRandom(FX_LPDWORD pBuffer, int32_t iCount);
 #endif
 #ifdef __cplusplus
 }
 #endif
 
 #endif  // CORE_SRC_FXCRT_EXTENSION_H_