Merge to XFA: Use stdint.h types throughout PDFium.

core/src/fxge/android/fpf_skiafontmgr.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 "fx_fpf.h"
 #if _FX_OS_ == _FX_ANDROID_
 #define FPF_SKIAMATCHWEIGHT_NAME1       62
 #define FPF_SKIAMATCHWEIGHT_NAME2       60
@@ skipping 46 matching lines @@
     {0xbf85ff26,        0xe1633081},
     {0xc04fe601,        0xbbeeec72},
     {0xca3812d5,        0x59b9f8f1},
     {0xca383e15,        0x59b9f8f1},
     {0xcad5eaf6,        0x59b9f8f1},
     {0xcb7a04c8,        0xc8d2e345},
     {0xfb4ce0de,        0xe1633081},
 };
 FX_DWORD FPF_SkiaGetSubstFont(FX_DWORD dwHash)
 {
-    FX_INT32 iStart = 0;
-    FX_INT32 iEnd = sizeof(g_SkiaFontmap) / sizeof(FPF_SKIAFONTMAP);
+    int32_t iStart = 0;
+    int32_t iEnd = sizeof(g_SkiaFontmap) / sizeof(FPF_SKIAFONTMAP);
     while (iStart <= iEnd) {
-        FX_INT32 iMid = (iStart + iEnd) / 2;
+        int32_t iMid = (iStart + iEnd) / 2;
         FPF_LPCSKIAFONTMAP pItem = &g_SkiaFontmap[iMid];
         if (dwHash < pItem->dwFamily) {
             iEnd = iMid - 1;
         } else if (dwHash > pItem->dwFamily) {
             iStart = iMid + 1;
         } else {
             return pItem->dwSubSt;
         }
     }
     return 0;
 }
 static const FPF_SKIAFONTMAP g_SkiaSansFontMap[] = {
     {0x58c5083,         0xd5b8d10f},
     {0x14ee2d13,        0xd5b8d10f},
     {0x779ce19d,        0xd5b8d10f},
     {0xcb7a04c8,        0xd5b8d10f},
     {0xfb4ce0de,        0xd5b8d10f},
 };
 FX_DWORD FPF_SkiaGetSansFont(FX_DWORD dwHash)
 {
-    FX_INT32 iStart = 0;
-    FX_INT32 iEnd = sizeof(g_SkiaSansFontMap) / sizeof(FPF_SKIAFONTMAP);
+    int32_t iStart = 0;
+    int32_t iEnd = sizeof(g_SkiaSansFontMap) / sizeof(FPF_SKIAFONTMAP);
     while (iStart <= iEnd) {
-        FX_INT32 iMid = (iStart + iEnd) / 2;
+        int32_t iMid = (iStart + iEnd) / 2;
         FPF_LPCSKIAFONTMAP pItem = &g_SkiaSansFontMap[iMid];
         if (dwHash < pItem->dwFamily) {
             iEnd = iMid - 1;
         } else if (dwHash > pItem->dwFamily) {
             iStart = iMid + 1;
         } else {
             return pItem->dwSubSt;
         }
     }
     return 0;
 }
-static FX_UINT32 FPF_GetHashCode_StringA(FX_LPCSTR pStr, FX_INT32 iLength, FX_BOOL bIgnoreCase = FALSE)
+static uint32_t FPF_GetHashCode_StringA(FX_LPCSTR pStr, int32_t iLength, FX_BOOL bIgnoreCase = FALSE)
 {
     if (!pStr) {
         return 0;
     }
     if (iLength < 0) {
         iLength = FXSYS_strlen(pStr);
     }
     FX_LPCSTR pStrEnd = pStr + iLength;
-    FX_UINT32 uHashCode = 0;
+    uint32_t uHashCode = 0;
     if (bIgnoreCase) {
         while (pStr < pStrEnd) {
             uHashCode = 31 * uHashCode + FXSYS_tolower(*pStr++);
         }
     } else {
         while (pStr < pStrEnd) {
             uHashCode = 31 * uHashCode + *pStr ++;
         }
     }
     return uHashCode;
@@ skipping 12 matching lines @@
     FPF_SKIACHARSET_Vietnamese          = 1 << 10,
     FPF_SKIACHARSET_Hebrew                      = 1 << 11,
     FPF_SKIACHARSET_Arabic                      = 1 << 12,
     FPF_SKIACHARSET_Baltic                      = 1 << 13,
     FPF_SKIACHARSET_Cyrillic            = 1 << 14,
     FPF_SKIACHARSET_Thai                        = 1 << 15,
     FPF_SKIACHARSET_EeasternEuropean = 1 << 16,
     FPF_SKIACHARSET_PC                          = 1 << 17,
     FPF_SKIACHARSET_OEM                         = 1 << 18,
 };
