Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_edit/fpdf_edit_create.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_edit/editint.h"
 
 #include <vector>
 
@@ skipping 77 matching lines @@
         return -1;
       offset += len + 6;
       break;
     }
     case CPDF_Object::ARRAY: {
       if (pFile->AppendString("[") < 0) {
         return -1;
       }
       offset += 1;
       const CPDF_Array* p = pObj->AsArray();
-      for (FX_DWORD i = 0; i < p->GetCount(); i++) {
+      for (uint32_t i = 0; i < p->GetCount(); i++) {
         CPDF_Object* pElement = p->GetElement(i);
         if (pElement->GetObjNum()) {
           if (pFile->AppendString(" ") < 0) {
             return -1;
           }
           if ((len = pFile->AppendDWord(pElement->GetObjNum())) < 0) {
             return -1;
           }
           if (pFile->AppendString(" 0 R") < 0) {
             return -1;
@@ skipping 162 matching lines @@
     }
     offset += 3;
     if (PDF_CreatorAppendObject(pIDArray, pFile, offset) < 0) {
       return -1;
     }
   }
   return offset;
 }
 
 int32_t PDF_CreatorWriteEncrypt(const CPDF_Dictionary* pEncryptDict,
-                                FX_DWORD dwObjNum,
+                                uint32_t dwObjNum,
                                 CFX_FileBufferArchive* pFile) {
   if (!pEncryptDict) {
     return 0;
   }
   FXSYS_assert(pFile);
   FX_FILESIZE offset = 0;
   int32_t len = 0;
   if (pFile->AppendString("/Encrypt") < 0) {
     return -1;
   }
   offset += 8;
   if (pFile->AppendString(" ") < 0) {
     return -1;
   }
   if ((len = pFile->AppendDWord(dwObjNum)) < 0) {
     return -1;
   }
   if (pFile->AppendString(" 0 R ") < 0) {
     return -1;
   }
   offset += len + 6;
   return offset;
 }
 
-std::vector<uint8_t> PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2) {
-  std::vector<uint8_t> buffer(sizeof(FX_DWORD) * 4);
-  FX_DWORD* pBuffer = reinterpret_cast<FX_DWORD*>(buffer.data());
+std::vector<uint8_t> PDF_GenerateFileID(uint32_t dwSeed1, uint32_t dwSeed2) {
+  std::vector<uint8_t> buffer(sizeof(uint32_t) * 4);
+  uint32_t* pBuffer = reinterpret_cast<uint32_t*>(buffer.data());
   void* pContext = FX_Random_MT_Start(dwSeed1);
   for (int i = 0; i < 2; ++i)
     *pBuffer++ = FX_Random_MT_Generate(pContext);
   FX_Random_MT_Close(pContext);
   pContext = FX_Random_MT_Start(dwSeed2);
   for (int i = 0; i < 2; ++i)
     *pBuffer++ = FX_Random_MT_Generate(pContext);
   FX_Random_MT_Close(pContext);
   return buffer;
 }
@@ skipping 12 matching lines @@
 void AppendIndex1(CFX_ByteTextBuf& buffer, FX_FILESIZE offset) {
   buffer.AppendByte(1);
   buffer.AppendByte(FX_GETBYTEOFFSET24(offset));
   buffer.AppendByte(FX_GETBYTEOFFSET16(offset));
   buffer.AppendByte(FX_GETBYTEOFFSET8(offset));
   buffer.AppendByte(FX_GETBYTEOFFSET0(offset));
   buffer.AppendByte(0);
   buffer.AppendByte(0);
 }
 
-void AppendIndex2(CFX_ByteTextBuf& buffer, FX_DWORD objnum, int32_t index) {
+void AppendIndex2(CFX_ByteTextBuf& buffer, uint32_t objnum, int32_t index) {
   buffer.AppendByte(2);
   buffer.AppendByte(FX_GETBYTEOFFSET24(objnum));
   buffer.AppendByte(FX_GETBYTEOFFSET16(objnum));
   buffer.AppendByte(FX_GETBYTEOFFSET8(objnum));
   buffer.AppendByte(FX_GETBYTEOFFSET0(objnum));
   buffer.AppendByte(FX_GETBYTEOFFSET8(index));
   buffer.AppendByte(FX_GETBYTEOFFSET0(index));
 }
 
-bool IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag) {
+bool IsXRefNeedEnd(CPDF_XRefStream* pXRef, uint32_t flag) {
   if (!(flag & FPDFCREATE_INCREMENTAL))
     return false;
 
-  FX_DWORD iCount = 0;
+  uint32_t iCount = 0;
   for (const auto& pair : pXRef->m_IndexArray)
     iCount += pair.count;
 
   return iCount >= PDF_XREFSTREAM_MAXSIZE;
 }
 
 int32_t OutputIndex(CFX_FileBufferArchive* pFile, FX_FILESIZE offset) {
   if (sizeof(offset) > 4) {
     if (FX_GETBYTEOFFSET32(offset)) {
       if (pFile->AppendByte(FX_GETBYTEOFFSET56(offset)) < 0)
@@ skipping 18 matching lines @@
     return -1;
   return 0;
 }
 
 class CPDF_FlateEncoder {
  public:
   CPDF_FlateEncoder();
   ~CPDF_FlateEncoder();
   FX_BOOL Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
   FX_BOOL Initialize(const uint8_t* pBuffer,
-                     FX_DWORD size,
+                     uint32_t size,
                      FX_BOOL bFlateEncode,
                      FX_BOOL bXRefStream = FALSE);
   void CloneDict();
   uint8_t* m_pData;
-  FX_DWORD m_dwSize;
+  uint32_t m_dwSize;
   CPDF_Dictionary* m_pDict;
   FX_BOOL m_bCloned;
   FX_BOOL m_bNewData;
   CPDF_StreamAcc m_Acc;
 };
 CPDF_FlateEncoder::CPDF_FlateEncoder() {
   m_pData = NULL;
   m_dwSize = 0;
   m_pDict = NULL;
   m_bCloned = FALSE;
@@ skipping 33 matching lines @@
   m_bNewData = TRUE;
   m_bCloned = TRUE;
   ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize);
   m_pDict = ToDictionary(pStream->GetDict()->Clone());
   m_pDict->SetAtInteger("Length", m_dwSize);
   m_pDict->SetAtName("Filter", "FlateDecode");
   m_pDict->RemoveAt("DecodeParms");
   return TRUE;
 }
 FX_BOOL CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer,
-                                      FX_DWORD size,
+                                      uint32_t size,
                                       FX_BOOL bFlateEncode,
                                       FX_BOOL bXRefStream) {
   if (!bFlateEncode) {
     m_pData = (uint8_t*)pBuffer;
     m_dwSize = size;
     return TRUE;
   }
   m_bNewData = TRUE;
   if (bXRefStream) {
     ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize);
@@ skipping 10 matching lines @@
     FX_Free(m_pData);
   }
 }
 class CPDF_Encryptor {
  public:
   CPDF_Encryptor();
   ~CPDF_Encryptor();
   FX_BOOL Initialize(IPDF_CryptoHandler* pHandler,
                      int objnum,
                      uint8_t* src_data,
-                     FX_DWORD src_size);
+                     uint32_t src_size);
   uint8_t* m_pData;
-  FX_DWORD m_dwSize;
+  uint32_t m_dwSize;
   FX_BOOL m_bNewBuf;
 };
 CPDF_Encryptor::CPDF_Encryptor() {
   m_pData = NULL;
   m_dwSize = 0;
   m_bNewBuf = FALSE;
 }
 FX_BOOL CPDF_Encryptor::Initialize(IPDF_CryptoHandler* pHandler,
                                    int objnum,
                                    uint8_t* src_data,
-                                   FX_DWORD src_size) {
+                                   uint32_t src_size) {
   if (src_size == 0) {
     return TRUE;
   }
   if (!pHandler) {
     m_pData = (uint8_t*)src_data;
     m_dwSize = src_size;
     m_bNewBuf = FALSE;
     return TRUE;
   }
   m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size);
@@ skipping 12 matching lines @@
 
 CPDF_ObjectStream::CPDF_ObjectStream() : m_dwObjNum(0), m_index(0) {}
 FX_BOOL CPDF_ObjectStream::Start() {
   m_ObjNumArray.RemoveAll();
   m_OffsetArray.RemoveAll();
   m_Buffer.Clear();
   m_dwObjNum = 0;
   m_index = 0;
   return TRUE;
 }
-int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum,
+int32_t CPDF_ObjectStream::CompressIndirectObject(uint32_t dwObjNum,
                                                   const CPDF_Object* pObj) {
   m_ObjNumArray.Add(dwObjNum);
   m_OffsetArray.Add(m_Buffer.GetLength());
   m_Buffer << pObj;
   return 1;
 }
-int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum,
+int32_t CPDF_ObjectStream::CompressIndirectObject(uint32_t dwObjNum,
                                                   const uint8_t* pBuffer,
-                                                  FX_DWORD dwSize) {
+                                                  uint32_t dwSize) {
   m_ObjNumArray.Add(dwObjNum);
   m_OffsetArray.Add(m_Buffer.GetLength());
   m_Buffer.AppendBlock(pBuffer, dwSize);
   return 1;
 }
 FX_FILESIZE CPDF_ObjectStream::End(CPDF_Creator* pCreator) {
   FXSYS_assert(pCreator);
   if (m_ObjNumArray.GetSize() == 0) {
     return 0;
   }
@@ skipping 12 matching lines @@
   FX_FILESIZE& offset = pCreator->m_Offset;
   int32_t len = pFile->AppendDWord(m_dwObjNum);
   if (len < 0) {
     return -1;
   }
   offset += len;
   if ((len = pFile->AppendString(" 0 obj\r\n<</Type /ObjStm /N ")) < 0) {
     return -1;
   }
   offset += len;
-  if ((len = pFile->AppendDWord((FX_DWORD)iCount)) < 0) {
+  if ((len = pFile->AppendDWord((uint32_t)iCount)) < 0) {
     return -1;
   }
   offset += len;
   if (pFile->AppendString("/First ") < 0) {
     return -1;
   }
-  if ((len = pFile->AppendDWord((FX_DWORD)tempBuffer.GetLength())) < 0) {
+  if ((len = pFile->AppendDWord((uint32_t)tempBuffer.GetLength())) < 0) {
     return -1;
   }
   if (pFile->AppendString("/Length ") < 0) {
     return -1;
   }
   offset += len + 15;
   if (!pCreator->m_bCompress && !pHandler) {
     if ((len = pFile->AppendDWord(
-             (FX_DWORD)(tempBuffer.GetLength() + m_Buffer.GetLength()))) < 0) {
+             (uint32_t)(tempBuffer.GetLength() + m_Buffer.GetLength()))) < 0) {
       return -1;
     }
     offset += len;
     if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
       return -1;
     }
     if (pFile->AppendBlock(tempBuffer.GetBuffer(), tempBuffer.GetLength()) <
         0) {
       return -1;
     }
@@ skipping 34 matching lines @@
   return ObjOffset;
 }
 CPDF_XRefStream::CPDF_XRefStream()
     : m_PrevOffset(0), m_dwTempObjNum(0), m_iSeg(0) {}
 FX_BOOL CPDF_XRefStream::Start() {
   m_IndexArray.clear();
   m_Buffer.Clear();
   m_iSeg = 0;
   return TRUE;
 }
-int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum,
+int32_t CPDF_XRefStream::CompressIndirectObject(uint32_t dwObjNum,
                                                 const CPDF_Object* pObj,
                                                 CPDF_Creator* pCreator) {
   if (!pCreator) {
     return 0;
   }
   m_ObjStream.CompressIndirectObject(dwObjNum, pObj);
   if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize &&
       m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) {
     return 1;
   }
   return EndObjectStream(pCreator);
 }
