Clean CPDF_CIDFont a little

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 121 matching lines @@
 }
 
 FX_WCHAR EmbeddedUnicodeFromCharcode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
                                      uint32_t charcode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
   uint16_t cid = FPDFAPI_CIDFromCharCode(pEmbedMap, charcode);
   const auto& codes = GetFontGlobals()->m_EmbeddedToUnicodes[charset];
-  return codes.m_pMap && cid && cid < codes.m_Count ? codes.m_pMap[cid] : 0;
+  if (codes.m_pMap && cid && cid < codes.m_Count)
+    return codes.m_pMap[cid];
+  return 0;
 }
 
 uint32_t EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
                                      FX_WCHAR unicode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
   const auto& codes = GetFontGlobals()->m_EmbeddedToUnicodes[charset];
   const uint16_t* pCodes = codes.m_pMap;
@@ skipping 81 matching lines @@
   if (!str.IsEmpty())
     return str;
   FX_WCHAR ret = GetUnicodeFromCharCode(charcode);
   return ret ? ret : CFX_WideString();
 }
 
 FX_WCHAR CPDF_CIDFont::GetUnicodeFromCharCode(uint32_t charcode) const {
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
-      return (FX_WCHAR)charcode;
+      return static_cast<FX_WCHAR>(charcode);
     case CIDCODING_CID:
       if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded())
         return 0;
-      return m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)charcode);
+      return m_pCID2UnicodeMap->UnicodeFromCID(static_cast<uint16_t>(charcode));
   }
   if (m_pCID2UnicodeMap && m_pCID2UnicodeMap->IsLoaded() && m_pCMap->IsLoaded())
     return m_pCID2UnicodeMap->UnicodeFromCID(CIDFromCharCode(charcode));
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   FX_WCHAR unicode;
   int charsize = 1;
   if (charcode > 255) {
     charcode = (charcode % 256) * 256 + (charcode / 256);
     charsize = 2;
   }
-  int ret = FXSYS_MultiByteToWideChar(g_CharsetCPs[m_pCMap->m_Coding], 0,
-                                      (const FX_CHAR*)&charcode, charsize,
-                                      &unicode, 1);
+  int ret = FXSYS_MultiByteToWideChar(
+      g_CharsetCPs[m_pCMap->m_Coding], 0,
+      reinterpret_cast<const FX_CHAR*>(&charcode), charsize, &unicode, 1);
   return ret == 1 ? unicode : 0;
 #else
   if (!m_pCMap->m_pEmbedMap)
     return 0;
   return EmbeddedUnicodeFromCharcode(m_pCMap->m_pEmbedMap, m_pCMap->m_Charset,
                                      charcode);
 #endif
 }
 
 uint32_t CPDF_CIDFont::CharCodeFromUnicode(FX_WCHAR unicode) const {
   uint32_t charcode = CPDF_Font::CharCodeFromUnicode(unicode);
   if (charcode)
     return charcode;
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UNKNOWN:
       return 0;
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return unicode;
     case CIDCODING_CID: {
-      if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
+      if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded())
         return 0;
-      }
       uint32_t CID = 0;
       while (CID < 65536) {
         FX_WCHAR this_unicode =
-            m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)CID);
-        if (this_unicode == unicode) {
+            m_pCID2UnicodeMap->UnicodeFromCID(static_cast<uint16_t>(CID));
+        if (this_unicode == unicode)
           return CID;
-        }
         CID++;
       }
       break;
     }
   }
 
-  if (unicode < 0x80) {
+  if (unicode < 0x80)
     return static_cast<uint32_t>(unicode);
-  }
-  if (m_pCMap->m_Coding == CIDCODING_CID) {
+  if (m_pCMap->m_Coding == CIDCODING_CID)
     return 0;
-  }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   uint8_t buffer[32];
-  int ret =
-      FXSYS_WideCharToMultiByte(g_CharsetCPs[m_pCMap->m_Coding], 0, &unicode, 1,
-                                (char*)buffer, 4, nullptr, nullptr);
-  if (ret == 1) {
+  int ret = FXSYS_WideCharToMultiByte(
+      g_CharsetCPs[m_pCMap->m_Coding], 0, &unicode, 1,
+      reinterpret_cast<char*>(buffer), 4, nullptr, nullptr);
+  if (ret == 1)
     return buffer[0];
-  }
-  if (ret == 2) {
+  if (ret == 2)
     return buffer[0] * 256 + buffer[1];
-  }
 #else
   if (m_pCMap->m_pEmbedMap) {
     return EmbeddedCharcodeFromUnicode(m_pCMap->m_pEmbedMap, m_pCMap->m_Charset,
                                        unicode);
   }
 #endif
   return 0;
 }
 
 FX_BOOL CPDF_CIDFont::Load() {
@@ skipping 73 matching lines @@
     LoadSubstFont();
 
   if (m_pFontFile || (GetSubstFont()->m_SubstFlags & FXFONT_SUBST_EXACT)) {
     CPDF_Object* pmap = pCIDFontDict->GetDirectObjectFor("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) {
+        if (m_pFontFile)
           m_bCIDIsGID = true;
-        }
 #else
         m_bCIDIsGID = true;
 #endif
       }
     }
   }
 
   CheckFontMetrics();
   if (IsVertWriting()) {
     pWidthArray = pCIDFontDict->GetArrayFor("W2");
-    if (pWidthArray) {
+    if (pWidthArray)
       LoadMetricsArray(pWidthArray, m_VertMetrics, 3);
-    }
     CPDF_Array* pDefaultArray = pCIDFontDict->GetArrayFor("DW2");
     if (pDefaultArray) {
       m_DefaultVY = pDefaultArray->GetIntegerAt(0);
       m_DefaultW1 = pDefaultArray->GetIntegerAt(1);
     } else {
       m_DefaultVY = 880;
       m_DefaultW1 = -1000;
     }
   }
   return TRUE;