-static FX_DWORD FPF_SkiaGetCharset(FX_BYTE uCharset)
+static FX_DWORD FPF_SkiaGetCharset(uint8_t uCharset)
 {
     switch (uCharset) {
         case FXFONT_ANSI_CHARSET:
             return FPF_SKIACHARSET_Ansi;
         case FXFONT_DEFAULT_CHARSET:
             return FPF_SKIACHARSET_Default;
         case FXFONT_SYMBOL_CHARSET:
             return FPF_SKIACHARSET_Symbol;
         case FXFONT_SHIFTJIS_CHARSET:
             return FPF_SKIACHARSET_ShiftJIS;
@@ skipping 18 matching lines @@
         case FXFONT_THAI_CHARSET:
             return FPF_SKIACHARSET_Thai;
         case FXFONT_EASTEUROPE_CHARSET:
             return FPF_SKIACHARSET_EeasternEuropean;
     }
     return FPF_SKIACHARSET_Default;
 }
 static FX_DWORD FPF_SKIANormalizeFontName(FX_BSTR bsfamily)
 {
     FX_DWORD dwHash = 0;
-    FX_INT32 iLength = bsfamily.GetLength();
+    int32_t iLength = bsfamily.GetLength();
     FX_LPCSTR pBuffer = bsfamily.GetCStr();
-    for (FX_INT32 i = 0; i < iLength; i++) {
+    for (int32_t i = 0; i < iLength; i++) {
         FX_CHAR ch = pBuffer[i];
         if (ch == ' ' || ch == '-' || ch == ',') {
             continue;
         }
         dwHash = 31 * dwHash + FXSYS_tolower(ch);
     }
     return dwHash;
 }
-static FX_DWORD FPF_SKIAGetFamilyHash(FX_BSTR bsFamily, FX_DWORD dwStyle, FX_BYTE uCharset)
+static FX_DWORD FPF_SKIAGetFamilyHash(FX_BSTR bsFamily, FX_DWORD dwStyle, uint8_t uCharset)
 {
     CFX_ByteString bsFont(bsFamily);
     if (dwStyle & FXFONT_BOLD) {
         bsFont += "Bold";
     }
     if (dwStyle & FXFONT_ITALIC) {
         bsFont += "Italic";
     }
     if (dwStyle & FXFONT_SERIF) {
         bsFont += "Serif";
     }
     bsFont += uCharset;
     return FPF_GetHashCode_StringA(bsFont.c_str(), bsFont.GetLength(), TRUE);
 }
-static FX_BOOL FPF_SkiaIsCJK(FX_BYTE uCharset)
+static FX_BOOL FPF_SkiaIsCJK(uint8_t uCharset)
 {
     return (uCharset == FXFONT_GB2312_CHARSET) || (uCharset == FXFONT_CHINESEBIG5_CHARSET)
            || (uCharset == FXFONT_HANGEUL_CHARSET) || (uCharset == FXFONT_SHIFTJIS_CHARSET);
 }
 static FX_BOOL FPF_SkiaMaybeSymbol(FX_BSTR bsFacename)
 {
     CFX_ByteString bsName = bsFacename;
     bsName.MakeLower();
     return bsName.Find("symbol") > -1;
 }
@@ skipping 12 matching lines @@
     void *pkey = NULL;
     CFPF_SkiaFont *pValue = NULL;
     FX_POSITION pos = m_FamilyFonts.GetStartPosition();
     while (pos) {
         m_FamilyFonts.GetNextAssoc(pos, pkey, (void*&)pValue);
         if (pValue) {
             pValue->Release();
         }
     }
     m_FamilyFonts.RemoveAll();
-    for (FX_INT32 i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
+    for (int32_t i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
         CFPF_SkiaFontDescriptor *pFont = (CFPF_SkiaFontDescriptor*)m_FontFaces.ElementAt(i);
         if (pFont) {
             delete pFont;
         }
     }
     m_FontFaces.RemoveAll();
     if (m_FTLibrary) {
         FXFT_Done_FreeType(m_FTLibrary);
     }
 }
@@ skipping 15 matching lines @@
 }
 void CFPF_SkiaFontMgr::LoadPrivateFont(IFX_FileRead* pFontFile)
 {
 }
 void CFPF_SkiaFontMgr::LoadPrivateFont(FX_BSTR bsFileName)
 {
 }
 void CFPF_SkiaFontMgr::LoadPrivateFont(FX_LPVOID pBuffer, size_t szBuffer)
 {
 }