-int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum,
+int32_t CPDF_XRefStream::CompressIndirectObject(uint32_t dwObjNum,
                                                 const uint8_t* pBuffer,
-                                                FX_DWORD dwSize,
+                                                uint32_t dwSize,
                                                 CPDF_Creator* pCreator) {
   if (!pCreator) {
     return 0;
   }
   m_ObjStream.CompressIndirectObject(dwObjNum, pBuffer, dwSize);
   if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize &&
       m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) {
     return 1;
   }
   return EndObjectStream(pCreator);
 }
 
 int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator* pCreator, FX_BOOL bEOF) {
   FX_FILESIZE objOffset = 0;
   if (bEOF) {
     objOffset = m_ObjStream.End(pCreator);
     if (objOffset < 0) {
       return -1;
     }
   }
-  FX_DWORD& dwObjStmNum = m_ObjStream.m_dwObjNum;
+  uint32_t& dwObjStmNum = m_ObjStream.m_dwObjNum;
   if (!dwObjStmNum) {
     dwObjStmNum = ++pCreator->m_dwLastObjNum;
   }
   int32_t iSize = m_ObjStream.m_ObjNumArray.GetSize();
   size_t iSeg = m_IndexArray.size();
   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
     if (m_dwTempObjNum == 0) {
       AppendIndex0(m_Buffer, true);
       m_dwTempObjNum++;
     }
-    FX_DWORD end_num = m_IndexArray.back().objnum + m_IndexArray.back().count;
+    uint32_t end_num = m_IndexArray.back().objnum + m_IndexArray.back().count;
     int index = 0;
     for (; m_dwTempObjNum < end_num; m_dwTempObjNum++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjNum);
       if (offset) {
         if (index >= iSize ||
             m_dwTempObjNum != m_ObjStream.m_ObjNumArray[index]) {
           AppendIndex1(m_Buffer, *offset);
         } else {
           AppendIndex2(m_Buffer, dwObjStmNum, index++);
         }
       } else {
         AppendIndex0(m_Buffer, false);
       }
     }
     if (iSize > 0 && bEOF) {
       pCreator->m_ObjectOffset.Add(dwObjStmNum, 1);
       pCreator->m_ObjectOffset[dwObjStmNum] = objOffset;
     }
     m_iSeg = iSeg;
     if (bEOF) {
       m_ObjStream.Start();
     }
     return 1;
   }
   for (auto it = m_IndexArray.begin() + m_iSeg; it != m_IndexArray.end();
        ++it) {
-    for (FX_DWORD m = it->objnum; m < it->objnum + it->count; ++m) {
+    for (uint32_t m = it->objnum; m < it->objnum + it->count; ++m) {
       if (m_ObjStream.m_index >= iSize ||
           m != m_ObjStream.m_ObjNumArray.ElementAt(it - m_IndexArray.begin())) {
         AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[m]);
       } else {
         AppendIndex2(m_Buffer, dwObjStmNum, m_ObjStream.m_index++);
       }
     }
   }
   if (iSize > 0 && bEOF) {
     AppendIndex1(m_Buffer, objOffset);
     m_IndexArray.push_back({dwObjStmNum, 1});
     iSeg += 1;
   }
   m_iSeg = iSeg;
   if (bEOF) {
     m_ObjStream.Start();
   }
   return 1;
 }
 FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator,
                                             FX_BOOL bEOF) {
   FX_FILESIZE offset_tmp = pCreator->m_Offset;
-  FX_DWORD objnum = ++pCreator->m_dwLastObjNum;
+  uint32_t objnum = ++pCreator->m_dwLastObjNum;
   CFX_FileBufferArchive* pFile = &pCreator->m_File;
   FX_BOOL bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
   if (bIncremental) {
     AddObjectNumberToIndexArray(objnum);
   } else {
     for (; m_dwTempObjNum < pCreator->m_dwLastObjNum; m_dwTempObjNum++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjNum);
       if (offset) {
         AppendIndex1(m_Buffer, *offset);
       } else {
@@ skipping 88 matching lines @@
   }
   offset += len + 8;
   if (bEOF) {
     if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile,
                                        pCreator->m_pIDArray,
                                        pCreator->m_bCompress)) < 0) {
       return FALSE;
     }
     offset += len;
     if (pCreator->m_pEncryptDict) {
-      FX_DWORD dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum();
+      uint32_t dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum();
       if (dwEncryptObjNum == 0) {
         dwEncryptObjNum = pCreator->m_dwEnryptObjNum;
       }
       if ((len = PDF_CreatorWriteEncrypt(pCreator->m_pEncryptDict,
                                          dwEncryptObjNum, pFile)) < 0) {
         return FALSE;
       }
       offset += len;
     }
   }
