Get rid of FX_SMALL_RECT.

core/fpdfapi/fpdf_font/cpdf_cidfont.cpp

 // Copyright 2016 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 "core/fpdfapi/fpdf_font/cpdf_cidfont.h"
 
 #include <algorithm>
 #include <vector>
@@ skipping 171 matching lines @@
     default:
       encoding = FXFT_ENCODING_UNICODE;
   }
   int err = FXFT_Select_Charmap(face, encoding);
   if (err)
     err = FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE);
   if (err && FXFT_Get_Face_Charmaps(face))
     FXFT_Set_Charmap(face, *FXFT_Get_Face_Charmaps(face));
 }
 
+bool IsMetricForCID(const uint32_t* pEntry, uint16_t CID) {
+  return pEntry[0] <= CID && pEntry[1] >= CID;
+}
+
 }  // namespace
 
 CPDF_CIDFont::CPDF_CIDFont()
     : m_pCMap(nullptr),
       m_pCID2UnicodeMap(nullptr),
-      m_bCIDIsGID(FALSE),
+      m_bCIDIsGID(false),
       m_bAnsiWidthsFixed(false),
-      m_bAdobeCourierStd(FALSE) {}
+      m_bAdobeCourierStd(false) {
+  for (size_t i = 0; i < FX_ArraySize(m_CharBBox); ++i)
+    m_CharBBox[i] = FX_RECT(-1, -1, -1, -1);
+}
 
 CPDF_CIDFont::~CPDF_CIDFont() {}
 
 bool CPDF_CIDFont::IsCIDFont() const {
   return true;
 }
 
 const CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() const {
   return this;
 }
 
 CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() {
   return this;
 }
 
 uint16_t CPDF_CIDFont::CIDFromCharCode(uint32_t charcode) const {
-  if (!m_pCMap) {
-    return (uint16_t)charcode;
-  }
-  return m_pCMap->CIDFromCharCode(charcode);
+  return m_pCMap ? m_pCMap->CIDFromCharCode(charcode)
+                 : static_cast<uint16_t>(charcode);
 }
 
 FX_BOOL CPDF_CIDFont::IsVertWriting() const {
-  return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
+  return m_pCMap && m_pCMap->IsVertWriting();
 }
 
 CFX_WideString CPDF_CIDFont::UnicodeFromCharCode(uint32_t charcode) const {
   CFX_WideString str = CPDF_Font::UnicodeFromCharCode(charcode);
   if (!str.IsEmpty())
     return str;
   FX_WCHAR ret = GetUnicodeFromCharCode(charcode);
   return ret ? ret : CFX_WideString();
 }
 
@@ skipping 95 matching lines @@
   CPDF_Dictionary* pCIDFontDict = pFonts->GetDictAt(0);
   if (!pCIDFontDict)
     return FALSE;
 
   m_BaseFont = pCIDFontDict->GetStringBy("BaseFont");
   if ((m_BaseFont.Compare("CourierStd") == 0 ||
        m_BaseFont.Compare("CourierStd-Bold") == 0 ||
        m_BaseFont.Compare("CourierStd-BoldOblique") == 0 ||
        m_BaseFont.Compare("CourierStd-Oblique") == 0) &&
       !IsEmbedded()) {
-    m_bAdobeCourierStd = TRUE;
+    m_bAdobeCourierStd = true;
   }
   CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDictBy("FontDescriptor");
   if (pFontDesc)
     LoadFontDescriptor(pFontDesc);
 
   CPDF_Object* pEncoding = m_pFontDict->GetDirectObjectBy("Encoding");
   if (!pEncoding)
     return FALSE;
 
   CFX_ByteString subtype = pCIDFontDict->GetStringBy("Subtype");
   m_bType1 = (subtype == "CIDFontType0");
 
   CPDF_CMapManager& manager = GetFontGlobals()->m_CMapManager;
   if (pEncoding->IsName()) {
     CFX_ByteString cmap = pEncoding->GetString();
     bool bPromptCJK = m_pFontFile && m_bType1;
     m_pCMap = manager.GetPredefinedCMap(cmap, bPromptCJK);
+    if (!m_pCMap)
+      return FALSE;
   } else if (CPDF_Stream* pStream = pEncoding->AsStream()) {
     m_pCMap = new CPDF_CMap;
     m_pAllocatedCMap.reset(m_pCMap);
     CPDF_StreamAcc acc;
     acc.LoadAllData(pStream, FALSE);
     m_pCMap->LoadEmbedded(acc.GetData(), acc.GetSize());
   } else {
     return FALSE;
   }
