Refactor CPDF_Document

core/fpdfapi/fpdf_parser/cpdf_document.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 "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 
 #include <memory>
 #include <set>
@@ skipping 182 matching lines @@
     if (widths[i] != *widths)
       break;
   }
   if (i == size) {
     int first = pWidthArray->GetIntegerAt(pWidthArray->GetCount() - 1);
     pWidthArray->AddInteger(first + size - 1);
     pWidthArray->AddInteger(*widths);
   } else {
     CPDF_Array* pWidthArray1 = new CPDF_Array;
     pWidthArray->Add(pWidthArray1);
-    for (i = 0; i < size; i++) {
+    for (i = 0; i < size; i++)
       pWidthArray1->AddInteger(widths[i]);
-    }
   }
   FX_Free(widths);
 }
 
 CFX_ByteString FPDF_GetPSNameFromTT(HDC hDC) {
   CFX_ByteString result;
   DWORD size = ::GetFontData(hDC, 'eman', 0, nullptr, 0);
   if (size != GDI_ERROR) {
     LPBYTE buffer = FX_Alloc(BYTE, size);
     ::GetFontData(hDC, 'eman', 0, buffer, size);
@@ skipping 78 matching lines @@
     }
   }
   return 0;
 }
 
 int InsertNewPage(CPDF_Document* pDoc,
                   int iPage,
                   CPDF_Dictionary* pPageDict,
                   CFX_ArrayTemplate<uint32_t>& pageList) {
   CPDF_Dictionary* pRoot = pDoc->GetRoot();
-  if (!pRoot)
-    return -1;
-
-  CPDF_Dictionary* pPages = pRoot->GetDictBy("Pages");
+  CPDF_Dictionary* pPages = pRoot ? pRoot->GetDictBy("Pages") : nullptr;
   if (!pPages)
     return -1;
 
   int nPages = pDoc->GetPageCount();
   if (iPage < 0 || iPage > nPages)
     return -1;
 
   if (iPage == nPages) {
     CPDF_Array* pPagesList = pPages->GetArrayBy("Kids");
     if (!pPagesList) {
       pPagesList = new CPDF_Array;
       pPages->SetAt("Kids", pPagesList);
     }
     pPagesList->Add(pPageDict, pDoc);
     pPages->SetAtInteger("Count", nPages + 1);
     pPageDict->SetAtReference("Parent", pDoc, pPages->GetObjNum());
   } else {
     std::set<CPDF_Dictionary*> stack = {pPages};
     if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, TRUE, &stack) < 0)
       return -1;
   }
   pageList.InsertAt(iPage, pPageDict->GetObjNum());
   return iPage;
 }
 
 int CountPages(CPDF_Dictionary* pPages,
                std::set<CPDF_Dictionary*>* visited_pages) {
   int count = pPages->GetIntegerBy("Count");
-  if (count > 0 && count < FPDF_PAGE_MAX_NUM) {
+  if (count > 0 && count < FPDF_PAGE_MAX_NUM)
     return count;
-  }
   CPDF_Array* pKidList = pPages->GetArrayBy("Kids");
-  if (!pKidList) {
+  if (!pKidList)
     return 0;
-  }
   count = 0;
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
-    if (!pKid || pdfium::ContainsKey(*visited_pages, pKid)) {
+    if (!pKid || pdfium::ContainsKey(*visited_pages, pKid))
       continue;
-    }
     if (pKid->KeyExist("Kids")) {
       // Use |visited_pages| to help detect circular references of pages.
       pdfium::ScopedSetInsertion<CPDF_Dictionary*> local_add(visited_pages,
                                                              pKid);
       count += CountPages(pKid, visited_pages);
     } else {
       // This page is a leaf node.
       count++;
     }
   }
   pPages->SetAtInteger("Count", count);
   return count;
 }
 