-IFPF_Font* CFPF_SkiaFontMgr::CreateFont(FX_BSTR bsFamilyname, FX_BYTE uCharset, FX_DWORD dwStyle, FX_DWORD dwMatch)
+IFPF_Font* CFPF_SkiaFontMgr::CreateFont(FX_BSTR bsFamilyname, uint8_t uCharset, FX_DWORD dwStyle, FX_DWORD dwMatch)
 {
     FX_DWORD dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
     IFPF_Font *pFont = NULL;
-    if (m_FamilyFonts.Lookup((void*)(FX_UINTPTR)dwHash, (void*&)pFont)) {
+    if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
         if (pFont) {
             return pFont->Retain();
         }
     }
     FX_DWORD dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
     FX_DWORD dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
     FX_DWORD dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
     FX_BOOL bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
     if (uCharset != FXFONT_ARABIC_CHARSET && FPF_SkiaMaybeArabic(bsFamilyname)) {
         uCharset = FXFONT_ARABIC_CHARSET;
     } else if (uCharset == FXFONT_ANSI_CHARSET && (dwMatch & FPF_MATCHFONT_REPLACEANSI)) {
         uCharset = FXFONT_DEFAULT_CHARSET;
     }
-    FX_INT32 nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 + FPF_SKIAMATCHWEIGHT_2 * 2;
-    FX_INT32 nItem = -1;
-    FX_INT32 nMax = -1;
-    FX_INT32 nGlyphNum = 0;
-    for (FX_INT32 i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
+    int32_t nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 + FPF_SKIAMATCHWEIGHT_2 * 2;
+    int32_t nItem = -1;
+    int32_t nMax = -1;
+    int32_t nGlyphNum = 0;
+    for (int32_t i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
         CFPF_SkiaPathFont *pFontDes = (CFPF_SkiaPathFont*)m_FontFaces.ElementAt(i);
         if(!(pFontDes->m_dwCharsets & FPF_SkiaGetCharset(uCharset))) {
             continue;
         }
-        FX_INT32 nFind = 0;
+        int32_t nFind = 0;
         FX_DWORD dwSysFontName = FPF_SKIANormalizeFontName(pFontDes->m_pFamily);
         if (dwFaceName == dwSysFontName) {
             nFind += FPF_SKIAMATCHWEIGHT_NAME1;
         }
         FX_BOOL bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
         if ((dwStyle & FXFONT_BOLD) == (pFontDes->m_dwStyle & FXFONT_BOLD)) {
             nFind += FPF_SKIAMATCHWEIGHT_1;
         }
         if ((dwStyle & FXFONT_ITALIC) == (pFontDes->m_dwStyle & FXFONT_ITALIC)) {
             nFind += FPF_SKIAMATCHWEIGHT_1;
@@ skipping 25 matching lines @@
             nMax = nFind;
             nItem = i;
         }
         if (nExpectVal <= nFind) {
             nItem = i;
             break;
         }
     }
     if (nItem > -1) {
         CFPF_SkiaFontDescriptor *pFontDes = (CFPF_SkiaFontDescriptor*)m_FontFaces.ElementAt(nItem);
+<<<<<<< HEAD
         CFPF_SkiaFont *pFont = FX_NEW CFPF_SkiaFont;
         if (pFont) {
             if (pFont->InitFont(this, pFontDes, bsFamilyname, dwStyle, uCharset)) {
-                m_FamilyFonts.SetAt((void*)(FX_UINTPTR)dwHash, (void*)pFont);
+                m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
                 return pFont->Retain();
             }
             pFont->Release();
             pFont = NULL;
+=======
+        CFPF_SkiaFont *pFont = new CFPF_SkiaFont;
+        if (pFont->InitFont(this, pFontDes, bsFamilyname, dwStyle, uCharset)) {
+            m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
+            return pFont->Retain();
+>>>>>>> bb17868... Use stdint.h types throughout PDFium.
         }
         return pFont;
     }
     return NULL;
 }
-FXFT_Face CFPF_SkiaFontMgr::GetFontFace(IFX_FileRead *pFileRead, FX_INT32 iFaceIndex)
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(IFX_FileRead *pFileRead, int32_t iFaceIndex)
 {
     if (!pFileRead) {
         return NULL;
     }
     if (pFileRead->GetSize() == 0) {
         return NULL;
     }
     if (iFaceIndex < 0) {
         return NULL;
     }
     FXFT_StreamRec streamRec;
     FXSYS_memset32(&streamRec, 0, sizeof(FXFT_StreamRec));
     streamRec.size = pFileRead->GetSize();
     streamRec.descriptor.pointer = pFileRead;
     streamRec.read = FPF_SkiaStream_Read;
     streamRec.close = FPF_SkiaStream_Close;
     FXFT_Open_Args args;
     args.flags = FT_OPEN_STREAM;
     args.stream = &streamRec;
     FXFT_Face face;
     if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
         return NULL;
     }
     FXFT_Set_Pixel_Sizes(face, 0, 64);
     return face;
 }
-FXFT_Face CFPF_SkiaFontMgr::GetFontFace(FX_BSTR bsFile, FX_INT32 iFaceIndex )
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(FX_BSTR bsFile, int32_t iFaceIndex )
 {
     if (bsFile.IsEmpty()) {
         return NULL;
     }
     if (iFaceIndex < 0) {
         return NULL;
     }
     FXFT_Open_Args args;
     args.flags = FT_OPEN_PATHNAME;
     args.pathname = (FT_String*)bsFile.GetCStr();
     FXFT_Face face;
     if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
         return FALSE;
     }
     FXFT_Set_Pixel_Sizes(face, 0, 64);
     return face;
 }
