Use stdint.h types throughout PDFium.

core/include/fpdfapi/fpdf_parser.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_INCLUDE_FPDFAPI_FPDF_PARSER_H_
 #define CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_
 
 #include "../fxcrt/fx_ext.h"
@@ skipping 251 matching lines @@
     CPDF_Object*                GetObjectByStrict(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, struct PARSE_CONTEXT* pContext = NULL);
 
     int                                 GetDirectNum();
 
     CFX_ByteString              GetString(FX_DWORD objnum, FX_DWORD gennum);
 
     CFX_ByteString              GetName();
 
     CFX_ByteString              GetKeyword();
 
-    void                                GetBinary(FX_BYTE* buffer, FX_DWORD size);
+    void                                GetBinary(uint8_t* buffer, FX_DWORD size);
 
     void                                ToNextLine();
 
     void                                ToNextWord();
 
     FX_BOOL                             SearchWord(FX_BSTR word, FX_BOOL bWholeWord, FX_BOOL bForward, FX_FILESIZE limit);
 
     int                                 SearchMultiWord(FX_BSTR words, FX_BOOL bWholeWord, FX_FILESIZE limit);
 
     FX_FILESIZE                 FindTag(FX_BSTR tag, FX_FILESIZE limit);
 
     void                                SetEncrypt(CPDF_CryptoHandler* pCryptoHandler)
     {
         m_pCryptoHandler = pCryptoHandler;
     }
 
     FX_BOOL                             IsEncrypted()
     {
         return m_pCryptoHandler != NULL;
     }
 
-    FX_BOOL                             GetCharAt(FX_FILESIZE pos, FX_BYTE& ch);
+    FX_BOOL                             GetCharAt(FX_FILESIZE pos, uint8_t& ch);
 
-    FX_BOOL                             ReadBlock(FX_BYTE* pBuf, FX_DWORD size);
+    FX_BOOL                             ReadBlock(uint8_t* pBuf, FX_DWORD size);
 
     CFX_ByteString              GetNextWord(FX_BOOL& bIsNumber);
 protected:
     static const int kParserMaxRecursionDepth = 64;
     static int s_CurrentRecursionDepth;
 
-    virtual FX_BOOL                             GetNextChar(FX_BYTE& ch);
+    virtual FX_BOOL                             GetNextChar(uint8_t& ch);
 
-    FX_BOOL                             GetCharAtBackward(FX_FILESIZE pos, FX_BYTE& ch);
+    FX_BOOL                             GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch);
 
     void                                GetNextWord();
 
     FX_BOOL                             IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, FX_LPCBYTE tag, FX_DWORD taglen);
 
     CFX_ByteString              ReadString();
 
     CFX_ByteString              ReadHexString();
 
     CPDF_Stream*                ReadStream(CPDF_Dictionary* pDict, PARSE_CONTEXT* pContext, FX_DWORD objnum, FX_DWORD gennum);
 
     FX_FILESIZE                 m_Pos;
 
     FX_BOOL                             m_bFileStream;
 
     int                                 m_MetadataObjnum;
 
     IFX_FileRead*               m_pFileAccess;
 
     FX_DWORD                    m_HeaderOffset;
 
     FX_FILESIZE                 m_FileLen;
 
-    FX_BYTE*                    m_pFileBuf;
+    uint8_t*                    m_pFileBuf;
 
     FX_DWORD                    m_BufSize;
 
     FX_FILESIZE                 m_BufOffset;
 
     CPDF_CryptoHandler* m_pCryptoHandler;
 
-    FX_BYTE                             m_WordBuffer[257];
+    uint8_t                             m_WordBuffer[257];
 
     FX_DWORD                    m_WordSize;
 
     FX_BOOL                             m_bIsNumber;
 
     FX_FILESIZE                 m_dwWordPos;
     friend class                CPDF_Parser;
     friend class                CPDF_DataAvail;
 };
 
@@ skipping 103 matching lines @@
 
     FX_FILESIZE                 GetObjectOffset(FX_DWORD objnum);
 
     FX_FILESIZE                 GetObjectSize(FX_DWORD objnum);
 
     int                                 GetObjectVersion(FX_DWORD objnum)
     {
         return m_ObjVersion[objnum];
     }
 
-    void                                GetIndirectBinary(FX_DWORD objnum, FX_BYTE*& pBuffer, FX_DWORD& size);
+    void                                GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD& size);
 
     FX_BOOL                             GetFileStreamOption()
     {
         return m_Syntax.m_bFileStream;
     }
 
     void                                SetFileStreamOption(FX_BOOL b)
     {
         m_Syntax.m_bFileStream = b;
     }
@@ skipping 156 matching lines @@
     }
 
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
                                  FX_LPCBYTE user_pass, FX_DWORD user_size,
                                  FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
 
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
                                  FX_LPCBYTE user_pass, FX_DWORD user_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
 
     CFX_ByteString              GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size);