@@ skipping 13 matching lines @@
 }
 FX_BOOL CPDF_XRefStream::End(CPDF_Creator* pCreator, FX_BOOL bEOF) {
   if (EndObjectStream(pCreator, bEOF) < 0) {
     return FALSE;
   }
   return GenerateXRefStream(pCreator, bEOF);
 }
 FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) {
   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
     AppendIndex0(m_Buffer, true);
-    for (FX_DWORD i = 1; i < pCreator->m_dwLastObjNum + 1; i++) {
+    for (uint32_t i = 1; i < pCreator->m_dwLastObjNum + 1; i++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(i);
       if (offset) {
         AppendIndex1(m_Buffer, *offset);
       } else {
         AppendIndex0(m_Buffer, false);
       }
     }
   } else {
     for (const auto& pair : m_IndexArray) {
-      for (FX_DWORD j = pair.objnum; j < pair.objnum + pair.count; ++j)
+      for (uint32_t j = pair.objnum; j < pair.objnum + pair.count; ++j)
         AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]);
     }
   }
   return GenerateXRefStream(pCreator, FALSE);
 }
-void CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum) {
+void CPDF_XRefStream::AddObjectNumberToIndexArray(uint32_t objnum) {
   if (m_IndexArray.empty()) {
     m_IndexArray.push_back({objnum, 1});
     return;
   }
-  FX_DWORD next_objnum = m_IndexArray.back().objnum + m_IndexArray.back().count;
+  uint32_t next_objnum = m_IndexArray.back().objnum + m_IndexArray.back().count;
   if (objnum == next_objnum)
     m_IndexArray.back().count += 1;
   else
     m_IndexArray.push_back({objnum, 1});
 }
 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
   m_pParser = (CPDF_Parser*)pDoc->m_pParser;
   m_bCompress = TRUE;
   if (m_pParser) {
@@ skipping 27 matching lines @@
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   Clear();
 }
 
 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) {
   if (!m_pXRefStream)
     return 1;
 
-  FX_DWORD objnum = pObj->GetObjNum();
+  uint32_t objnum = pObj->GetObjNum();
   if (m_pParser && m_pParser->GetObjectGenNum(objnum) > 0)
     return 1;
 
   if (pObj->IsNumber())
     return 1;
 
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (pObj->IsStream()) {
     if (pDict && pDict->GetStringBy("Type") == "XRef")
       return 0;
@@ skipping 13 matching lines @@
   if (m_pXRefStream->CompressIndirectObject(objnum, pObj, this) < 0)
     return -1;
   if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags))
     return 0;
   if (!m_pXRefStream->End(this))
     return -1;
   if (!m_pXRefStream->Start())
     return -1;
   return 0;
 }
