Remove FX_DWORD from fpdfsdk/ and testing/

fpdfsdk/fpdfppo.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 "public/fpdf_ppo.h"
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #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_name.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_reference.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_string.h"
 #include "fpdfsdk/include/fsdk_define.h"
 #include "third_party/base/stl_util.h"
 
 class CPDF_PageOrganizer {
  public:
-  using ObjectNumberMap = std::map<FX_DWORD, FX_DWORD>;
+  using ObjectNumberMap = std::map<uint32_t, uint32_t>;
   CPDF_PageOrganizer();
   ~CPDF_PageOrganizer();
 
   FX_BOOL PDFDocInit(CPDF_Document* pDestPDFDoc, CPDF_Document* pSrcPDFDoc);
   FX_BOOL ExportPage(CPDF_Document* pSrcPDFDoc,
                      std::vector<uint16_t>* pPageNums,
                      CPDF_Document* pDestPDFDoc,
                      int nIndex);
   CPDF_Object* PageDictGetInheritableTag(CPDF_Dictionary* pDict,
                                          CFX_ByteString nSrctag);
   FX_BOOL UpdateReference(CPDF_Object* pObj,
                           CPDF_Document* pDoc,
                           ObjectNumberMap* pObjNumberMap);
-  FX_DWORD GetNewObjId(CPDF_Document* pDoc,
+  uint32_t GetNewObjId(CPDF_Document* pDoc,
                        ObjectNumberMap* pObjNumberMap,
                        CPDF_Reference* pRef);
 };
 
 CPDF_PageOrganizer::CPDF_PageOrganizer() {}
 
 CPDF_PageOrganizer::~CPDF_PageOrganizer() {}
 
 FX_BOOL CPDF_PageOrganizer::PDFDocInit(CPDF_Document* pDestPDFDoc,
                                        CPDF_Document* pSrcPDFDoc) {
@@ skipping 17 matching lines @@
   CFX_ByteString cbRootType = pNewRoot->GetStringBy("Type", "");
   if (cbRootType.Equal("")) {
     pNewRoot->SetAt("Type", new CPDF_Name("Catalog"));
   }
 
   CPDF_Object* pElement = pNewRoot->GetElement("Pages");
   CPDF_Dictionary* pNewPages =
       pElement ? ToDictionary(pElement->GetDirect()) : nullptr;
   if (!pNewPages) {
     pNewPages = new CPDF_Dictionary;
-    FX_DWORD NewPagesON = pDestPDFDoc->AddIndirectObject(pNewPages);
+    uint32_t NewPagesON = pDestPDFDoc->AddIndirectObject(pNewPages);
     pNewRoot->SetAt("Pages", new CPDF_Reference(pDestPDFDoc, NewPagesON));
   }
 
   CFX_ByteString cbPageType = pNewPages->GetStringBy("Type", "");
   if (cbPageType.Equal("")) {
     pNewPages->SetAt("Type", new CPDF_Name("Pages"));
   }
 
   CPDF_Array* pKeysArray = pNewPages->GetArrayBy("Kids");
   if (!pKeysArray) {
     CPDF_Array* pNewKids = new CPDF_Array;
-    FX_DWORD Kidsobjnum = pDestPDFDoc->AddIndirectObject(pNewKids);
+    uint32_t Kidsobjnum = pDestPDFDoc->AddIndirectObject(pNewKids);
 
     pNewPages->SetAt("Kids", new CPDF_Reference(pDestPDFDoc, Kidsobjnum));
     pNewPages->SetAt("Count", new CPDF_Number(0));
   }
 
   return TRUE;
 }
 
 FX_BOOL CPDF_PageOrganizer::ExportPage(CPDF_Document* pSrcPDFDoc,
                                        std::vector<uint16_t>* pPageNums,
@@ skipping 57 matching lines @@
         pCurPageDict->SetAt("CropBox", pInheritable->Clone());
     }
     // 4 Rotate  //Optional
     if (!pCurPageDict->KeyExist("Rotate")) {
       pInheritable = PageDictGetInheritableTag(pSrcPageDict, "Rotate");
       if (pInheritable)
         pCurPageDict->SetAt("Rotate", pInheritable->Clone());
     }
 
     // Update the reference
-    FX_DWORD dwOldPageObj = pSrcPageDict->GetObjNum();
-    FX_DWORD dwNewPageObj = pCurPageDict->GetObjNum();
+    uint32_t dwOldPageObj = pSrcPageDict->GetObjNum();
+    uint32_t dwNewPageObj = pCurPageDict->GetObjNum();
 
     (*pObjNumberMap)[dwOldPageObj] = dwNewPageObj;
 
     UpdateReference(pCurPageDict, pDestPDFDoc, pObjNumberMap.get());
     ++curpage;
   }
 
   return TRUE;
 }
 
