Move core/src/ up to core/.

This CL moves the core/src/ files up to core/ and fixes up the include guards,
includes and build files.

R=tsepez@chromium.org

Review URL: https://codereview.chromium.org/1800523005 .

1 files changed, 753 insertions, 0 deletions

diff --git a/core/fpdfdoc/doc_utils.cpp b/core/fpdfdoc/doc_utils.cpp
new file mode 100644
index 0000000000..5160c1115c
--- /dev/null
+++ b/core/fpdfdoc/doc_utils.cpp
@@ -0,0 +1,753 @@
+// 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 <algorithm>
+#include <vector>
+
+#include "core/fpdfdoc/doc_utils.h"
+#include "core/include/fpdfapi/cpdf_array.h"
+#include "core/include/fpdfapi/cpdf_document.h"
+#include "core/include/fpdfapi/cpdf_simple_parser.h"
+#include "core/include/fpdfdoc/fpdf_doc.h"
+
+namespace {
+
+const int FPDFDOC_UTILS_MAXRECURSION = 32;
+
+CPDF_Object* SearchNumberNode(const CPDF_Dictionary* pNode, int num) {
+  CPDF_Array* pLimits = pNode->GetArrayBy("Limits");
+  if (pLimits &&
+      (num < pLimits->GetIntegerAt(0) || num > pLimits->GetIntegerAt(1))) {
+    return NULL;
+  }
+  CPDF_Array* pNumbers = pNode->GetArrayBy("Nums");
+  if (pNumbers) {
+    FX_DWORD dwCount = pNumbers->GetCount() / 2;
+    for (FX_DWORD i = 0; i < dwCount; i++) {
+      int index = pNumbers->GetIntegerAt(i * 2);
+      if (num == index) {
+        return pNumbers->GetElementValue(i * 2 + 1);
+      }
+      if (index > num) {
+        break;
+      }
+    }
+    return NULL;
+  }
+  CPDF_Array* pKids = pNode->GetArrayBy("Kids");
+  if (!pKids) {
+    return NULL;
+  }
+  for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
+    CPDF_Dictionary* pKid = pKids->GetDictAt(i);
+    if (!pKid) {
+      continue;
+    }
+    CPDF_Object* pFound = SearchNumberNode(pKid, num);
+    if (pFound) {
+      return pFound;
+    }
+  }
+  return NULL;
+}
+
+}  // namespace
+
+CPDF_Object* CPDF_NumberTree::LookupValue(int num) const {
+  return SearchNumberNode(m_pRoot, num);
+}
+
+CFX_WideString GetFullName(CPDF_Dictionary* pFieldDict) {
+  CFX_WideString full_name;
+  CPDF_Dictionary* pLevel = pFieldDict;
+  while (pLevel) {
+    CFX_WideString short_name = pLevel->GetUnicodeTextBy("T");
+    if (short_name != L"") {
+      if (full_name == L"") {
+        full_name = short_name;
+      } else {
+        full_name = short_name + L"." + full_name;
+      }
+    }
+    pLevel = pLevel->GetDictBy("Parent");
+  }
+  return full_name;
+}
+FX_BOOL CPDF_DefaultAppearance::HasFont() {
+  if (m_csDA.IsEmpty()) {
+    return FALSE;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  return syntax.FindTagParamFromStart("Tf", 2);
+}
+CFX_ByteString CPDF_DefaultAppearance::GetFontString() {
+  CFX_ByteString csFont;
+  if (m_csDA.IsEmpty()) {
+    return csFont;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart("Tf", 2)) {
+    csFont += (CFX_ByteString)syntax.GetWord();
+    csFont += " ";
+    csFont += (CFX_ByteString)syntax.GetWord();
+    csFont += " ";
+    csFont += (CFX_ByteString)syntax.GetWord();
+  }
+  return csFont;
+}
+void CPDF_DefaultAppearance::GetFont(CFX_ByteString& csFontNameTag,
+                                     FX_FLOAT& fFontSize) {
+  csFontNameTag = "";
+  fFontSize = 0;
+  if (m_csDA.IsEmpty()) {
+    return;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart("Tf", 2)) {
+    csFontNameTag = (CFX_ByteString)syntax.GetWord();
+    csFontNameTag.Delete(0, 1);
+    fFontSize = FX_atof((CFX_ByteString)syntax.GetWord());
+  }
+  csFontNameTag = PDF_NameDecode(csFontNameTag);
+}
+FX_BOOL CPDF_DefaultAppearance::HasColor(FX_BOOL bStrokingOperation) {
+  if (m_csDA.IsEmpty()) {
+    return FALSE;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "G" : "g", 1)) {
+    return TRUE;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "RG" : "rg", 3)) {
+    return TRUE;
+  }
+  return syntax.FindTagParamFromStart(bStrokingOperation ? "K" : "k", 4);
+}
+CFX_ByteString CPDF_DefaultAppearance::GetColorString(
+    FX_BOOL bStrokingOperation) {
+  CFX_ByteString csColor;
+  if (m_csDA.IsEmpty()) {
+    return csColor;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "G" : "g", 1)) {
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    return csColor;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "RG" : "rg", 3)) {
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    return csColor;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "K" : "k", 4)) {
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+    csColor += " ";
+    csColor += (CFX_ByteString)syntax.GetWord();
+  }
+  return csColor;
+}
+void CPDF_DefaultAppearance::GetColor(int& iColorType,
+                                      FX_FLOAT fc[4],
+                                      FX_BOOL bStrokingOperation) {
+  iColorType = COLORTYPE_TRANSPARENT;
+  for (int c = 0; c < 4; c++) {
+    fc[c] = 0;
+  }
+  if (m_csDA.IsEmpty()) {
+    return;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "G" : "g", 1)) {
+    iColorType = COLORTYPE_GRAY;
+    fc[0] = FX_atof((CFX_ByteString)syntax.GetWord());
+    return;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "RG" : "rg", 3)) {
+    iColorType = COLORTYPE_RGB;
+    fc[0] = FX_atof((CFX_ByteString)syntax.GetWord());
+    fc[1] = FX_atof((CFX_ByteString)syntax.GetWord());
+    fc[2] = FX_atof((CFX_ByteString)syntax.GetWord());
+    return;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "K" : "k", 4)) {
+    iColorType = COLORTYPE_CMYK;
+    fc[0] = FX_atof((CFX_ByteString)syntax.GetWord());
+    fc[1] = FX_atof((CFX_ByteString)syntax.GetWord());
+    fc[2] = FX_atof((CFX_ByteString)syntax.GetWord());
+    fc[3] = FX_atof((CFX_ByteString)syntax.GetWord());
+  }
+}
+void CPDF_DefaultAppearance::GetColor(FX_ARGB& color,
+                                      int& iColorType,
+                                      FX_BOOL bStrokingOperation) {
+  color = 0;
+  iColorType = COLORTYPE_TRANSPARENT;
+  if (m_csDA.IsEmpty()) {
+    return;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "G" : "g", 1)) {
+    iColorType = COLORTYPE_GRAY;
+    FX_FLOAT g = FX_atof((CFX_ByteString)syntax.GetWord()) * 255 + 0.5f;
+    color = ArgbEncode(255, (int)g, (int)g, (int)g);
+    return;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "RG" : "rg", 3)) {
+    iColorType = COLORTYPE_RGB;
+    FX_FLOAT r = FX_atof((CFX_ByteString)syntax.GetWord()) * 255 + 0.5f;
+    FX_FLOAT g = FX_atof((CFX_ByteString)syntax.GetWord()) * 255 + 0.5f;
+    FX_FLOAT b = FX_atof((CFX_ByteString)syntax.GetWord()) * 255 + 0.5f;
+    color = ArgbEncode(255, (int)r, (int)g, (int)b);
+    return;
+  }
+  if (syntax.FindTagParamFromStart(bStrokingOperation ? "K" : "k", 4)) {
+    iColorType = COLORTYPE_CMYK;
+    FX_FLOAT c = FX_atof((CFX_ByteString)syntax.GetWord());
+    FX_FLOAT m = FX_atof((CFX_ByteString)syntax.GetWord());
+    FX_FLOAT y = FX_atof((CFX_ByteString)syntax.GetWord());
+    FX_FLOAT k = FX_atof((CFX_ByteString)syntax.GetWord());
+    FX_FLOAT r = 1.0f - std::min(1.0f, c + k);
+    FX_FLOAT g = 1.0f - std::min(1.0f, m + k);
+    FX_FLOAT b = 1.0f - std::min(1.0f, y + k);
+    color = ArgbEncode(255, (int)(r * 255 + 0.5f), (int)(g * 255 + 0.5f),
+                       (int)(b * 255 + 0.5f));
+  }
+}
+FX_BOOL CPDF_DefaultAppearance::HasTextMatrix() {
+  if (m_csDA.IsEmpty()) {
+    return FALSE;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  return syntax.FindTagParamFromStart("Tm", 6);
+}
+CFX_ByteString CPDF_DefaultAppearance::GetTextMatrixString() {
+  CFX_ByteString csTM;
+  if (m_csDA.IsEmpty()) {
+    return csTM;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart("Tm", 6)) {
+    for (int i = 0; i < 6; i++) {
+      csTM += (CFX_ByteString)syntax.GetWord();
+      csTM += " ";
+    }
+    csTM += (CFX_ByteString)syntax.GetWord();
+  }
+  return csTM;
+}
+CFX_Matrix CPDF_DefaultAppearance::GetTextMatrix() {
+  CFX_Matrix tm;
+  if (m_csDA.IsEmpty()) {
+    return tm;
+  }
+  CPDF_SimpleParser syntax(m_csDA);
+  if (syntax.FindTagParamFromStart("Tm", 6)) {
+    FX_FLOAT f[6];
+    for (int i = 0; i < 6; i++) {
+      f[i] = FX_atof((CFX_ByteString)syntax.GetWord());
+    }
+    tm.Set(f[0], f[1], f[2], f[3], f[4], f[5]);
+  }
+  return tm;
+}
+void InitInterFormDict(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument) {
+  if (!pDocument) {
+    return;
+  }
+  if (!pFormDict) {
+    pFormDict = new CPDF_Dictionary;
+    FX_DWORD dwObjNum = pDocument->AddIndirectObject(pFormDict);
+    CPDF_Dictionary* pRoot = pDocument->GetRoot();
+    pRoot->SetAtReference("AcroForm", pDocument, dwObjNum);
+  }
+  CFX_ByteString csDA;
+  if (!pFormDict->KeyExist("DR")) {
+    CPDF_Font* pFont = NULL;
+    CFX_ByteString csBaseName, csDefault;
+    uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
+    pFont = CPDF_InterForm::AddStandardFont(pDocument, "Helvetica");
+    if (pFont) {
+      AddInterFormFont(pFormDict, pDocument, pFont, csBaseName);
+      csDefault = csBaseName;
+    }
+    if (charSet != 0) {
+      CFX_ByteString csFontName = CPDF_InterForm::GetNativeFont(charSet, NULL);
+      if (!pFont || csFontName != "Helvetica") {
+        pFont = CPDF_InterForm::AddNativeFont(pDocument);
+        if (pFont) {
+          csBaseName = "";
+          AddInterFormFont(pFormDict, pDocument, pFont, csBaseName);
+          csDefault = csBaseName;
+        }
+      }
+    }
+    if (pFont) {
+      csDA = "/" + PDF_NameEncode(csDefault) + " 0 Tf";
+    }
+  }
+  if (!csDA.IsEmpty()) {
+    csDA += " ";
+  }
+  csDA += "0 g";
+  if (!pFormDict->KeyExist("DA")) {
+    pFormDict->SetAtString("DA", csDA);
+  }
+}
+FX_DWORD CountInterFormFonts(CPDF_Dictionary* pFormDict) {
+  if (!pFormDict) {
+    return 0;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return 0;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return 0;
+  }
+  FX_DWORD dwCount = 0;
+  for (const auto& it : *pFonts) {
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    if (CPDF_Dictionary* pDirect = ToDictionary(pObj->GetDirect())) {
+      if (pDirect->GetStringBy("Type") == "Font") {
+        dwCount++;
+      }
+    }
+  }
+  return dwCount;
+}
+CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
+                            CPDF_Document* pDocument,
+                            FX_DWORD index,
+                            CFX_ByteString& csNameTag) {
+  if (!pFormDict) {
+    return NULL;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return NULL;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return NULL;
+  }
+  FX_DWORD dwCount = 0;
+  for (const auto& it : *pFonts) {
+    const CFX_ByteString& csKey = it.first;
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
+    if (!pElement)
+      continue;
+    if (pElement->GetStringBy("Type") != "Font")
+      continue;
+    if (dwCount == index) {
+      csNameTag = csKey;
+      return pDocument->LoadFont(pElement);
+    }
+    dwCount++;
+  }
+  return NULL;
+}
+CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
+                            CPDF_Document* pDocument,
+                            CFX_ByteString csNameTag) {
+  CFX_ByteString csAlias = PDF_NameDecode(csNameTag);
+  if (!pFormDict || csAlias.IsEmpty()) {
+    return NULL;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return NULL;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return NULL;
+  }
+  CPDF_Dictionary* pElement = pFonts->GetDictBy(csAlias);
+  if (!pElement) {
+    return NULL;
+  }
+  if (pElement->GetStringBy("Type") == "Font") {
+    return pDocument->LoadFont(pElement);
+  }
+  return NULL;
+}
+CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
+                            CPDF_Document* pDocument,
+                            CFX_ByteString csFontName,
+                            CFX_ByteString& csNameTag) {
+  if (!pFormDict || csFontName.IsEmpty()) {
+    return NULL;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return NULL;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return NULL;
+  }
+  for (const auto& it : *pFonts) {
+    const CFX_ByteString& csKey = it.first;
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
+    if (!pElement)
+      continue;
+    if (pElement->GetStringBy("Type") != "Font")
+      continue;
+
+    CPDF_Font* pFind = pDocument->LoadFont(pElement);
+    if (!pFind)
+      continue;
+
+    CFX_ByteString csBaseFont;
+    csBaseFont = pFind->GetBaseFont();
+    csBaseFont.Remove(' ');
+    if (csBaseFont == csFontName) {
+      csNameTag = csKey;
+      return pFind;
+    }
+  }
+  return NULL;
+}
+CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict,
+                                  CPDF_Document* pDocument,
+                                  uint8_t charSet,
+                                  CFX_ByteString& csNameTag) {
+  if (!pFormDict) {
+    return NULL;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return NULL;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return NULL;
+  }
+  for (const auto& it : *pFonts) {
+    const CFX_ByteString& csKey = it.first;
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
+    if (!pElement)
+      continue;
+    if (pElement->GetStringBy("Type") != "Font")
+      continue;
+    CPDF_Font* pFind = pDocument->LoadFont(pElement);
+    if (!pFind) {
+      continue;
+    }
+    CFX_SubstFont* pSubst = (CFX_SubstFont*)pFind->GetSubstFont();
+    if (!pSubst) {
+      continue;
+    }
+    if (pSubst->m_Charset == (int)charSet) {
+      csNameTag = csKey;
+      return pFind;
+    }
+  }
+  return NULL;
+}
+CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict,
+                                  CPDF_Document* pDocument,
+                                  CFX_ByteString& csNameTag) {
+  csNameTag = "";
+  uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
+  CFX_SubstFont* pSubst;
+  CPDF_Font* pFont = GetDefaultInterFormFont(pFormDict, pDocument);
+  if (pFont) {
+    pSubst = (CFX_SubstFont*)pFont->GetSubstFont();
+    if (pSubst && pSubst->m_Charset == (int)charSet) {
+      FindInterFormFont(pFormDict, pFont, csNameTag);
+      return pFont;
+    }
+  }
+  return GetNativeInterFormFont(pFormDict, pDocument, charSet, csNameTag);
+}
+FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
+                          const CPDF_Font* pFont,
+                          CFX_ByteString& csNameTag) {
+  if (!pFormDict || !pFont) {
+    return FALSE;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return FALSE;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return FALSE;
+  }
+  for (const auto& it : *pFonts) {
+    const CFX_ByteString& csKey = it.first;
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
+    if (!pElement)
+      continue;
+    if (pElement->GetStringBy("Type") != "Font") {
+      continue;
+    }
+    if (pFont->GetFontDict() == pElement) {
+      csNameTag = csKey;
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict,
+                          CPDF_Document* pDocument,
+                          CFX_ByteString csFontName,
+                          CPDF_Font*& pFont,
+                          CFX_ByteString& csNameTag) {
+  if (!pFormDict) {
+    return FALSE;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return FALSE;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return FALSE;
+  }
+  if (csFontName.GetLength() > 0) {
+    csFontName.Remove(' ');
+  }
+  for (const auto& it : *pFonts) {
+    const CFX_ByteString& csKey = it.first;
+    CPDF_Object* pObj = it.second;
+    if (!pObj) {
+      continue;
+    }
+    CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
+    if (!pElement)
+      continue;
+    if (pElement->GetStringBy("Type") != "Font") {
+      continue;
+    }
+    pFont = pDocument->LoadFont(pElement);
+    if (!pFont) {
+      continue;
+    }
+    CFX_ByteString csBaseFont;
+    csBaseFont = pFont->GetBaseFont();
+    csBaseFont.Remove(' ');
+    if (csBaseFont == csFontName) {
+      csNameTag = csKey;
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+void AddInterFormFont(CPDF_Dictionary*& pFormDict,
+                      CPDF_Document* pDocument,
+                      const CPDF_Font* pFont,
+                      CFX_ByteString& csNameTag) {
+  if (!pFont) {
+    return;
+  }
+  if (!pFormDict) {
+    InitInterFormDict(pFormDict, pDocument);
+  }
+  CFX_ByteString csTag;
+  if (FindInterFormFont(pFormDict, pFont, csTag)) {
+    csNameTag = csTag;
+    return;
+  }
+  if (!pFormDict) {
+    InitInterFormDict(pFormDict, pDocument);
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    pDR = new CPDF_Dictionary;
+    pFormDict->SetAt("DR", pDR);
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    pFonts = new CPDF_Dictionary;
+    pDR->SetAt("Font", pFonts);
+  }
+  if (csNameTag.IsEmpty()) {
+    csNameTag = pFont->GetBaseFont();
+  }
+  csNameTag.Remove(' ');
+  csNameTag =
+      CPDF_InterForm::GenerateNewResourceName(pDR, "Font", 4, csNameTag);
+  pFonts->SetAtReference(csNameTag, pDocument, pFont->GetFontDict());
+}
+CPDF_Font* AddNativeInterFormFont(CPDF_Dictionary*& pFormDict,
+                                  CPDF_Document* pDocument,
+                                  uint8_t charSet,
+                                  CFX_ByteString& csNameTag) {
+  if (!pFormDict) {
+    InitInterFormDict(pFormDict, pDocument);
+  }
+  CFX_ByteString csTemp;
+  CPDF_Font* pFont =
+      GetNativeInterFormFont(pFormDict, pDocument, charSet, csTemp);
+  if (pFont) {
+    csNameTag = csTemp;
+    return pFont;
+  }
+  CFX_ByteString csFontName = CPDF_InterForm::GetNativeFont(charSet);
+  if (!csFontName.IsEmpty()) {
+    if (FindInterFormFont(pFormDict, pDocument, csFontName, pFont, csNameTag)) {
+      return pFont;
+    }
+  }
+  pFont = CPDF_InterForm::AddNativeFont(charSet, pDocument);
+  if (pFont) {
+    AddInterFormFont(pFormDict, pDocument, pFont, csNameTag);
+  }
+  return pFont;
+}
+CPDF_Font* AddNativeInterFormFont(CPDF_Dictionary*& pFormDict,
+                                  CPDF_Document* pDocument,
+                                  CFX_ByteString& csNameTag) {
+  uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
+  return AddNativeInterFormFont(pFormDict, pDocument, charSet, csNameTag);
+}
+void RemoveInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont) {
+  if (!pFormDict || !pFont) {
+    return;
+  }
+  CFX_ByteString csTag;
+  if (!FindInterFormFont(pFormDict, pFont, csTag)) {
+    return;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  pFonts->RemoveAt(csTag);
+}
+void RemoveInterFormFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag) {
+  if (!pFormDict || csNameTag.IsEmpty()) {
+    return;
+  }
+  CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
+  if (!pDR) {
+    return;
+  }
+  CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
+  if (!pFonts) {
+    return;
+  }
+  pFonts->RemoveAt(csNameTag);
+}
+
+CPDF_Font* GetDefaultInterFormFont(CPDF_Dictionary* pFormDict,
+                                   CPDF_Document* pDocument) {
+  if (!pFormDict) {
+    return NULL;
+  }
+  CPDF_DefaultAppearance cDA(pFormDict->GetStringBy("DA"));
+  CFX_ByteString csFontNameTag;
+  FX_FLOAT fFontSize;
+  cDA.GetFont(csFontNameTag, fFontSize);
+  return GetInterFormFont(pFormDict, pDocument, csFontNameTag);
+}
+
+CPDF_IconFit::ScaleMethod CPDF_IconFit::GetScaleMethod() {
+  if (!m_pDict) {
+    return Always;
+  }
+  CFX_ByteString csSW = m_pDict->GetStringBy("SW", "A");
+  if (csSW == "B") {
+    return Bigger;
+  }
+  if (csSW == "S") {
+    return Smaller;
+  }
+  if (csSW == "N") {
+    return Never;
+  }
+  return Always;
+}
+FX_BOOL CPDF_IconFit::IsProportionalScale() {
+  if (!m_pDict) {
+    return TRUE;
+  }
+  return m_pDict->GetStringBy("S", "P") != "A";
+}
+void CPDF_IconFit::GetIconPosition(FX_FLOAT& fLeft, FX_FLOAT& fBottom) {
+  fLeft = fBottom = 0.5;
+  if (!m_pDict) {
+    return;
+  }
+  CPDF_Array* pA = m_pDict->GetArrayBy("A");
+  if (pA) {
+    FX_DWORD dwCount = pA->GetCount();
+    if (dwCount > 0) {
+      fLeft = pA->GetNumberAt(0);
+    }
+    if (dwCount > 1) {
+      fBottom = pA->GetNumberAt(1);
+    }
+  }
+}
+FX_BOOL CPDF_IconFit::GetFittingBounds() {
+  if (!m_pDict) {
+    return FALSE;
+  }
+  return m_pDict->GetBooleanBy("FB");
+}
+
+std::vector<bool> SaveCheckedFieldStatus(CPDF_FormField* pField) {
+  std::vector<bool> result;
+  int iCount = pField->CountControls();
+  for (int i = 0; i < iCount; ++i) {
+    if (CPDF_FormControl* pControl = pField->GetControl(i))
+      result.push_back(pControl->IsChecked());
+  }
+  return result;
+}
+
+CPDF_Object* FPDF_GetFieldAttr(CPDF_Dictionary* pFieldDict,
+                               const FX_CHAR* name,
+                               int nLevel) {
+  if (nLevel > FPDFDOC_UTILS_MAXRECURSION) {
+    return NULL;
+  }
+  if (!pFieldDict) {
+    return NULL;
+  }
+  CPDF_Object* pAttr = pFieldDict->GetElementValue(name);
+  if (pAttr) {
+    return pAttr;
+  }
+  CPDF_Dictionary* pParent = pFieldDict->GetDictBy("Parent");
+  if (!pParent) {
+    return NULL;
+  }
+  return FPDF_GetFieldAttr(pParent, name, nLevel + 1);
+}