-int32_t CPDF_Creator::WriteIndirectObjectToStream(FX_DWORD objnum,
+int32_t CPDF_Creator::WriteIndirectObjectToStream(uint32_t objnum,
                                                   const uint8_t* pBuffer,
-                                                  FX_DWORD dwSize) {
+                                                  uint32_t dwSize) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   int32_t iRet =
       m_pXRefStream->CompressIndirectObject(objnum, pBuffer, dwSize, this);
   if (iRet < 1) {
     return iRet;
   }
   if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
-int32_t CPDF_Creator::AppendObjectNumberToXRef(FX_DWORD objnum) {
+int32_t CPDF_Creator::AppendObjectNumberToXRef(uint32_t objnum) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream,
-                                  FX_DWORD objnum,
+                                  uint32_t objnum,
                                   IPDF_CryptoHandler* pCrypto) {
   CPDF_FlateEncoder encoder;
   encoder.Initialize(const_cast<CPDF_Stream*>(pStream->AsStream()),
                      pStream == m_pMetadata ? FALSE : m_bCompress);
   CPDF_Encryptor encryptor;
   if (!encryptor.Initialize(pCrypto, objnum, encoder.m_pData,
                             encoder.m_dwSize)) {
     return -1;
   }
-  if ((FX_DWORD)encoder.m_pDict->GetIntegerBy("Length") != encryptor.m_dwSize) {
+  if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") != encryptor.m_dwSize) {
     encoder.CloneDict();
     encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
   }
   if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
     return -1;
   }
   int len = m_File.AppendString("stream\r\n");
   if (len < 0) {
     return -1;
   }
   m_Offset += len;
   if (m_File.AppendBlock(encryptor.m_pData, encryptor.m_dwSize) < 0) {
     return -1;
   }
   m_Offset += encryptor.m_dwSize;
   if ((len = m_File.AppendString("\r\nendstream")) < 0) {
     return -1;
   }
   m_Offset += len;
   return 1;
 }
-int32_t CPDF_Creator::WriteIndirectObj(FX_DWORD objnum,
+int32_t CPDF_Creator::WriteIndirectObj(uint32_t objnum,
                                        const CPDF_Object* pObj) {
   int32_t len = m_File.AppendDWord(objnum);
   if (len < 0)
     return -1;
 
   m_Offset += len;
   if ((len = m_File.AppendString(" 0 obj\r\n")) < 0)
     return -1;
 
   m_Offset += len;
@@ skipping 15 matching lines @@
     return -1;
   return 0;
 }
 int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj) {
   int32_t iRet = WriteIndirectObjectToStream(pObj);
   if (iRet < 1) {
     return iRet;
   }
   return WriteIndirectObj(pObj->GetObjNum(), pObj);
 }