+int CalculateFlags(bool bold,
+                   bool italic,
+                   bool fixedPitch,
+                   bool serif,
+                   bool script,
+                   bool symbolic) {
+  int flags = 0;
+  if (bold)
+    flags |= PDFFONT_FORCEBOLD;
+  if (italic)
+    flags |= PDFFONT_ITALIC;
+  if (fixedPitch)
+    flags |= PDFFONT_FIXEDPITCH;
+  if (serif)
+    flags |= PDFFONT_SERIF;
+  if (script)
+    flags |= PDFFONT_SCRIPT;
+  if (symbolic)
+    flags |= PDFFONT_SYMBOLIC;
+  else
+    flags |= PDFFONT_NONSYMBOLIC;
+  return flags;
+}
+
+void ProcessNonbCJK(CPDF_Dictionary* pBaseDict,
+                    bool bold,
+                    bool italic,
+                    CFX_ByteString basefont,
+                    CPDF_Array* pWidths) {
+  if (bold && italic)
+    basefont += ",BoldItalic";
+  else if (bold)
+    basefont += ",Bold";
+  else if (italic)
+    basefont += ",Italic";
+  pBaseDict->SetAtName("Subtype", "TrueType");
+  pBaseDict->SetAtName("BaseFont", basefont);
+  pBaseDict->SetAtNumber("FirstChar", 32);
+  pBaseDict->SetAtNumber("LastChar", 255);
+  pBaseDict->SetAt("Widths", pWidths);
+}
+
 }  // namespace
 
 CPDF_Document::CPDF_Document(std::unique_ptr<CPDF_Parser> pParser)
     : CPDF_IndirectObjectHolder(),
       m_pParser(std::move(pParser)),
       m_pRootDict(nullptr),
       m_pInfoDict(nullptr),
       m_bLinearized(false),
       m_iFirstPageNo(0),
       m_dwFirstPageObjNum(0),
@@ skipping 66 matching lines @@
 
   if (level >= FX_MAX_PAGE_LEVEL)
     return nullptr;
 
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
     if (!pKid) {
       nPagesToGo--;
       continue;
     }
-    if (pKid == pPages) {
+    if (pKid == pPages)
       continue;
-    }
     if (!pKid->KeyExist("Kids")) {
-      if (nPagesToGo == 0) {
+      if (nPagesToGo == 0)
         return pKid;
-      }
+
       m_PageList.SetAt(iPage - nPagesToGo, pKid->GetObjNum());
       nPagesToGo--;
     } else {
       int nPages = pKid->GetIntegerBy("Count");
-      if (nPagesToGo < nPages) {
+      if (nPagesToGo < nPages)
         return FindPDFPage(pKid, iPage, nPagesToGo, level + 1);
-      }
+
       nPagesToGo -= nPages;
     }
   }
   return nullptr;
 }
 
+CPDF_Dictionary* CPDF_Document::GetPagesDict() const {
+  CPDF_Dictionary* pRoot = GetRoot();
+  return pRoot ? pRoot->GetDictBy("Pages") : nullptr;
+}
+
 CPDF_Dictionary* CPDF_Document::GetPage(int iPage) {
   if (iPage < 0 || iPage >= m_PageList.GetSize())
     return nullptr;
 
   if (m_bLinearized && (iPage == m_iFirstPageNo)) {
     if (CPDF_Dictionary* pDict =
             ToDictionary(GetOrParseIndirectObject(m_dwFirstPageObjNum))) {
       return pDict;
     }
   }
 
   int objnum = m_PageList.GetAt(iPage);
   if (objnum) {
     if (CPDF_Dictionary* pDict = ToDictionary(GetOrParseIndirectObject(objnum)))
       return pDict;
   }
 
-  CPDF_Dictionary* pRoot = GetRoot();
-  if (!pRoot)
-    return nullptr;
-
-  CPDF_Dictionary* pPages = pRoot->GetDictBy("Pages");
+  CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return nullptr;
 
   CPDF_Dictionary* pPage = FindPDFPage(pPages, iPage, iPage, 0);
   if (!pPage)
     return nullptr;
 
   m_PageList.SetAt(iPage, pPage->GetObjNum());
   return pPage;
 }
@@ skipping 58 matching lines @@
   for (uint32_t i = 0; i < nPages; i++) {
     uint32_t objnum1 = m_PageList.GetAt(i);
     if (objnum1 == objnum)
       return i;
 
     if (!bSkipped && objnum1 == 0) {
       skip_count = i;
       bSkipped = true;
     }
   }