-  if (!m_pCMap)
-    return FALSE;
 
   m_Charset = m_pCMap->m_Charset;
   if (m_Charset == CIDSET_UNKNOWN) {
     CPDF_Dictionary* pCIDInfo = pCIDFontDict->GetDictBy("CIDSystemInfo");
     if (pCIDInfo) {
       m_Charset =
           CharsetFromOrdering(pCIDInfo->GetStringBy("Ordering").AsStringC());
     }
   }
   if (m_Charset != CIDSET_UNKNOWN) {
@@ skipping 16 matching lines @@
 
   if (m_pFontFile || (GetSubstFont()->m_SubstFlags & FXFONT_SUBST_EXACT)) {
     CPDF_Object* pmap = pCIDFontDict->GetDirectObjectBy("CIDToGIDMap");
     if (pmap) {
       if (CPDF_Stream* pStream = pmap->AsStream()) {
         m_pStreamAcc.reset(new CPDF_StreamAcc);
         m_pStreamAcc->LoadAllData(pStream, FALSE);
       } else if (pmap->GetString() == "Identity") {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         if (m_pFontFile) {
-          m_bCIDIsGID = TRUE;
+          m_bCIDIsGID = true;
         }
 #else
-        m_bCIDIsGID = TRUE;
+        m_bCIDIsGID = true;
 #endif
       }
     }
   }
 
   CheckFontMetrics();
   if (IsVertWriting()) {
     pWidthArray = pCIDFontDict->GetArrayBy("W2");
     if (pWidthArray) {
       LoadMetricsArray(pWidthArray, m_VertMetrics, 3);
     }
     CPDF_Array* pDefaultArray = pCIDFontDict->GetArrayBy("DW2");
     if (pDefaultArray) {
       m_DefaultVY = pDefaultArray->GetIntegerAt(0);
       m_DefaultW1 = pDefaultArray->GetIntegerAt(1);
     } else {
       m_DefaultVY = 880;
       m_DefaultW1 = -1000;
     }
   }
   return TRUE;
 }
 
 FX_RECT CPDF_CIDFont::GetCharBBox(uint32_t charcode, int level) {
-  if (charcode < 256 && m_CharBBox[charcode].right != FX_SMALL_RECT::kInvalid)
-    return FX_RECT(m_CharBBox[charcode]);
+  if (charcode < 256 && m_CharBBox[charcode].right != -1)
+    return m_CharBBox[charcode];
 
   FX_RECT rect;
   bool bVert = false;
   int glyph_index = GlyphFromCharCode(charcode, &bVert);
   FXFT_Face face = m_Font.GetFace();
   if (face) {
     if (FXFT_Is_Face_Tricky(face)) {
       int err = FXFT_Load_Glyph(face, glyph_index,
                                 FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
       if (!err) {
@@ skipping 45 matching lines @@
                         CIDTransformToFloat(pTransform[2]),
                         CIDTransformToFloat(pTransform[3]),
                         CIDTransformToFloat(pTransform[4]) * 1000,
                         CIDTransformToFloat(pTransform[5]) * 1000);
       CFX_FloatRect rect_f(rect);
       rect_f.Transform(&matrix);
       rect = rect_f.GetOuterRect();
     }
   }
   if (charcode < 256)
-    m_CharBBox[charcode] = rect.ToSmallRect();
+    m_CharBBox[charcode] = rect;
 
   return rect;
 }
+
 int CPDF_CIDFont::GetCharWidthF(uint32_t charcode, int level) {
   if (charcode < 0x80 && m_bAnsiWidthsFixed)
     return charcode >= 32 && charcode < 127 ? 500 : 0;
 
   uint16_t cid = CIDFromCharCode(charcode);
   int size = m_WidthList.GetSize();
-  uint32_t* list = m_WidthList.GetData();
+  const uint32_t* pList = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
-    if (cid >= list[i] && cid <= list[i + 1]) {
-      return (int)list[i + 2];
-    }
+    const uint32_t* pEntry = pList + i;
+    if (IsMetricForCID(pEntry, cid))
+      return static_cast<int>(pEntry[2]);
   }
   return m_DefaultWidth;
 }