-int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum,
+int32_t CPDF_Creator::WriteDirectObj(uint32_t objnum,
                                      const CPDF_Object* pObj,
                                      FX_BOOL bEncrypt) {
   int32_t len = 0;
   if (!pObj) {
     if (m_File.AppendString(" null") < 0) {
       return -1;
     }
     m_Offset += 5;
     return 1;
   }
@@ skipping 37 matching lines @@
       m_Offset += len;
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_FlateEncoder encoder;
       encoder.Initialize(const_cast<CPDF_Stream*>(pObj->AsStream()),
                          m_bCompress);
       CPDF_Encryptor encryptor;
       IPDF_CryptoHandler* pHandler = m_pCryptoHandler;
       encryptor.Initialize(pHandler, objnum, encoder.m_pData, encoder.m_dwSize);
-      if ((FX_DWORD)encoder.m_pDict->GetIntegerBy("Length") !=
+      if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") !=
           encryptor.m_dwSize) {
         encoder.CloneDict();
         encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
       }
       if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
         return -1;
       }
       if ((len = m_File.AppendString("stream\r\n")) < 0) {
         return -1;
       }
@@ skipping 28 matching lines @@
         return -1;
       m_Offset += len + 5;
       break;
     }
     case CPDF_Object::ARRAY: {
       if (m_File.AppendString("[") < 0) {
         return -1;
       }
       m_Offset += 1;
       const CPDF_Array* p = pObj->AsArray();
-      for (FX_DWORD i = 0; i < p->GetCount(); i++) {
+      for (uint32_t i = 0; i < p->GetCount(); i++) {
         CPDF_Object* pElement = p->GetElement(i);
         if (pElement->GetObjNum()) {
           if (m_File.AppendString(" ") < 0) {
             return -1;
           }
           if ((len = m_File.AppendDWord(pElement->GetObjNum())) < 0) {
             return -1;
           }
           if (m_File.AppendString(" 0 R") < 0) {
             return -1;
@@ skipping 54 matching lines @@
       }
       if (m_File.AppendString(">>") < 0) {
         return -1;
       }
       m_Offset += 2;
       break;
     }
   }
   return 1;
 }
-int32_t CPDF_Creator::WriteOldIndirectObject(FX_DWORD objnum) {
+int32_t CPDF_Creator::WriteOldIndirectObject(uint32_t objnum) {
   if (m_pParser->IsObjectFreeOrNull(objnum))
     return 0;
 
   m_ObjectOffset[objnum] = m_Offset;
   FX_BOOL bExistInMap =
       pdfium::ContainsKey(m_pDocument->m_IndirectObjs, objnum);
   const uint8_t object_type = m_pParser->GetObjectType(objnum);
   bool bObjStm = (object_type == 2) && m_pEncryptDict && !m_pXRefStream;
   if (m_pParser->IsVersionUpdated() || m_bSecurityChanged || bExistInMap ||
       bObjStm) {
     CPDF_Object* pObj = m_pDocument->GetIndirectObject(objnum);
     if (!pObj) {
       m_ObjectOffset[objnum] = 0;
       return 0;
     }
     if (WriteIndirectObj(pObj)) {
       return -1;
     }
     if (!bExistInMap) {
       m_pDocument->ReleaseIndirectObject(objnum);
     }
   } else {
     uint8_t* pBuffer;
-    FX_DWORD size;
+    uint32_t size;
     m_pParser->GetIndirectBinary(objnum, pBuffer, size);
     if (!pBuffer) {
       return 0;
     }
     if (object_type == 2) {
       if (m_pXRefStream) {
         if (WriteIndirectObjectToStream(objnum, pBuffer, size) < 0) {
           FX_Free(pBuffer);
           return -1;
         }
@@ skipping 22 matching lines @@
       m_Offset += size;
       if (AppendObjectNumberToXRef(objnum) < 0) {
         return -1;
       }
     }
     FX_Free(pBuffer);
   }
   return 1;
 }
 int32_t CPDF_Creator::WriteOldObjs(IFX_Pause* pPause) {
-  FX_DWORD nLastObjNum = m_pParser->GetLastObjNum();
+  uint32_t nLastObjNum = m_pParser->GetLastObjNum();
   if (!m_pParser->IsValidObjectNumber(nLastObjNum))
     return 0;
 
-  FX_DWORD objnum = (FX_DWORD)(uintptr_t)m_Pos;
+  uint32_t objnum = (uint32_t)(uintptr_t)m_Pos;
   for (; objnum <= nLastObjNum; ++objnum) {
     int32_t iRet = WriteOldIndirectObject(objnum);
     if (iRet < 0)
       return iRet;
 
     if (!iRet)
       continue;
 
     if (pPause && pPause->NeedToPauseNow()) {
       m_Pos = (void*)(uintptr_t)(objnum + 1);
       return 1;
     }
   }
   return 0;
 }
 int32_t CPDF_Creator::WriteNewObjs(FX_BOOL bIncremental, IFX_Pause* pPause) {
   int32_t iCount = m_NewObjNumArray.GetSize();
   int32_t index = (int32_t)(uintptr_t)m_Pos;
   while (index < iCount) {
-    FX_DWORD objnum = m_NewObjNumArray.ElementAt(index);
+    uint32_t objnum = m_NewObjNumArray.ElementAt(index);
     auto it = m_pDocument->m_IndirectObjs.find(objnum);
     if (it == m_pDocument->m_IndirectObjs.end()) {
       ++index;
       continue;
     }
     m_ObjectOffset[objnum] = m_Offset;
     if (WriteIndirectObj(it->second)) {
       return -1;
     }
     index++;
     if (pPause && pPause->NeedToPauseNow()) {
       m_Pos = (FX_POSITION)(uintptr_t)index;
       return 1;
     }
   }
   return 0;
 }
 void CPDF_Creator::InitOldObjNumOffsets() {
   if (!m_pParser) {
     return;
   }
-  FX_DWORD j = 0;
-  FX_DWORD dwStart = 0;
-  FX_DWORD dwEnd = m_pParser->GetLastObjNum();
+  uint32_t j = 0;
+  uint32_t dwStart = 0;
+  uint32_t dwEnd = m_pParser->GetLastObjNum();
   while (dwStart <= dwEnd) {
     while (dwStart <= dwEnd && m_pParser->IsObjectFreeOrNull(dwStart))
       dwStart++;
 
     if (dwStart > dwEnd)
       break;
 
     j = dwStart;
     while (j <= dwEnd && !m_pParser->IsObjectFreeOrNull(j))
       j++;
 
     m_ObjectOffset.Add(dwStart, j - dwStart);
     dwStart = j;
   }
 }
 void CPDF_Creator::InitNewObjNumOffsets() {
   FX_BOOL bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
   FX_BOOL bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0;
   for (const auto& pair : m_pDocument->m_IndirectObjs) {
-    const FX_DWORD objnum = pair.first;
+    const uint32_t objnum = pair.first;
     const CPDF_Object* pObj = pair.second;
     if (pObj->GetObjNum() == -1)
       continue;
     if (bIncremental) {
       if (!pObj->IsModified())
         continue;
     } else if (m_pParser && m_pParser->IsValidObjectNumber(objnum) &&
                m_pParser->GetObjectType(objnum)) {
       continue;
     }
     AppendNewObjNum(objnum);
   }
 
   int32_t iCount = m_NewObjNumArray.GetSize();
   if (iCount == 0) {
     return;
   }
   int32_t i = 0;
-  FX_DWORD dwStartObjNum = 0;
+  uint32_t dwStartObjNum = 0;
   FX_BOOL bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0;
   while (i < iCount) {
     dwStartObjNum = m_NewObjNumArray.ElementAt(i);
     if ((bIncremental && (bNoOriginal || bCrossRefValid)) ||
         !m_ObjectOffset.GetPtrAt(dwStartObjNum)) {
       break;
     }
     i++;
   }
   if (i >= iCount) {
     return;
   }
-  FX_DWORD dwLastObjNum = dwStartObjNum;
+  uint32_t dwLastObjNum = dwStartObjNum;
   i++;
   FX_BOOL bNewStart = FALSE;
   for (; i < iCount; i++) {
-    FX_DWORD dwCurObjNum = m_NewObjNumArray.ElementAt(i);
+    uint32_t dwCurObjNum = m_NewObjNumArray.ElementAt(i);
     bool bExist = m_pParser && m_pParser->IsValidObjectNumber(dwCurObjNum) &&
                   m_ObjectOffset.GetPtrAt(dwCurObjNum);
     if (bExist || dwCurObjNum - dwLastObjNum > 1) {
       if (!bNewStart)
         m_ObjectOffset.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum + 1);
       dwStartObjNum = dwCurObjNum;
     }
     if (bNewStart) {
       dwStartObjNum = dwCurObjNum;
     }
     bNewStart = bExist;
     dwLastObjNum = dwCurObjNum;
   }
   m_ObjectOffset.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum + 1);
 }
-void CPDF_Creator::AppendNewObjNum(FX_DWORD objbum) {
+void CPDF_Creator::AppendNewObjNum(uint32_t objbum) {
   int32_t iStart = 0, iFind = 0;
   int32_t iEnd = m_NewObjNumArray.GetUpperBound();
   while (iStart <= iEnd) {
     int32_t iMid = (iStart + iEnd) / 2;
-    FX_DWORD dwMid = m_NewObjNumArray.ElementAt(iMid);
+    uint32_t dwMid = m_NewObjNumArray.ElementAt(iMid);
     if (objbum < dwMid) {
       iEnd = iMid - 1;
     } else {
       if (iMid == iEnd) {
         iFind = iMid + 1;
         break;
       }
-      FX_DWORD dwNext = m_NewObjNumArray.ElementAt(iMid + 1);
+      uint32_t dwNext = m_NewObjNumArray.ElementAt(iMid + 1);
       if (objbum < dwNext) {
         iFind = iMid + 1;
         break;
       }
       iStart = iMid + 1;
     }
   }
   m_NewObjNumArray.InsertAt(iFind, objbum);
 }
 int32_t CPDF_Creator::WriteDoc_Stage1(IFX_Pause* pPause) {
@@ skipping 44 matching lines @@
       IFX_FileRead* pSrcFile = m_pParser->GetFileAccess();
       m_Offset = pSrcFile->GetSize();
       m_Pos = (void*)(uintptr_t)m_Offset;
       m_iStage = 15;
     }
   }
   if (m_iStage == 15) {
     if ((m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0 && m_Pos) {
       IFX_FileRead* pSrcFile = m_pParser->GetFileAccess();
       uint8_t buffer[4096];
-      FX_DWORD src_size = (FX_DWORD)(uintptr_t)m_Pos;
+      uint32_t src_size = (uint32_t)(uintptr_t)m_Pos;
       while (src_size) {
-        FX_DWORD block_size = src_size > 4096 ? 4096 : src_size;
+        uint32_t block_size = src_size > 4096 ? 4096 : src_size;
         if (!pSrcFile->ReadBlock(buffer, m_Offset - src_size, block_size)) {
           return -1;
         }
         if (m_File.AppendBlock(buffer, block_size) < 0) {
           return -1;
         }
         src_size -= block_size;
         if (pPause && pPause->NeedToPauseNow()) {
           m_Pos = (void*)(uintptr_t)src_size;
           return 1;
         }
       }
     }
     if ((m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0 &&
         m_pParser->GetLastXRefOffset() == 0) {
       InitOldObjNumOffsets();
-      FX_DWORD dwEnd = m_pParser->GetLastObjNum();
+      uint32_t dwEnd = m_pParser->GetLastObjNum();
       bool bObjStm = (m_dwFlags & FPDFCREATE_OBJECTSTREAM) != 0;
-      for (FX_DWORD objnum = 0; objnum <= dwEnd; objnum++) {
+      for (uint32_t objnum = 0; objnum <= dwEnd; objnum++) {
         if (m_pParser->IsObjectFreeOrNull(objnum))
           continue;
 
         m_ObjectOffset[objnum] = m_pParser->GetObjectPositionOrZero(objnum);
         if (bObjStm) {
           m_pXRefStream->AddObjectNumberToIndexArray(objnum);
         }
       }
       if (bObjStm) {
         m_pXRefStream->EndXRefStream(this);
@@ skipping 47 matching lines @@
       if (m_dwFlags & FPDFCREATE_INCREMENTAL) {
         m_NewObjNumArray.Add(m_dwLastObjNum);
       }
     }
     m_iStage = 80;
   }
   return m_iStage;
 }
 int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause* pPause) {
   FXSYS_assert(m_iStage >= 80 || m_iStage < 90);
-  FX_DWORD dwLastObjNum = m_dwLastObjNum;
+  uint32_t dwLastObjNum = m_dwLastObjNum;
   if (m_iStage == 80) {
     m_XrefStart = m_Offset;
     if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
       m_pXRefStream->End(this, TRUE);
       m_XrefStart = m_pXRefStream->m_PrevOffset;
       m_iStage = 90;
     } else if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 ||
                !m_pParser->IsXRefStream()) {
       if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 ||
           m_pParser->GetLastXRefOffset() == 0) {
@@ skipping 12 matching lines @@
         }
         m_Pos = (void*)(uintptr_t)0;
         m_iStage = 82;
       }
     } else {
       m_iStage = 90;
     }
   }
   if (m_iStage == 81) {
     CFX_ByteString str;
-    FX_DWORD i = (FX_DWORD)(uintptr_t)m_Pos, j;
+    uint32_t i = (uint32_t)(uintptr_t)m_Pos, j;
     while (i <= dwLastObjNum) {
       while (i <= dwLastObjNum && !m_ObjectOffset.GetPtrAt(i)) {
         i++;
       }
       if (i > dwLastObjNum) {
         break;
       }
       j = i;
       while (j <= dwLastObjNum && m_ObjectOffset.GetPtrAt(j)) {
         j++;
@@ skipping 21 matching lines @@
       }
     }
     m_iStage = 90;
   }
   if (m_iStage == 82) {
     CFX_ByteString str;
     int32_t iCount = m_NewObjNumArray.GetSize();
     int32_t i = (int32_t)(uintptr_t)m_Pos;
     while (i < iCount) {
       int32_t j = i;
-      FX_DWORD objnum = m_NewObjNumArray.ElementAt(i);
+      uint32_t objnum = m_NewObjNumArray.ElementAt(i);
       while (j < iCount) {
         if (++j == iCount) {
           break;
         }
-        FX_DWORD dwCurrent = m_NewObjNumArray.ElementAt(j);
+        uint32_t dwCurrent = m_NewObjNumArray.ElementAt(j);
         if (dwCurrent - objnum > 1) {
           break;
         }
         objnum = dwCurrent;
       }
       objnum = m_NewObjNumArray.ElementAt(i);
       if (objnum == 1) {
         str.Format("0 %d\r\n0000000000 65535 f\r\n", j - i + 1);
       } else {
         str.Format("%d %d\r\n", objnum, j - i);
@@ skipping 89 matching lines @@
         }
         if (m_File.AppendString(" 0 R\r\n") < 0) {
           return -1;
         }
       }
     }
     if (m_pEncryptDict) {
       if (m_File.AppendString("/Encrypt") < 0) {
         return -1;
       }
-      FX_DWORD dwObjNum = m_pEncryptDict->GetObjNum();
+      uint32_t dwObjNum = m_pEncryptDict->GetObjNum();
       if (dwObjNum == 0) {
         dwObjNum = m_pDocument->GetLastObjNum() + 1;
       }
       if (m_File.AppendString(" ") < 0) {
         return -1;
       }
       if (m_File.AppendDWord(dwObjNum) < 0) {
         return -1;
       }
       if (m_File.AppendString(" 0 R ") < 0) {
@@ skipping 32 matching lines @@
     if (!bXRefStream) {
       if (m_File.AppendString(">>") < 0) {
         return -1;
       }
     } else {
       if (m_File.AppendString("/W[0 4 1]/Index[") < 0) {
         return -1;
       }
       if ((m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser &&
           m_pParser->GetLastXRefOffset() == 0) {
-        FX_DWORD i = 0;
+        uint32_t i = 0;
         for (i = 0; i < m_dwLastObjNum; i++) {
           if (!m_ObjectOffset.GetPtrAt(i)) {
             continue;
           }
           if (m_File.AppendDWord(i) < 0) {
             return -1;
           }
           if (m_File.AppendString(" 1 ") < 0) {
             return -1;
           }
@@ skipping 11 matching lines @@
           FX_FILESIZE* offset = m_ObjectOffset.GetPtrAt(i);
           if (!offset) {
             continue;
           }
           OutputIndex(&m_File, *offset);
         }
       } else {
         int count = m_NewObjNumArray.GetSize();
         int32_t i = 0;
         for (i = 0; i < count; i++) {
-          FX_DWORD objnum = m_NewObjNumArray.ElementAt(i);
+          uint32_t objnum = m_NewObjNumArray.ElementAt(i);
           if (m_File.AppendDWord(objnum) < 0) {
             return -1;
           }
           if (m_File.AppendString(" 1 ") < 0) {
             return -1;
           }
         }
         if (m_File.AppendString("]/Length ") < 0) {
           return -1;
         }
         if (m_File.AppendDWord(count * 5) < 0) {
           return -1;
         }
         if (m_File.AppendString(">>stream\r\n") < 0) {
           return -1;
         }
         for (i = 0; i < count; i++) {
-          FX_DWORD objnum = m_NewObjNumArray.ElementAt(i);
+          uint32_t objnum = m_NewObjNumArray.ElementAt(i);
           FX_FILESIZE offset = m_ObjectOffset[objnum];
           OutputIndex(&m_File, offset);
         }
       }
       if (m_File.AppendString("\r\nendstream") < 0) {
         return -1;
       }
     }
   }
   if (m_File.AppendString("\r\nstartxref\r\n") < 0) {
@@ skipping 15 matching lines @@
   delete m_pXRefStream;
   m_pXRefStream = NULL;
   m_File.Clear();
   m_NewObjNumArray.RemoveAll();
   if (m_pIDArray) {
     m_pIDArray->Release();
     m_pIDArray = NULL;
   }
 }
 
-bool CPDF_Creator::Create(IFX_StreamWrite* pFile, FX_DWORD flags) {
+bool CPDF_Creator::Create(IFX_StreamWrite* pFile, uint32_t flags) {
   m_File.AttachFile(pFile);
   return Create(flags);
 }
 
-bool CPDF_Creator::Create(FX_DWORD flags) {
+bool CPDF_Creator::Create(uint32_t flags) {
   m_dwFlags = flags;
   m_iStage = 0;
   m_Offset = 0;
   m_dwLastObjNum = m_pDocument->GetLastObjNum();
   m_ObjectOffset.Clear();
   m_NewObjNumArray.RemoveAll();
   InitID();
   if (flags & FPDFCREATE_PROGRESSIVE) {
     return true;
   }
   return Continue(NULL) > -1;
 }
 void CPDF_Creator::InitID(FX_BOOL bDefault) {
   CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL;
   FX_BOOL bNewId = !m_pIDArray;
   if (!m_pIDArray) {
     m_pIDArray = new CPDF_Array;
     CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetElement(0) : NULL;
     if (pID1) {
       m_pIDArray->Add(pID1->Clone());
     } else {
       std::vector<uint8_t> buffer =
-          PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum);
+          PDF_GenerateFileID((uint32_t)(uintptr_t) this, m_dwLastObjNum);
       CFX_ByteStringC bsBuffer(buffer.data(), buffer.size());
       m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
     }
   }
   if (!bDefault) {
     return;
   }
   if (pOldIDArray) {
     CPDF_Object* pID2 = pOldIDArray->GetElement(1);
     if ((m_dwFlags & FPDFCREATE_INCREMENTAL) && m_pEncryptDict && pID2) {
       m_pIDArray->Add(pID2->Clone());
       return;
     }
     std::vector<uint8_t> buffer =
-        PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum);
+        PDF_GenerateFileID((uint32_t)(uintptr_t) this, m_dwLastObjNum);
     CFX_ByteStringC bsBuffer(buffer.data(), buffer.size());
     m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
     return;
   }
   m_pIDArray->Add(m_pIDArray->GetElement(0)->Clone());
   if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) {
     if (m_pEncryptDict->GetStringBy("Filter") == "Standard") {
       CPDF_StandardSecurityHandler handler;
       CFX_ByteString user_pass = m_pParser->GetPassword();
-      FX_DWORD flag = PDF_ENCRYPT_CONTENT;
+      uint32_t flag = PDF_ENCRYPT_CONTENT;
       handler.OnCreate(m_pEncryptDict, m_pIDArray, (const uint8_t*)user_pass,
                        user_pass.GetLength(), flag);
       if (m_bNewCrypto) {
         delete m_pCryptoHandler;
       }
       m_pCryptoHandler = new CPDF_StandardCryptoHandler;
       m_pCryptoHandler->Init(m_pEncryptDict, &handler);
       m_bNewCrypto = TRUE;
       m_bSecurityChanged = TRUE;
     }
@@ skipping 46 matching lines @@
   m_bNewCrypto = FALSE;
   if (!m_bStandardSecurity) {
     return;
   }
   if (m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   m_bStandardSecurity = FALSE;
 }