-  CPDF_Dictionary* pRoot = GetRoot();
-  if (!pRoot)
-    return -1;
-
-  CPDF_Dictionary* pPages = pRoot->GetDictBy("Pages");
+  CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return -1;
 
   int index = 0;
   return FindPageIndex(pPages, skip_count, objnum, index);
 }
 
 int CPDF_Document::GetPageCount() const {
   return m_PageList.GetSize();
 }
 
 int CPDF_Document::RetrievePageCount() const {
-  CPDF_Dictionary* pRoot = GetRoot();
-  if (!pRoot)
-    return 0;
-
-  CPDF_Dictionary* pPages = pRoot->GetDictBy("Pages");
+  CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return 0;
 
   if (!pPages->KeyExist("Kids"))
     return 1;
 
   std::set<CPDF_Dictionary*> visited_pages;
   visited_pages.insert(pPages);
   return CountPages(pPages, &visited_pages);
 }
@@ skipping 62 matching lines @@
   pDict->SetAtName("Type", "Page");
   uint32_t dwObjNum = AddIndirectObject(pDict);
   if (InsertNewPage(this, iPage, pDict, m_PageList) < 0) {
     ReleaseIndirectObject(dwObjNum);
     return nullptr;
   }
   return pDict;
 }
 
 void CPDF_Document::DeletePage(int iPage) {
-  CPDF_Dictionary* pRoot = GetRoot();
-  if (!pRoot)
-    return;
-
-  CPDF_Dictionary* pPages = pRoot->GetDictBy("Pages");
+  CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return;
 
   int nPages = pPages->GetIntegerBy("Count");
   if (iPage < 0 || iPage >= nPages)
     return;
 
   std::set<CPDF_Dictionary*> stack = {pPages};
   if (InsertDeletePDFPage(this, pPages, iPage, nullptr, FALSE, &stack) < 0)
     return;
 
   m_PageList.RemoveAt(iPage);
 }
 
 CPDF_Font* CPDF_Document::AddStandardFont(const FX_CHAR* font,
                                           CPDF_FontEncoding* pEncoding) {
   CFX_ByteString name(font);
   if (PDF_GetStandardFontName(&name) < 0)
     return nullptr;
   return GetPageData()->GetStandardFont(name, pEncoding);
 }
 