@@ skipping 27 matching lines @@
   }
   return nullptr;
 }
 
 FX_BOOL CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
                                             CPDF_Document* pDoc,
                                             ObjectNumberMap* pObjNumberMap) {
   switch (pObj->GetType()) {
     case CPDF_Object::REFERENCE: {
       CPDF_Reference* pReference = pObj->AsReference();
-      FX_DWORD newobjnum = GetNewObjId(pDoc, pObjNumberMap, pReference);
+      uint32_t newobjnum = GetNewObjId(pDoc, pObjNumberMap, pReference);
       if (newobjnum == 0)
         return FALSE;
       pReference->SetRef(pDoc, newobjnum);
       break;
     }
     case CPDF_Object::DICTIONARY: {
       CPDF_Dictionary* pDict = pObj->AsDictionary();
       auto it = pDict->begin();
       while (it != pDict->end()) {
         const CFX_ByteString& key = it->first;
         CPDF_Object* pNextObj = it->second;
         ++it;
         if (!FXSYS_strcmp(key, "Parent") || !FXSYS_strcmp(key, "Prev") ||
             !FXSYS_strcmp(key, "First")) {
           continue;
         }
         if (pNextObj) {
           if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
             pDict->RemoveAt(key);
         } else {
           return FALSE;
         }
       }
       break;
     }
     case CPDF_Object::ARRAY: {
       CPDF_Array* pArray = pObj->AsArray();
-      FX_DWORD count = pArray->GetCount();
-      for (FX_DWORD i = 0; i < count; ++i) {
+      uint32_t count = pArray->GetCount();
+      for (uint32_t i = 0; i < count; ++i) {
         CPDF_Object* pNextObj = pArray->GetElement(i);
         if (!pNextObj)
           return FALSE;
         if (!UpdateReference(pNextObj, pDoc, pObjNumberMap))
           return FALSE;
       }
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_Stream* pStream = pObj->AsStream();
       CPDF_Dictionary* pDict = pStream->GetDict();
       if (pDict) {
         if (!UpdateReference(pDict, pDoc, pObjNumberMap))
           return FALSE;
       } else {
         return FALSE;
       }
       break;
     }
     default:
       break;
   }
 
   return TRUE;
 }
 
-FX_DWORD CPDF_PageOrganizer::GetNewObjId(CPDF_Document* pDoc,
+uint32_t CPDF_PageOrganizer::GetNewObjId(CPDF_Document* pDoc,
                                          ObjectNumberMap* pObjNumberMap,
                                          CPDF_Reference* pRef) {
   if (!pRef)
     return 0;
 
-  FX_DWORD dwObjnum = pRef->GetRefObjNum();
-  FX_DWORD dwNewObjNum = 0;
+  uint32_t dwObjnum = pRef->GetRefObjNum();
+  uint32_t dwNewObjNum = 0;
   const auto it = pObjNumberMap->find(dwObjnum);
   if (it != pObjNumberMap->end())
     dwNewObjNum = it->second;
   if (dwNewObjNum)
     return dwNewObjNum;
 
   CPDF_Object* pDirect = pRef->GetDirect();
   if (!pDirect)
     return 0;
 
@@ skipping 116 matching lines @@
   if (!pSrcDict)
     return FALSE;
 
   CPDF_Dictionary* pDstDict = pDstDoc->GetRoot();
   if (!pDstDict)
     return FALSE;
 
   pDstDict->SetAt("ViewerPreferences", pSrcDict->Clone(TRUE));
   return TRUE;
 }