-FXFT_Face CFPF_SkiaFontMgr::GetFontFace(FX_LPCBYTE pBuffer, size_t szBuffer, FX_INT32 iFaceIndex )
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(FX_LPCBYTE pBuffer, size_t szBuffer, int32_t iFaceIndex )
 {
     if (!pBuffer || szBuffer < 1) {
         return NULL;
     }
     if (iFaceIndex < 0) {
         return NULL;
     }
     FXFT_Open_Args args;
     args.flags = FT_OPEN_MEMORY;
     args.memory_base = pBuffer;
@@ skipping 81 matching lines @@
     0,
     0,
     0,
     FPF_SKIACHARSET_OEM,
     FPF_SKIACHARSET_Symbol,
 };
 static FX_DWORD FPF_SkiaGetFaceCharset(TT_OS2 *pOS2)
 {
     FX_DWORD dwCharset = 0;
     if (pOS2) {
-        for (FX_INT32 i = 0; i < 32; i++) {
+        for (int32_t i = 0; i < 32; i++) {
             if (pOS2->ulCodePageRange1 & (1 << i)) {
                 dwCharset |= g_FPFSkiaFontCharsets[i];
             }
         }
     }
     dwCharset |= FPF_SKIACHARSET_Default;
     return dwCharset;
 }
 void CFPF_SkiaFontMgr::ReportFace(FXFT_Face face, CFPF_SkiaFontDescriptor *pFontDesc)
 {
     if (!face || !pFontDesc) {
         return;
     }
     pFontDesc->SetFamily(FXFT_Get_Face_Family_Name(face));
     if (FXFT_Is_Face_Bold(face))        {
         pFontDesc->m_dwStyle |= FXFONT_BOLD;
     }
     if (FXFT_Is_Face_Italic(face))      {
         pFontDesc->m_dwStyle |= FXFONT_ITALIC;
     }
     if (FT_IS_FIXED_WIDTH(face))        {
         pFontDesc->m_dwStyle |= FXFONT_FIXED_PITCH;
     }
     TT_OS2 *pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
     if (pOS2) {
         if (pOS2->ulCodePageRange1 & (1 << 31)) {
             pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
         }
         if (pOS2->panose[0] == 2) {
-            FX_BYTE uSerif = pOS2->panose[1];
+            uint8_t uSerif = pOS2->panose[1];
             if ((uSerif > 1 && uSerif < 10) || uSerif > 13) {
                 pFontDesc->m_dwStyle |= FXFONT_SERIF;
             }
         }
     }
     if (pOS2 && (pOS2->ulCodePageRange1 & (1 << 31))) {
         pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
     }
     pFontDesc->m_dwCharsets = FPF_SkiaGetFaceCharset(pOS2);
     pFontDesc->m_iFaceIndex = face->face_index;
     pFontDesc->m_iGlyphNum = face->num_glyphs;
 }
 void CFPF_SkiaFontMgr::OutputSystemFonts()
 {
 }
 #endif