+
 short CPDF_CIDFont::GetVertWidth(uint16_t CID) const {
   uint32_t vertsize = m_VertMetrics.GetSize() / 5;
-  if (vertsize == 0) {
-    return m_DefaultW1;
+  if (vertsize) {
+    const uint32_t* pTable = m_VertMetrics.GetData();
+    for (uint32_t i = 0; i < vertsize; i++) {
+      const uint32_t* pEntry = pTable + (i * 5);
+      if (IsMetricForCID(pEntry, CID))
+        return static_cast<short>(pEntry[2]);
+    }
   }
-  const uint32_t* pTable = m_VertMetrics.GetData();
-  for (uint32_t i = 0; i < vertsize; i++)
-    if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
-      return (short)(int)pTable[i * 5 + 2];
-    }
   return m_DefaultW1;
 }
+
 void CPDF_CIDFont::GetVertOrigin(uint16_t CID, short& vx, short& vy) const {
   uint32_t vertsize = m_VertMetrics.GetSize() / 5;
   if (vertsize) {
     const uint32_t* pTable = m_VertMetrics.GetData();
-    for (uint32_t i = 0; i < vertsize; i++)
-      if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
-        vx = (short)(int)pTable[i * 5 + 3];
-        vy = (short)(int)pTable[i * 5 + 4];
+    for (uint32_t i = 0; i < vertsize; i++) {
+      const uint32_t* pEntry = pTable + (i * 5);
+      if (IsMetricForCID(pEntry, CID)) {
+        vx = static_cast<short>(pEntry[3]);
+        vy = static_cast<short>(pEntry[4]);
         return;
       }
+    }
   }
   uint32_t dwWidth = m_DefaultWidth;
   int size = m_WidthList.GetSize();
-  const uint32_t* list = m_WidthList.GetData();
+  const uint32_t* pList = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
-    if (CID >= list[i] && CID <= list[i + 1]) {
-      dwWidth = (uint16_t)list[i + 2];
+    const uint32_t* pEntry = pList + i;
+    if (IsMetricForCID(pEntry, CID)) {
+      dwWidth = pEntry[2];
       break;
     }
   }
-  vx = (short)dwWidth / 2;
-  vy = (short)m_DefaultVY;
+  vx = static_cast<short>(dwWidth) / 2;
+  vy = m_DefaultVY;
 }
 
 int CPDF_CIDFont::GetGlyphIndex(uint32_t unicode, bool* pVertGlyph) {
   if (pVertGlyph)
     *pVertGlyph = false;
 
   FXFT_Face face = m_Font.GetFace();
   int index = FXFT_Get_Char_Index(face, unicode);
   if (unicode == 0x2502)
     return index;
@@ skipping 252 matching lines @@
   return (ch < 128 ? ch : ch - 255) * (1.0f / 127);
 }
 
 void CPDF_CIDFont::LoadGB2312() {
   m_BaseFont = m_pFontDict->GetStringBy("BaseFont");
   CPDF_Dictionary* pFontDesc = m_pFontDict->GetDictBy("FontDescriptor");
   if (pFontDesc)
     LoadFontDescriptor(pFontDesc);
 
   m_Charset = CIDSET_GB1;
-  m_bType1 = FALSE;
+  m_bType1 = false;
   CPDF_CMapManager& manager = GetFontGlobals()->m_CMapManager;
   m_pCMap = manager.GetPredefinedCMap("GBK-EUC-H", FALSE);
   m_pCID2UnicodeMap = manager.GetCID2UnicodeMap(m_Charset, FALSE);
   if (!IsEmbedded())
     LoadSubstFont();
 
   CheckFontMetrics();
   m_DefaultWidth = 1000;
   m_bAnsiWidthsFixed = true;
 }
 
 const uint8_t* CPDF_CIDFont::GetCIDTransform(uint16_t CID) const {
   if (m_Charset != CIDSET_JAPAN1 || m_pFontFile)
     return nullptr;
 
   const auto* pEnd = g_Japan1_VertCIDs + FX_ArraySize(g_Japan1_VertCIDs);
   const auto* pTransform = std::lower_bound(
       g_Japan1_VertCIDs, pEnd, CID,
       [](const CIDTransform& entry, uint16_t cid) { return entry.cid < cid; });
   return pTransform < pEnd && CID == pTransform->cid ? &pTransform->a : nullptr;
 }