Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_parser/cpdf_parser.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_parser/include/cpdf_parser.h"
 
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "third_party/base/stl_util.h"
 
 namespace {
 
 // A limit on the size of the xref table. Theoretical limits are higher, but
 // this may be large enough in practice.
 const int32_t kMaxXRefSize = 1048576;
 
 // A limit on the maximum object number in the xref table. Theoretical limits
 // are higher, but this may be large enough in practice.
-const FX_DWORD kMaxObjectNumber = 1048576;
+const uint32_t kMaxObjectNumber = 1048576;
 
-FX_DWORD GetVarInt(const uint8_t* p, int32_t n) {
-  FX_DWORD result = 0;
+uint32_t GetVarInt(const uint8_t* p, int32_t n) {
+  uint32_t result = 0;
   for (int32_t i = 0; i < n; ++i)
     result = result * 256 + p[i];
   return result;
 }
 
 int32_t GetStreamNCount(CPDF_StreamAcc* pObjStream) {
   return pObjStream->GetDict()->GetIntegerBy("N");
 }
 
 int32_t GetStreamFirst(CPDF_StreamAcc* pObjStream) {
@@ skipping 12 matching lines @@
       m_pLinearized(nullptr),
       m_dwFirstPageNo(0),
       m_dwXrefStartObjNum(0) {
   m_pSyntax.reset(new CPDF_SyntaxParser);
 }
 
 CPDF_Parser::~CPDF_Parser() {
   CloseParser();
 }
 
-FX_DWORD CPDF_Parser::GetLastObjNum() const {
+uint32_t CPDF_Parser::GetLastObjNum() const {
   return m_ObjectInfo.empty() ? 0 : m_ObjectInfo.rbegin()->first;
 }
 
-bool CPDF_Parser::IsValidObjectNumber(FX_DWORD objnum) const {
+bool CPDF_Parser::IsValidObjectNumber(uint32_t objnum) const {
   return !m_ObjectInfo.empty() && objnum <= m_ObjectInfo.rbegin()->first;
 }
 
-FX_FILESIZE CPDF_Parser::GetObjectPositionOrZero(FX_DWORD objnum) const {
+FX_FILESIZE CPDF_Parser::GetObjectPositionOrZero(uint32_t objnum) const {
   auto it = m_ObjectInfo.find(objnum);
   return it != m_ObjectInfo.end() ? it->second.pos : 0;
 }
 
-uint8_t CPDF_Parser::GetObjectType(FX_DWORD objnum) const {
+uint8_t CPDF_Parser::GetObjectType(uint32_t objnum) const {
   ASSERT(IsValidObjectNumber(objnum));
   auto it = m_ObjectInfo.find(objnum);
   return it != m_ObjectInfo.end() ? it->second.type : 0;
 }
 
-uint16_t CPDF_Parser::GetObjectGenNum(FX_DWORD objnum) const {
+uint16_t CPDF_Parser::GetObjectGenNum(uint32_t objnum) const {
   ASSERT(IsValidObjectNumber(objnum));
   auto it = m_ObjectInfo.find(objnum);
   return it != m_ObjectInfo.end() ? it->second.gennum : 0;
 }
 
-bool CPDF_Parser::IsObjectFreeOrNull(FX_DWORD objnum) const {
+bool CPDF_Parser::IsObjectFreeOrNull(uint32_t objnum) const {
   uint8_t type = GetObjectType(objnum);
   return type == 0 || type == 255;
 }
 
 void CPDF_Parser::SetEncryptDictionary(CPDF_Dictionary* pDict) {
   m_pEncryptDict = pDict;
 }
 
 IPDF_CryptoHandler* CPDF_Parser::GetCryptoHandler() {
   return m_pSyntax->m_pCryptoHandler.get();
 }
 
 IFX_FileRead* CPDF_Parser::GetFileAccess() const {
   return m_pSyntax->m_pFileAccess;
 }
 
-void CPDF_Parser::ShrinkObjectMap(FX_DWORD objnum) {
+void CPDF_Parser::ShrinkObjectMap(uint32_t objnum) {
   if (objnum == 0) {
     m_ObjectInfo.clear();
     return;
   }
 
   auto it = m_ObjectInfo.lower_bound(objnum);
   while (it != m_ObjectInfo.end()) {
     auto saved_it = it++;
     m_ObjectInfo.erase(saved_it);
   }
@@ skipping 172 matching lines @@
     m_pSyntax->SetEncrypt(std::move(pCryptoHandler));
   }
   return SUCCESS;
 }
 
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_pSyntax->m_pCryptoHandler.reset();
   m_pSecurityHandler.reset();
 }
 
-FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) const {
+FX_FILESIZE CPDF_Parser::GetObjectOffset(uint32_t objnum) const {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
   if (GetObjectType(objnum) == 1)
     return GetObjectPositionOrZero(objnum);
 
   if (GetObjectType(objnum) == 2) {
     FX_FILESIZE pos = GetObjectPositionOrZero(objnum);
     return GetObjectPositionOrZero(pos);
   }
@@ skipping 48 matching lines @@
   }
 
   for (size_t i = 0; i < CrossRefList.size(); ++i) {
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
       return FALSE;
   }
   return TRUE;
 }
 
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos,
-                                                 FX_DWORD dwObjCount) {
+                                                 uint32_t dwObjCount) {
   if (!LoadLinearizedCrossRefV4(xrefpos, dwObjCount))
     return FALSE;
 
   m_pTrailer = LoadTrailerV4();
   if (!m_pTrailer)
     return FALSE;
 
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
   if (xrefsize == 0)
     return FALSE;
@@ skipping 32 matching lines @@
   }
 
   for (size_t i = 1; i < CrossRefList.size(); ++i) {
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE))
       return FALSE;
   }
   return TRUE;
 }
 
 FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos,
-                                              FX_DWORD dwObjCount) {
+                                              uint32_t dwObjCount) {
   FX_FILESIZE dwStartPos = pos - m_pSyntax->m_HeaderOffset;
 
   m_pSyntax->RestorePos(dwStartPos);
   m_SortedOffset.insert(pos);
 
-  FX_DWORD start_objnum = 0;
-  FX_DWORD count = dwObjCount;
+  uint32_t start_objnum = 0;
+  uint32_t count = dwObjCount;
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
 
   const int32_t recordsize = 20;
   std::vector<char> buf(1024 * recordsize + 1);
   buf[1024 * recordsize] = '\0';
 
   int32_t nBlocks = count / 1024 + 1;
   for (int32_t block = 0; block < nBlocks; block++) {
     int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
-    FX_DWORD dwReadSize = block_size * recordsize;
+    uint32_t dwReadSize = block_size * recordsize;
     if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_pSyntax->m_FileLen)
       return FALSE;
 
     if (!m_pSyntax->ReadBlock(reinterpret_cast<uint8_t*>(buf.data()),
                               dwReadSize)) {
       return FALSE;
     }
 
     for (int32_t i = 0; i < block_size; i++) {
-      FX_DWORD objnum = start_objnum + block * 1024 + i;
+      uint32_t objnum = start_objnum + block * 1024 + i;
       char* pEntry = &buf[i * recordsize];
       if (pEntry[17] == 'f') {
         m_ObjectInfo[objnum].pos = 0;
         m_ObjectInfo[objnum].type = 0;
       } else {
         int32_t offset = FXSYS_atoi(pEntry);
         if (offset == 0) {
           for (int32_t c = 0; c < 10; c++) {
             if (!std::isdigit(pEntry[c]))
               return FALSE;
@@ skipping 33 matching lines @@
     bool bIsNumber;
     CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
     if (word.IsEmpty())
       return false;
 
     if (!bIsNumber) {
       m_pSyntax->RestorePos(SavedPos);
       break;
     }
 
-    FX_DWORD start_objnum = FXSYS_atoui(word);
+    uint32_t start_objnum = FXSYS_atoui(word);
     if (start_objnum >= kMaxObjectNumber)
       return false;
 
-    FX_DWORD count = m_pSyntax->GetDirectNum();
+    uint32_t count = m_pSyntax->GetDirectNum();
     m_pSyntax->ToNextWord();
     SavedPos = m_pSyntax->SavePos();
     const int32_t recordsize = 20;
 
     m_dwXrefStartObjNum = start_objnum;
     if (!bSkip) {
       std::vector<char> buf(1024 * recordsize + 1);
       buf[1024 * recordsize] = '\0';
 
       int32_t nBlocks = count / 1024 + 1;
       for (int32_t block = 0; block < nBlocks; block++) {
         int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
         m_pSyntax->ReadBlock(reinterpret_cast<uint8_t*>(buf.data()),
                              block_size * recordsize);
 
         for (int32_t i = 0; i < block_size; i++) {
-          FX_DWORD objnum = start_objnum + block * 1024 + i;
+          uint32_t objnum = start_objnum + block * 1024 + i;
           char* pEntry = &buf[i * recordsize];
           if (pEntry[17] == 'f') {
             m_ObjectInfo[objnum].pos = 0;
             m_ObjectInfo[objnum].type = 0;
           } else {
             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
             if (offset == 0) {
               for (int32_t c = 0; c < 10; c++) {
                 if (!std::isdigit(pEntry[c]))
                   return false;
@@ skipping 42 matching lines @@
   m_ObjectInfo.clear();
   m_SortedOffset.clear();
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = nullptr;
   }
 
   ParserState state = ParserState::kDefault;
 
   int32_t inside_index = 0;
-  FX_DWORD objnum = 0;
-  FX_DWORD gennum = 0;
+  uint32_t objnum = 0;
+  uint32_t gennum = 0;
   int32_t depth = 0;
 
-  const FX_DWORD kBufferSize = 4096;
+  const uint32_t kBufferSize = 4096;
   std::vector<uint8_t> buffer(kBufferSize);
 
   FX_FILESIZE pos = m_pSyntax->m_HeaderOffset;
   FX_FILESIZE start_pos = 0;
   FX_FILESIZE start_pos1 = 0;
   FX_FILESIZE last_obj = -1;
   FX_FILESIZE last_xref = -1;
   FX_FILESIZE last_trailer = -1;
 
   while (pos < m_pSyntax->m_FileLen) {
     const FX_FILESIZE saved_pos = pos;
     bool bOverFlow = false;
-    FX_DWORD size =
-        std::min((FX_DWORD)(m_pSyntax->m_FileLen - pos), kBufferSize);
+    uint32_t size =
+        std::min((uint32_t)(m_pSyntax->m_FileLen - pos), kBufferSize);
     if (!m_pSyntax->m_pFileAccess->ReadBlock(buffer.data(), pos, size))
       break;
 
-    for (FX_DWORD i = 0; i < size; i++) {
+    for (uint32_t i = 0; i < size; i++) {
       uint8_t byte = buffer[i];
       switch (state) {
         case ParserState::kDefault:
           if (PDFCharIsWhitespace(byte)) {
             state = ParserState::kWhitespace;
           } else if (std::isdigit(byte)) {
             --i;
             state = ParserState::kWhitespace;
           } else if (byte == '%') {
             inside_index = 0;
@@ skipping 131 matching lines @@
 
                 FX_FILESIZE offset = 0;
                 m_pSyntax->RestorePos(obj_pos);
                 offset = m_pSyntax->FindTag("obj", 0);
                 if (offset == -1)
                   offset = 0;
                 else
                   offset += 3;
 
                 FX_FILESIZE nLen = obj_end - obj_pos - offset;
-                if ((FX_DWORD)nLen > size - i) {
+                if ((uint32_t)nLen > size - i) {
                   pos = obj_end + m_pSyntax->m_HeaderOffset;
                   bOverFlow = true;
                 } else {
-                  i += (FX_DWORD)nLen;
+                  i += (uint32_t)nLen;
                 }
 
                 if (!m_ObjectInfo.empty() && IsValidObjectNumber(objnum) &&
                     m_ObjectInfo[objnum].pos) {
                   if (pObject) {
-                    FX_DWORD oldgen = GetObjectGenNum(objnum);
+                    uint32_t oldgen = GetObjectGenNum(objnum);
                     m_ObjectInfo[objnum].pos = obj_pos;
                     m_ObjectInfo[objnum].gennum = gennum;
                     if (oldgen != gennum)
                       m_bVersionUpdated = true;
                   }
                 } else {
                   m_ObjectInfo[objnum].pos = obj_pos;
                   m_ObjectInfo[objnum].type = 1;
                   m_ObjectInfo[objnum].gennum = gennum;
                 }
@@ skipping 25 matching lines @@
                       CPDF_Object* pRoot = pTrailer->GetElement("Root");
                       CPDF_Reference* pRef = ToReference(pRoot);
                       if (!pRoot ||
                           (pRef && IsValidObjectNumber(pRef->GetRefObjNum()) &&
                            m_ObjectInfo[pRef->GetRefObjNum()].pos != 0)) {
                         auto it = pTrailer->begin();
                         while (it != pTrailer->end()) {
                           const CFX_ByteString& key = it->first;
                           CPDF_Object* pElement = it->second;
                           ++it;
-                          FX_DWORD dwObjNum =
+                          uint32_t dwObjNum =
                               pElement ? pElement->GetObjNum() : 0;
                           if (dwObjNum) {
                             m_pTrailer->SetAtReference(key, m_pDocument,
                                                        dwObjNum);
                           } else {
                             m_pTrailer->SetAt(key, pElement->Clone());
                           }
                         }
                       }
                       pObj->Release();
@@ skipping 147 matching lines @@
     ShrinkObjectMap(size);
     for (auto& it : m_ObjectInfo)
       it.second.type = 0;
   } else {
     m_Trailers.Add(ToDictionary(pStream->GetDict()->Clone()));
   }
 
   std::vector<std::pair<int32_t, int32_t>> arrIndex;
   CPDF_Array* pArray = pStream->GetDict()->GetArrayBy("Index");
   if (pArray) {
-    FX_DWORD nPairSize = pArray->GetCount() / 2;
-    for (FX_DWORD i = 0; i < nPairSize; i++) {
+    uint32_t nPairSize = pArray->GetCount() / 2;
+    for (uint32_t i = 0; i < nPairSize; i++) {
       CPDF_Object* pStartNumObj = pArray->GetElement(i * 2);
       CPDF_Object* pCountObj = pArray->GetElement(i * 2 + 1);
 
       if (ToNumber(pStartNumObj) && ToNumber(pCountObj)) {
         int nStartNum = pStartNumObj->GetInteger();
         int nCount = pCountObj->GetInteger();
         if (nStartNum >= 0 && nCount > 0)
           arrIndex.push_back(std::make_pair(nStartNum, nCount));
       }
     }
   }
 
   if (arrIndex.size() == 0)
     arrIndex.push_back(std::make_pair(0, size));
 
   pArray = pStream->GetDict()->GetArrayBy("W");
   if (!pArray) {
     pStream->Release();
     return FALSE;
   }
 
-  CFX_ArrayTemplate<FX_DWORD> WidthArray;
+  CFX_ArrayTemplate<uint32_t> WidthArray;
   FX_SAFE_DWORD dwAccWidth = 0;
-  for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
+  for (uint32_t i = 0; i < pArray->GetCount(); i++) {
     WidthArray.Add(pArray->GetIntegerAt(i));
     dwAccWidth += WidthArray[i];
   }
 
   if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3) {
     pStream->Release();
     return FALSE;
   }
 
-  FX_DWORD totalWidth = dwAccWidth.ValueOrDie();
+  uint32_t totalWidth = dwAccWidth.ValueOrDie();
   CPDF_StreamAcc acc;
   acc.LoadAllData(pStream);
 
   const uint8_t* pData = acc.GetData();
-  FX_DWORD dwTotalSize = acc.GetSize();
-  FX_DWORD segindex = 0;
-  for (FX_DWORD i = 0; i < arrIndex.size(); i++) {
+  uint32_t dwTotalSize = acc.GetSize();
+  uint32_t segindex = 0;
+  for (uint32_t i = 0; i < arrIndex.size(); i++) {
     int32_t startnum = arrIndex[i].first;
     if (startnum < 0)
       continue;
 
     m_dwXrefStartObjNum =
-        pdfium::base::checked_cast<FX_DWORD, int32_t>(startnum);
-    FX_DWORD count =
-        pdfium::base::checked_cast<FX_DWORD, int32_t>(arrIndex[i].second);
+        pdfium::base::checked_cast<uint32_t, int32_t>(startnum);
+    uint32_t count =
+        pdfium::base::checked_cast<uint32_t, int32_t>(arrIndex[i].second);
     FX_SAFE_DWORD dwCaculatedSize = segindex;
     dwCaculatedSize += count;
     dwCaculatedSize *= totalWidth;
     if (!dwCaculatedSize.IsValid() ||
         dwCaculatedSize.ValueOrDie() > dwTotalSize) {
       continue;
     }
 
     const uint8_t* segstart = pData + segindex * totalWidth;
     FX_SAFE_DWORD dwMaxObjNum = startnum;
     dwMaxObjNum += count;
-    FX_DWORD dwV5Size = m_ObjectInfo.empty() ? 0 : GetLastObjNum() + 1;
+    uint32_t dwV5Size = m_ObjectInfo.empty() ? 0 : GetLastObjNum() + 1;
     if (!dwMaxObjNum.IsValid() || dwMaxObjNum.ValueOrDie() > dwV5Size)
       continue;
 
-    for (FX_DWORD j = 0; j < count; j++) {
+    for (uint32_t j = 0; j < count; j++) {
       int32_t type = 1;
       const uint8_t* entrystart = segstart + j * totalWidth;
       if (WidthArray[0])
         type = GetVarInt(entrystart, WidthArray[0]);
 
       if (GetObjectType(startnum + j) == 255) {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_ObjectInfo[startnum + j].pos = offset;
         m_SortedOffset.insert(offset);
@@ skipping 32 matching lines @@
   if (!pID)
     return nullptr;
 
   if (CPDF_Reference* pRef = pID->AsReference()) {
     pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum());
     m_pTrailer->SetAt("ID", pID);
   }
   return ToArray(pID);
 }
 
-FX_DWORD CPDF_Parser::GetRootObjNum() {
+uint32_t CPDF_Parser::GetRootObjNum() {
   CPDF_Reference* pRef =
       ToReference(m_pTrailer ? m_pTrailer->GetElement("Root") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
-FX_DWORD CPDF_Parser::GetInfoObjNum() {
+uint32_t CPDF_Parser::GetInfoObjNum() {
   CPDF_Reference* pRef =
       ToReference(m_pTrailer ? m_pTrailer->GetElement("Info") : nullptr);
   return pRef ? pRef->GetRefObjNum() : 0;
 }
 
-FX_BOOL CPDF_Parser::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) {
+FX_BOOL CPDF_Parser::IsFormStream(uint32_t objnum, FX_BOOL& bForm) {
   bForm = FALSE;
   if (!IsValidObjectNumber(objnum))
     return TRUE;
 
   if (GetObjectType(objnum) == 0)
     return TRUE;
 
   if (GetObjectType(objnum) == 2)
     return TRUE;
 
@@ skipping 11 matching lines @@
 
   const char kFormStream[] = "/Form\0stream";
   const CFX_ByteStringC kFormStreamStr(kFormStream, sizeof(kFormStream) - 1);
   bForm = m_pSyntax->SearchMultiWord(kFormStreamStr, TRUE, size) == 0;
   m_pSyntax->RestorePos(SavedPos);
   return TRUE;
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObject(
     CPDF_IndirectObjectHolder* pObjList,
-    FX_DWORD objnum) {
+    uint32_t objnum) {
   if (!IsValidObjectNumber(objnum))
     return nullptr;
 
   // Prevent circular parsing the same object.
   if (pdfium::ContainsKey(m_ParsingObjNums, objnum))
     return nullptr;
 
-  pdfium::ScopedSetInsertion<FX_DWORD> local_insert(&m_ParsingObjNums, objnum);
+  pdfium::ScopedSetInsertion<uint32_t> local_insert(&m_ParsingObjNums, objnum);
   if (GetObjectType(objnum) == 1 || GetObjectType(objnum) == 255) {
     FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
     if (pos <= 0)
       return nullptr;
     return ParseIndirectObjectAt(pObjList, pos, objnum);
   }
   if (GetObjectType(objnum) != 2)
     return nullptr;
 
   CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
   if (!pObjStream)
     return nullptr;
 
   ScopedFileStream file(FX_CreateMemoryStream(
       (uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
   CPDF_SyntaxParser syntax;
   syntax.InitParser(file.get(), 0);
   const int32_t offset = GetStreamFirst(pObjStream);
 
   // Read object numbers from |pObjStream| into a cache.
   if (!pdfium::ContainsKey(m_ObjCache, pObjStream)) {
     for (int32_t i = GetStreamNCount(pObjStream); i > 0; --i) {
-      FX_DWORD thisnum = syntax.GetDirectNum();
-      FX_DWORD thisoff = syntax.GetDirectNum();
+      uint32_t thisnum = syntax.GetDirectNum();
+      uint32_t thisoff = syntax.GetDirectNum();
       m_ObjCache[pObjStream][thisnum] = thisoff;
     }
   }
 
   const auto it = m_ObjCache[pObjStream].find(objnum);
   if (it == m_ObjCache[pObjStream].end())
     return nullptr;
 
   syntax.RestorePos(offset + it->second);
   return syntax.GetObject(pObjList, 0, 0, true);
 }
 
-CPDF_StreamAcc* CPDF_Parser::GetObjectStream(FX_DWORD objnum) {
+CPDF_StreamAcc* CPDF_Parser::GetObjectStream(uint32_t objnum) {
   auto it = m_ObjectStreamMap.find(objnum);
   if (it != m_ObjectStreamMap.end())
     return it->second.get();
 
   if (!m_pDocument)
     return nullptr;
 
   const CPDF_Stream* pStream = ToStream(m_pDocument->GetIndirectObject(objnum));
   if (!pStream)
     return nullptr;
 
   CPDF_StreamAcc* pStreamAcc = new CPDF_StreamAcc;
   pStreamAcc->LoadAllData(pStream);
   m_ObjectStreamMap[objnum].reset(pStreamAcc);
   return pStreamAcc;
 }
 
-FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) const {
+FX_FILESIZE CPDF_Parser::GetObjectSize(uint32_t objnum) const {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
   if (GetObjectType(objnum) == 2)
     objnum = GetObjectPositionOrZero(objnum);
 
   if (GetObjectType(objnum) != 1 && GetObjectType(objnum) != 255)
     return 0;
 
   FX_FILESIZE offset = GetObjectPositionOrZero(objnum);
   if (offset == 0)
     return 0;
 
   auto it = m_SortedOffset.find(offset);
   if (it == m_SortedOffset.end() || ++it == m_SortedOffset.end())
     return 0;
 
   return *it - offset;
 }
 
-void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum,
+void CPDF_Parser::GetIndirectBinary(uint32_t objnum,
                                     uint8_t*& pBuffer,
-                                    FX_DWORD& size) {
+                                    uint32_t& size) {
   pBuffer = nullptr;
   size = 0;
   if (!IsValidObjectNumber(objnum))
     return;
 
   if (GetObjectType(objnum) == 2) {
     CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
     if (!pObjStream)
       return;
 
     int32_t offset = GetStreamFirst(pObjStream);
     const uint8_t* pData = pObjStream->GetData();
-    FX_DWORD totalsize = pObjStream->GetSize();
+    uint32_t totalsize = pObjStream->GetSize();
     ScopedFileStream file(
         FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
 
     CPDF_SyntaxParser syntax;
     syntax.InitParser(file.get(), 0);
     for (int i = GetStreamNCount(pObjStream); i > 0; --i) {
-      FX_DWORD thisnum = syntax.GetDirectNum();
-      FX_DWORD thisoff = syntax.GetDirectNum();
+      uint32_t thisnum = syntax.GetDirectNum();
+      uint32_t thisoff = syntax.GetDirectNum();
       if (thisnum != objnum)
         continue;
 
       if (i == 1) {
         size = totalsize - (thisoff + offset);
       } else {
         syntax.GetDirectNum();  // Skip nextnum.
-        FX_DWORD nextoff = syntax.GetDirectNum();
+        uint32_t nextoff = syntax.GetDirectNum();
         size = nextoff - thisoff;
       }
 
       pBuffer = FX_Alloc(uint8_t, size);
       FXSYS_memcpy(pBuffer, pData + thisoff + offset, size);
       return;
     }
     return;
   }
 
   if (GetObjectType(objnum) != 1)
     return;
 
   FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
   if (pos == 0)
     return;
 
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   m_pSyntax->RestorePos(pos);
 
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return;
   }
 
-  FX_DWORD parser_objnum = FXSYS_atoui(word);
+  uint32_t parser_objnum = FXSYS_atoui(word);
   if (parser_objnum && parser_objnum != objnum) {
     m_pSyntax->RestorePos(SavedPos);
     return;
   }
 
   word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return;
   }
@@ skipping 29 matching lines @@
     while (1) {
       if (m_pSyntax->GetKeyword() == "endobj")
         break;
 
       if (m_pSyntax->SavePos() == m_pSyntax->m_FileLen)
         break;
     }
     nextoff = m_pSyntax->SavePos();
   }
 
-  size = (FX_DWORD)(nextoff - pos);
+  size = (uint32_t)(nextoff - pos);
   pBuffer = FX_Alloc(uint8_t, size);
   m_pSyntax->RestorePos(pos);
   m_pSyntax->ReadBlock(pBuffer, size);
   m_pSyntax->RestorePos(SavedPos);
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
-    FX_DWORD objnum) {
+    uint32_t objnum) {
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   m_pSyntax->RestorePos(pos);
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   FX_FILESIZE objOffset = m_pSyntax->SavePos();
   objOffset -= word.GetLength();
-  FX_DWORD parser_objnum = FXSYS_atoui(word);
+  uint32_t parser_objnum = FXSYS_atoui(word);
   if (objnum && parser_objnum != objnum) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  FX_DWORD parser_gennum = FXSYS_atoui(word);
+  uint32_t parser_gennum = FXSYS_atoui(word);
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   CPDF_Object* pObj =
       m_pSyntax->GetObject(pObjList, objnum, parser_gennum, true);
   m_pSyntax->SavePos();
 
   CFX_ByteString bsWord = m_pSyntax->GetKeyword();
   if (bsWord == "endobj")
     m_pSyntax->SavePos();
 
   m_pSyntax->RestorePos(SavedPos);
   if (pObj) {
     if (!objnum)
       pObj->m_ObjNum = parser_objnum;
     pObj->m_GenNum = parser_gennum;
   }
   return pObj;
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(
     CPDF_IndirectObjectHolder* pObjList,
     FX_FILESIZE pos,
-    FX_DWORD objnum,
+    uint32_t objnum,
     FX_FILESIZE* pResultPos) {
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   m_pSyntax->RestorePos(pos);
 
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  FX_DWORD parser_objnum = FXSYS_atoui(word);
+  uint32_t parser_objnum = FXSYS_atoui(word);
   if (objnum && parser_objnum != objnum) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
-  FX_DWORD gennum = FXSYS_atoui(word);
+  uint32_t gennum = FXSYS_atoui(word);
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return nullptr;
   }
 
   CPDF_Object* pObj = m_pSyntax->GetObjectByStrict(pObjList, objnum, gennum);
   if (pResultPos)
     *pResultPos = m_pSyntax->m_Pos;
 
   m_pSyntax->RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_pSyntax->GetKeyword() != "trailer")
     return nullptr;
 
   std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
       m_pSyntax->GetObject(m_pDocument, 0, 0, true));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
-FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
+uint32_t CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
   if (!m_pSecurityHandler)
-    return (FX_DWORD)-1;
+    return (uint32_t)-1;
 
-  FX_DWORD dwPermission = m_pSecurityHandler->GetPermissions();
+  uint32_t dwPermission = m_pSecurityHandler->GetPermissions();
   if (m_pEncryptDict && m_pEncryptDict->GetStringBy("Filter") == "Standard") {
     dwPermission &= 0xFFFFFFFC;
     dwPermission |= 0xFFFFF0C0;
     if (bCheckRevision && m_pEncryptDict->GetIntegerBy("R") == 2)
       dwPermission &= 0xFFFFF0FF;
   }
   return dwPermission;
 }
 
 FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess,
-                                      FX_DWORD offset) {
+                                      uint32_t offset) {
   m_pSyntax->InitParser(pFileAccess, offset);
   m_pSyntax->RestorePos(m_pSyntax->m_HeaderOffset + 9);
 
   FX_FILESIZE SavedPos = m_pSyntax->SavePos();
   bool bIsNumber;
   CFX_ByteString word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber)
     return FALSE;
 
-  FX_DWORD objnum = FXSYS_atoui(word);
+  uint32_t objnum = FXSYS_atoui(word);
   word = m_pSyntax->GetNextWord(&bIsNumber);
   if (!bIsNumber)
     return FALSE;
 
-  FX_DWORD gennum = FXSYS_atoui(word);
+  uint32_t gennum = FXSYS_atoui(word);
   if (m_pSyntax->GetKeyword() != "obj") {
     m_pSyntax->RestorePos(SavedPos);
     return FALSE;
   }
 
   m_pLinearized = m_pSyntax->GetObject(nullptr, objnum, gennum, true);
   if (!m_pLinearized)
     return FALSE;
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
@@ skipping 114 matching lines @@
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos))
       return FALSE;
   }
   m_ObjectStreamMap.clear();
   m_bXRefStream = TRUE;
   return TRUE;
 }
 
 CPDF_Parser::Error CPDF_Parser::LoadLinearizedMainXRefTable() {
-  FX_DWORD dwSaveMetadataObjnum = m_pSyntax->m_MetadataObjnum;
+  uint32_t dwSaveMetadataObjnum = m_pSyntax->m_MetadataObjnum;
   m_pSyntax->m_MetadataObjnum = 0;
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = nullptr;
   }
 
   m_pSyntax->RestorePos(m_LastXRefOffset - m_pSyntax->m_HeaderOffset);
   uint8_t ch = 0;
-  FX_DWORD dwCount = 0;
+  uint32_t dwCount = 0;
   m_pSyntax->GetNextChar(ch);
   while (PDFCharIsWhitespace(ch)) {
     ++dwCount;
     if (m_pSyntax->m_FileLen >=
         (FX_FILESIZE)(m_pSyntax->SavePos() + m_pSyntax->m_HeaderOffset)) {
       break;
     }
     m_pSyntax->GetNextChar(ch);
   }
   m_LastXRefOffset += dwCount;
   m_ObjectStreamMap.clear();
   m_ObjCache.clear();
 
   if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) &&
       !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
     m_LastXRefOffset = 0;
     m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
     return FORMAT_ERROR;
   }
 
   m_pSyntax->m_MetadataObjnum = dwSaveMetadataObjnum;
   return SUCCESS;
 }