Remove FX_DWORD from core/ and delete definition

core/fpdfdoc/doc_utils.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 <algorithm>
 #include <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
 #include "core/fpdfdoc/doc_utils.h"
 #include "core/include/fpdfdoc/fpdf_doc.h"
 #include "core/include/fxge/fx_font.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++) {
+    uint32_t dwCount = pNumbers->GetCount() / 2;
+    for (uint32_t 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++) {
+  for (uint32_t 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;
@@ skipping 210 matching lines @@
     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);
+    uint32_t 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) {
@@ skipping 16 matching lines @@
     }
   }
   if (!csDA.IsEmpty()) {
     csDA += " ";
   }
   csDA += "0 g";
   if (!pFormDict->KeyExist("DA")) {
     pFormDict->SetAtString("DA", csDA);
   }
 }
-FX_DWORD CountInterFormFonts(CPDF_Dictionary* pFormDict) {
+uint32_t 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;
+  uint32_t 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,
+                            uint32_t 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;
+  uint32_t 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")
@@ skipping 335 matching lines @@
   }
   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();
+    uint32_t 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) {
@@ skipping 24 matching lines @@
   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);
 }