@@ skipping 20 matching lines @@
           int pixel_size_x = ((FXFT_Face)face)->size->metrics.x_ppem;
           int pixel_size_y = ((FXFT_Face)face)->size->metrics.y_ppem;
           if (pixel_size_x == 0 || pixel_size_y == 0) {
             rect = FX_RECT(cbox.xMin, cbox.yMax, cbox.xMax, cbox.yMin);
           } else {
             rect = FX_RECT(cbox.xMin * 1000 / pixel_size_x,
                            cbox.yMax * 1000 / pixel_size_y,
                            cbox.xMax * 1000 / pixel_size_x,
                            cbox.yMin * 1000 / pixel_size_y);
           }
-          if (rect.top > FXFT_Get_Face_Ascender(face)) {
-            rect.top = FXFT_Get_Face_Ascender(face);
-          }
-          if (rect.bottom < FXFT_Get_Face_Descender(face)) {
-            rect.bottom = FXFT_Get_Face_Descender(face);
-          }
+          rect.top = std::min(rect.top,
+                              static_cast<int>(FXFT_Get_Face_Ascender(face)));
+          rect.bottom = std::max(
+              rect.bottom, static_cast<int>(FXFT_Get_Face_Descender(face)));
           FXFT_Done_Glyph(glyph);
         }
       }
     } else {
       int err = FXFT_Load_Glyph(face, glyph_index, FXFT_LOAD_NO_SCALE);
       if (err == 0) {
         rect = FX_RECT(TT2PDF(FXFT_Get_Glyph_HoriBearingX(face), face),
                        TT2PDF(FXFT_Get_Glyph_HoriBearingY(face), face),
                        TT2PDF(FXFT_Get_Glyph_HoriBearingX(face) +
                                   FXFT_Get_Glyph_Width(face),
@@ skipping 21 matching lines @@
     }
   }
   if (charcode < 256)
     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;
+    return (charcode >= 32 && charcode < 127) ? 500 : 0;
 
   uint16_t cid = CIDFromCharCode(charcode);
   int size = m_WidthList.GetSize();
   const uint32_t* pList = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
     const uint32_t* pEntry = pList + i;
     if (IsMetricForCID(pEntry, cid))
       return static_cast<int>(pEntry[2]);
   }
   return m_DefaultWidth;
@@ skipping 116 matching lines @@
     }
     FXFT_Face face = m_Font.GetFace();
     if (unicode == 0) {
       if (!m_bAdobeCourierStd)
         return charcode ? static_cast<int>(charcode) : -1;
 
       charcode += 31;
       bool bMSUnicode = FT_UseTTCharmap(face, 3, 1);
       bool bMacRoman = !bMSUnicode && FT_UseTTCharmap(face, 1, 0);
       int iBaseEncoding = PDFFONT_ENCODING_STANDARD;
-      if (bMSUnicode) {
+      if (bMSUnicode)
         iBaseEncoding = PDFFONT_ENCODING_WINANSI;
-      } else if (bMacRoman) {
+      else if (bMacRoman)
         iBaseEncoding = PDFFONT_ENCODING_MACROMAN;
-      }
       const FX_CHAR* name = GetAdobeCharName(
           iBaseEncoding, std::vector<CFX_ByteString>(), charcode);
       if (!name)
         return charcode ? static_cast<int>(charcode) : -1;
 
       int index = 0;
       uint16_t name_unicode = PDF_UnicodeFromAdobeName(name);
       if (!name_unicode)
         return charcode ? static_cast<int>(charcode) : -1;
 
@@ skipping 24 matching lines @@
     }
     if (!face)
       return unicode;
 
     int err = FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE);
     if (err) {
       int i;
       for (i = 0; i < FXFT_Get_Face_CharmapCount(face); i++) {
         uint32_t ret = FT_CharCodeFromUnicode(
             FXFT_Get_Charmap_Encoding(FXFT_Get_Face_Charmaps(face)[i]),
-            (FX_WCHAR)charcode);
-        if (ret == 0) {
+            static_cast<FX_WCHAR>(charcode));
+        if (ret == 0)
           continue;
-        }
         FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[i]);
-        unicode = (FX_WCHAR)ret;
+        unicode = static_cast<FX_WCHAR>(ret);
         break;
       }
       if (i == FXFT_Get_Face_CharmapCount(face) && i) {
         FXFT_Set_Charmap(face, FXFT_Get_Face_Charmaps(face)[0]);
-        unicode = (FX_WCHAR)charcode;
+        unicode = static_cast<FX_WCHAR>(charcode);
       }
     }
     if (FXFT_Get_Face_Charmap(face)) {
       int index = GetGlyphIndex(unicode, pVertGlyph);
       return index != 0 ? index : -1;
     }
     return unicode;
   }
 
   if (!m_Font.GetFace())
@@ skipping 92 matching lines @@
         last_code = pObj->GetInteger();
         width_status = 2;
         iCurElement = 0;
       } else {
         if (!iCurElement) {
           result.Add(first_code);
           result.Add(last_code);
         }
         result.Add(pObj->GetInteger());
         iCurElement++;
-        if (iCurElement == nElements) {
+        if (iCurElement == nElements)
           width_status = 0;
-        }
       }
     }
   }
 }
 
 // static
 FX_FLOAT CPDF_CIDFont::CIDTransformToFloat(uint8_t ch) {
   return (ch < 128 ? ch : ch - 255) * (1.0f / 127);
 }
 
@@ skipping 17 matching lines @@
 }
 
 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;
+  return (pTransform < pEnd && CID == pTransform->cid) ? &pTransform->a
+                                                       : nullptr;
 }