+size_t CPDF_Document::CalculateEncodingDict(int charset,
+                                            CPDF_Dictionary* pBaseDict) {
+  size_t i;
+  for (i = 0; i < FX_ArraySize(g_FX_CharsetUnicodes); ++i) {
+    if (g_FX_CharsetUnicodes[i].m_Charset == charset)
+      break;
+  }
+  if (i == FX_ArraySize(g_FX_CharsetUnicodes))
+    return i;
+  CPDF_Dictionary* pEncodingDict = new CPDF_Dictionary;
+  pEncodingDict->SetAtName("BaseEncoding", "WinAnsiEncoding");
+  CPDF_Array* pArray = new CPDF_Array;
+  pArray->AddInteger(128);
+  const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
+  for (int j = 0; j < 128; j++) {
+    CFX_ByteString name = PDF_AdobeNameFromUnicode(pUnicodes[j]);
+    pArray->AddName(name.IsEmpty() ? ".notdef" : name);
+  }
+  pEncodingDict->SetAt("Differences", pArray);
+  AddIndirectObject(pEncodingDict);
+  pBaseDict->SetAtReference("Encoding", this, pEncodingDict);
+  return i;
+}
+
 CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, FX_BOOL bVert) {
   if (!pFont)
     return nullptr;
 
   bool bCJK = charset == FXFONT_CHINESEBIG5_CHARSET ||
               charset == FXFONT_GB2312_CHARSET ||
               charset == FXFONT_HANGEUL_CHARSET ||
               charset == FXFONT_SHIFTJIS_CHARSET;
   CFX_ByteString basefont = pFont->GetFamilyName();
   basefont.Replace(" ", "");
-  int flags = 0;
-  if (pFont->IsBold())
-    flags |= PDFFONT_FORCEBOLD;
-  if (pFont->IsItalic())
-    flags |= PDFFONT_ITALIC;
-  if (pFont->IsFixedWidth())
-    flags |= PDFFONT_FIXEDPITCH;
+  int flags =
+      CalculateFlags(pFont->IsBold(), pFont->IsItalic(), pFont->IsFixedWidth(),
+                     false, false, charset == FXFONT_SYMBOL_CHARSET);
 
   CPDF_Dictionary* pBaseDict = new CPDF_Dictionary;
   pBaseDict->SetAtName("Type", "Font");
   std::unique_ptr<CFX_UnicodeEncoding> pEncoding(
       new CFX_UnicodeEncoding(pFont));
   CPDF_Dictionary* pFontDict = pBaseDict;
   if (!bCJK) {
     CPDF_Array* pWidths = new CPDF_Array;
     for (int charcode = 32; charcode < 128; charcode++) {
       int glyph_index = pEncoding->GlyphFromCharCode(charcode);
       int char_width = pFont->GetGlyphWidth(glyph_index);
       pWidths->AddInteger(char_width);
     }
     if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_DEFAULT_CHARSET ||
         charset == FXFONT_SYMBOL_CHARSET) {
-      if (charset == FXFONT_SYMBOL_CHARSET) {
-        flags |= PDFFONT_SYMBOLIC;
-      } else {
-        flags |= PDFFONT_NONSYMBOLIC;
-      }
       pBaseDict->SetAtName("Encoding", "WinAnsiEncoding");
       for (int charcode = 128; charcode <= 255; charcode++) {
         int glyph_index = pEncoding->GlyphFromCharCode(charcode);
         int char_width = pFont->GetGlyphWidth(glyph_index);
         pWidths->AddInteger(char_width);
       }
     } else {
-      flags |= PDFFONT_NONSYMBOLIC;
-      size_t i;
-      for (i = 0; i < FX_ArraySize(g_FX_CharsetUnicodes); ++i) {
-        if (g_FX_CharsetUnicodes[i].m_Charset == charset)
-          break;
-      }
+      size_t i = CalculateEncodingDict(charset, pBaseDict);
       if (i < FX_ArraySize(g_FX_CharsetUnicodes)) {
-        CPDF_Dictionary* pEncodingDict = new CPDF_Dictionary;
-        pEncodingDict->SetAtName("BaseEncoding", "WinAnsiEncoding");
-        CPDF_Array* pArray = new CPDF_Array;
-        pArray->AddInteger(128);
         const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
         for (int j = 0; j < 128; j++) {
-          CFX_ByteString name = PDF_AdobeNameFromUnicode(pUnicodes[j]);
-          pArray->AddName(name.IsEmpty() ? ".notdef" : name);
           int glyph_index = pEncoding->GlyphFromCharCode(pUnicodes[j]);
           int char_width = pFont->GetGlyphWidth(glyph_index);
           pWidths->AddInteger(char_width);
         }
-        pEncodingDict->SetAt("Differences", pArray);
-        AddIndirectObject(pEncodingDict);
-        pBaseDict->SetAtReference("Encoding", this, pEncodingDict);
       }
     }
-    if (pFont->IsBold() && pFont->IsItalic())
-      basefont += ",BoldItalic";
-    else if (pFont->IsBold())
-      basefont += ",Bold";
-    else if (pFont->IsItalic())
-      basefont += ",Italic";
-
-    pBaseDict->SetAtName("Subtype", "TrueType");
-    pBaseDict->SetAtName("BaseFont", basefont);
-    pBaseDict->SetAtNumber("FirstChar", 32);
-    pBaseDict->SetAtNumber("LastChar", 255);
-    pBaseDict->SetAt("Widths", pWidths);
+    ProcessNonbCJK(pBaseDict, pFont->IsBold(), pFont->IsItalic(), basefont,
+                   pWidths);
   } else {
     flags |= PDFFONT_NONSYMBOLIC;
     pFontDict = new CPDF_Dictionary;
     CFX_ByteString cmap;
     CFX_ByteString ordering;
     int supplement = 0;
     CPDF_Array* pWidthArray = new CPDF_Array;
     switch (charset) {
       case FXFONT_CHINESEBIG5_CHARSET:
         cmap = bVert ? "ETenms-B5-V" : "ETenms-B5-H";
@@ skipping 71 matching lines @@
   if (pFont->GetSubstFont()) {
     nStemV = pFont->GetSubstFont()->m_Weight / 5;
   } else {
     static const FX_CHAR stem_chars[] = {'i', 'I', '!', '1'};
     const size_t count = FX_ArraySize(stem_chars);
     uint32_t glyph = pEncoding->GlyphFromCharCode(stem_chars[0]);
     nStemV = pFont->GetGlyphWidth(glyph);
     for (size_t i = 1; i < count; i++) {
       glyph = pEncoding->GlyphFromCharCode(stem_chars[i]);
       int width = pFont->GetGlyphWidth(glyph);
-      if (width > 0 && width < nStemV) {
+      if (width > 0 && width < nStemV)
         nStemV = width;
-      }
     }
   }
   pFontDesc->SetAtInteger("StemV", nStemV);
   AddIndirectObject(pFontDesc);
   pFontDict->SetAtReference("FontDescriptor", this, pFontDesc);
   return LoadFont(pBaseDict);
 }
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont,
@@ skipping 19 matching lines @@
   hFont = SelectObject(hDC, hFont);
   int tm_size = GetOutlineTextMetrics(hDC, 0, nullptr);
   if (tm_size == 0) {
     hFont = SelectObject(hDC, hFont);
     DeleteObject(hFont);
     DeleteDC(hDC);
     return nullptr;
   }
 
   LPBYTE tm_buf = FX_Alloc(BYTE, tm_size);
-  OUTLINETEXTMETRIC* ptm = (OUTLINETEXTMETRIC*)tm_buf;
+  OUTLINETEXTMETRIC* ptm = reinterpret_cast<OUTLINETEXTMETRIC*>(tm_buf);
   GetOutlineTextMetrics(hDC, tm_size, ptm);
-  int flags = 0, italicangle, ascend, descend, capheight, bbox[4];
-  if (pLogFont->lfItalic)
-    flags |= PDFFONT_ITALIC;
-  if ((pLogFont->lfPitchAndFamily & 3) == FIXED_PITCH)
-    flags |= PDFFONT_FIXEDPITCH;
-  if ((pLogFont->lfPitchAndFamily & 0xf8) == FF_ROMAN)
-    flags |= PDFFONT_SERIF;
-  if ((pLogFont->lfPitchAndFamily & 0xf8) == FF_SCRIPT)
-    flags |= PDFFONT_SCRIPT;
+  int flags = CalculateFlags(false, pLogFont->lfItalic != 0,
+                             (pLogFont->lfPitchAndFamily & 3) == FIXED_PITCH,
+                             (pLogFont->lfPitchAndFamily & 0xf8) == FF_ROMAN,
+                             (pLogFont->lfPitchAndFamily & 0xf8) == FF_SCRIPT,
+                             pLogFont->lfCharSet == SYMBOL_CHARSET);
 
   bool bCJK = pLogFont->lfCharSet == CHINESEBIG5_CHARSET ||
               pLogFont->lfCharSet == GB2312_CHARSET ||
               pLogFont->lfCharSet == HANGEUL_CHARSET ||
               pLogFont->lfCharSet == SHIFTJIS_CHARSET;
   CFX_ByteString basefont;
   if (bTranslateName && bCJK)
     basefont = FPDF_GetPSNameFromTT(hDC);
 
   if (basefont.IsEmpty())
     basefont = pLogFont->lfFaceName;
 
-  italicangle = ptm->otmItalicAngle / 10;
-  ascend = ptm->otmrcFontBox.top;
-  descend = ptm->otmrcFontBox.bottom;
-  capheight = ptm->otmsCapEmHeight;
-  bbox[0] = ptm->otmrcFontBox.left;
-  bbox[1] = ptm->otmrcFontBox.bottom;
-  bbox[2] = ptm->otmrcFontBox.right;
-  bbox[3] = ptm->otmrcFontBox.top;
+  int italicangle = ptm->otmItalicAngle / 10;
+  int ascend = ptm->otmrcFontBox.top;
+  int descend = ptm->otmrcFontBox.bottom;
+  int capheight = ptm->otmsCapEmHeight;
+  int bbox[4] = {ptm->otmrcFontBox.left, ptm->otmrcFontBox.bottom,
+                 ptm->otmrcFontBox.right, ptm->otmrcFontBox.top};
   FX_Free(tm_buf);
   basefont.Replace(" ", "");
   CPDF_Dictionary* pBaseDict = new CPDF_Dictionary;
   pBaseDict->SetAtName("Type", "Font");
   CPDF_Dictionary* pFontDict = pBaseDict;
   if (!bCJK) {
     if (pLogFont->lfCharSet == ANSI_CHARSET ||
         pLogFont->lfCharSet == DEFAULT_CHARSET ||
         pLogFont->lfCharSet == SYMBOL_CHARSET) {
-      if (pLogFont->lfCharSet == SYMBOL_CHARSET)
-        flags |= PDFFONT_SYMBOLIC;
-      else
-        flags |= PDFFONT_NONSYMBOLIC;
       pBaseDict->SetAtName("Encoding", "WinAnsiEncoding");
     } else {
-      flags |= PDFFONT_NONSYMBOLIC;
-      size_t i;
-      for (i = 0; i < FX_ArraySize(g_FX_CharsetUnicodes); ++i) {
-        if (g_FX_CharsetUnicodes[i].m_Charset == pLogFont->lfCharSet)
-          break;
-      }
-      if (i < FX_ArraySize(g_FX_CharsetUnicodes)) {
-        CPDF_Dictionary* pEncoding = new CPDF_Dictionary;
-        pEncoding->SetAtName("BaseEncoding", "WinAnsiEncoding");
-        CPDF_Array* pArray = new CPDF_Array;
-        pArray->AddInteger(128);
-        const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
-        for (int j = 0; j < 128; j++) {
-          CFX_ByteString name = PDF_AdobeNameFromUnicode(pUnicodes[j]);
-          pArray->AddName(name.IsEmpty() ? ".notdef" : name);
-        }
-        pEncoding->SetAt("Differences", pArray);
-        AddIndirectObject(pEncoding);
-        pBaseDict->SetAtReference("Encoding", this, pEncoding);
-      }
+      CalculateEncodingDict(pLogFont->lfCharSet, pBaseDict);
     }
-    if (pLogFont->lfWeight > FW_MEDIUM && pLogFont->lfItalic)
-      basefont += ",BoldItalic";
-    else if (pLogFont->lfWeight > FW_MEDIUM)
-      basefont += ",Bold";
-    else if (pLogFont->lfItalic)
-      basefont += ",Italic";
-
-    pBaseDict->SetAtName("Subtype", "TrueType");
-    pBaseDict->SetAtName("BaseFont", basefont);
-    pBaseDict->SetAtNumber("FirstChar", 32);
-    pBaseDict->SetAtNumber("LastChar", 255);
     int char_widths[224];
     GetCharWidth(hDC, 32, 255, char_widths);
     CPDF_Array* pWidths = new CPDF_Array;
     for (size_t i = 0; i < 224; i++)
       pWidths->AddInteger(char_widths[i]);
-
-    pBaseDict->SetAt("Widths", pWidths);
+    ProcessNonbCJK(pBaseDict, pLogFont->lfWeight > FW_MEDIUM,
+                   pLogFont->lfItalic != 0, basefont, pWidths);
   } else {
-    flags |= PDFFONT_NONSYMBOLIC;
     pFontDict = new CPDF_Dictionary;
     CFX_ByteString cmap;
     CFX_ByteString ordering;
     int supplement = 0;
     CPDF_Array* pWidthArray = new CPDF_Array;
     switch (pLogFont->lfCharSet) {
       case CHINESEBIG5_CHARSET:
         cmap = bVert ? "ETenms-B5-V" : "ETenms-B5-H";
         ordering = "CNS1";
         supplement = 4;
@@ skipping 45 matching lines @@
     pBaseDict->SetAt("DescendantFonts", pArray);
     AddIndirectObject(pFontDict);
     pArray->AddReference(this, pFontDict);
   }
   AddIndirectObject(pBaseDict);
   CPDF_Dictionary* pFontDesc = new CPDF_Dictionary;
   pFontDesc->SetAtName("Type", "FontDescriptor");
   pFontDesc->SetAtName("FontName", basefont);
   pFontDesc->SetAtInteger("Flags", flags);
   CPDF_Array* pBBox = new CPDF_Array;
-  for (int i = 0; i < 4; i++) {
+  for (int i = 0; i < 4; i++)
     pBBox->AddInteger(bbox[i]);
-  }
   pFontDesc->SetAt("FontBBox", pBBox);
   pFontDesc->SetAtInteger("ItalicAngle", italicangle);
   pFontDesc->SetAtInteger("Ascent", ascend);
   pFontDesc->SetAtInteger("Descent", descend);
   pFontDesc->SetAtInteger("CapHeight", capheight);
   pFontDesc->SetAtInteger("StemV", pLogFont->lfWeight / 5);
   AddIndirectObject(pFontDesc);
   pFontDict->SetAtReference("FontDescriptor", this, pFontDesc);
   hFont = SelectObject(hDC, hFont);
   DeleteObject(hFont);
   DeleteDC(hDC);
   return LoadFont(pBaseDict);
 }
 #endif  //  _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_