-    CFX_ByteString              GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size, FX_INT32 key_len);
+    CFX_ByteString              GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size, int32_t key_len);
     int                                 GetVersion()
     {
         return m_Version;
     }
     int                                 GetRevision()
     {
         return m_Revision;
     }
 
     int                                 CheckPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_BOOL bOwner, FX_LPBYTE key);
     int                                 CheckPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_BOOL bOwner, FX_LPBYTE key, int key_len);
 private:
 
     int                                 m_Version;
 
     int                                 m_Revision;
 
     CPDF_Parser*                m_pParser;
 
     CPDF_Dictionary*    m_pEncryptDict;
 
     FX_BOOL                             LoadDict(CPDF_Dictionary* pEncryptDict);
     FX_BOOL                             LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len);
 
     FX_BOOL                             CheckUserPassword(FX_LPCBYTE password, FX_DWORD pass_size,
-                                          FX_BOOL bIgnoreEncryptMeta, FX_LPBYTE key, FX_INT32 key_len);
+                                          FX_BOOL bIgnoreEncryptMeta, FX_LPBYTE key, int32_t key_len);
 
-    FX_BOOL                             CheckOwnerPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_LPBYTE key, FX_INT32 key_len);
+    FX_BOOL                             CheckOwnerPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_LPBYTE key, int32_t key_len);
     FX_BOOL                             AES256_CheckPassword(FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPBYTE key);
     void                                AES256_SetPassword(CPDF_Dictionary* pEncryptDict, FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPCBYTE key);
     void                                AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permission, FX_BOOL bEncryptMetadata, FX_LPCBYTE key);
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
                                  FX_LPCBYTE user_pass, FX_DWORD user_size,
                                  FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type);
-    FX_BOOL                             CheckSecurity(FX_INT32 key_len);
+    FX_BOOL                             CheckSecurity(int32_t key_len);
 
     FX_BOOL                             m_bOwner;
 
     FX_DWORD                    m_Permissions;
 
     int                                 m_Cipher;
 
-    FX_BYTE                             m_EncryptKey[32];
+    uint8_t                             m_EncryptKey[32];
 
     int                                 m_KeyLen;
 };
 class CPDF_CryptoHandler 
 {
 public:
 
     virtual ~CPDF_CryptoHandler() {}
 
     virtual FX_BOOL             Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler) = 0;
@@ skipping 32 matching lines @@
     virtual FX_BOOL             EncryptContent(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size,
                                        FX_LPBYTE dest_buf, FX_DWORD& dest_size);
 protected:
 
     virtual void                CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, FX_LPCBYTE src_buf, FX_DWORD src_size,
                                    FX_LPBYTE dest_buf, FX_DWORD& dest_size);
     virtual FX_LPVOID   CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt);
     virtual FX_BOOL             CryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
     virtual FX_BOOL             CryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
 
-    FX_BYTE                             m_EncryptKey[32];
+    uint8_t                             m_EncryptKey[32];
 
     int                                 m_KeyLen;
 
     int                                 m_Cipher;
 
     FX_LPBYTE                   m_pAESContext;
 };
 class CPDF_Point 
 {
 public:
@@ skipping 46 matching lines @@
     CFDF_Document();
     void        ParseStream(IFX_FileRead *pFile, FX_BOOL bOwnFile);
     CPDF_Dictionary*            m_pRootDict;
     IFX_FileRead*                       m_pFile;
     FX_BOOL                                     m_bOwnFile;
 };
 
 CFX_WideString  FPDF_FileSpec_GetWin32Path(const CPDF_Object* pFileSpec);
 void                    FPDF_FileSpec_SetWin32Path(CPDF_Object* pFileSpec, const CFX_WideString& fullpath);
 
-void FlateEncode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
-FX_DWORD FlateDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
-FX_DWORD RunLengthDecode(const FX_BYTE* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
+void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
+FX_DWORD FlateDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
+FX_DWORD RunLengthDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
 class CPDF_NumberTree 
 {
 public:
 
     CPDF_NumberTree(CPDF_Dictionary* pRoot)
     {
         m_pRoot = pRoot;
     }
 
     CPDF_Object*                LookupValue(int num);
@@ skipping 26 matching lines @@
     static IPDF_DataAvail* Create(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
     virtual ~IPDF_DataAvail() { }
 
     IFX_FileAvail* GetFileAvail() const { return m_pFileAvail; }
     IFX_FileRead* GetFileRead() const { return m_pFileRead; }
 
     virtual FX_BOOL                     IsDocAvail(IFX_DownloadHints* pHints) = 0;
     virtual void                        SetDocument(CPDF_Document* pDoc) = 0;
     virtual FX_BOOL                     IsPageAvail(int iPage, IFX_DownloadHints* pHints) = 0;
     virtual FX_BOOL                     IsLinearized() = 0;
-    virtual FX_INT32            IsFormAvail(IFX_DownloadHints *pHints) = 0;
-    virtual FX_INT32            IsLinearizedPDF() = 0;
+    virtual int32_t             IsFormAvail(IFX_DownloadHints *pHints) = 0;
+    virtual int32_t             IsLinearizedPDF() = 0;
     virtual void                                GetLinearizedMainXRefInfo(FX_FILESIZE *pPos, FX_DWORD *pSize) = 0;
 
 protected:
     IPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
 
     IFX_FileAvail* m_pFileAvail;
     IFX_FileRead* m_pFileRead;
 };
 class CPDF_SortObjNumArray 
 {
@@ skipping 47 matching lines @@
     PDF_DATAAVAIL_PAGE,
     PDF_DATAAVAIL_PAGE_LATERLOAD,
     PDF_DATAAVAIL_RESOURCES,
     PDF_DATAAVAIL_DONE,
     PDF_DATAAVAIL_ERROR,
     PDF_DATAAVAIL_LOADALLFILE,
     PDF_DATAAVAIL_TRAILER_APPEND
 };
 
 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_