Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_parser/cpdf_syntax_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/cpdf_syntax_parser.h"
 
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 #include "core/fpdfapi/fpdf_parser/ipdf_crypto_handler.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "third_party/base/numerics/safe_math.h"
 
 namespace {
 
 struct SearchTagRecord {
   const char* m_pTag;
-  FX_DWORD m_Len;
-  FX_DWORD m_Offset;
+  uint32_t m_Len;
+  uint32_t m_Offset;
 };
 
 }  // namespace
 
 // static
 int CPDF_SyntaxParser::s_CurrentRecursionDepth = 0;
 
 CPDF_SyntaxParser::CPDF_SyntaxParser()
     : m_MetadataObjnum(0),
       m_pFileAccess(nullptr),
@@ skipping 10 matching lines @@
   return GetNextChar(ch);
 }
 
 FX_BOOL CPDF_SyntaxParser::GetNextChar(uint8_t& ch) {
   FX_FILESIZE pos = m_Pos + m_HeaderOffset;
   if (pos >= m_FileLen)
     return FALSE;
 
   if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
     FX_FILESIZE read_pos = pos;
-    FX_DWORD read_size = m_BufSize;
+    uint32_t read_size = m_BufSize;
     if ((FX_FILESIZE)read_size > m_FileLen)
-      read_size = (FX_DWORD)m_FileLen;
+      read_size = (uint32_t)m_FileLen;
 
     if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) {
       if (m_FileLen < (FX_FILESIZE)read_size) {
         read_pos = 0;
-        read_size = (FX_DWORD)m_FileLen;
+        read_size = (uint32_t)m_FileLen;
       } else {
         read_pos = m_FileLen - read_size;
       }
     }
 
     if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size))
       return FALSE;
 
     m_BufOffset = read_pos;
   }
   ch = m_pFileBuf[pos - m_BufOffset];
   m_Pos++;
   return TRUE;
 }
 
 FX_BOOL CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch) {
   pos += m_HeaderOffset;
   if (pos >= m_FileLen)
     return FALSE;
 
   if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
     FX_FILESIZE read_pos;
     if (pos < (FX_FILESIZE)m_BufSize)
       read_pos = 0;
     else
       read_pos = pos - m_BufSize + 1;
 
-    FX_DWORD read_size = m_BufSize;
+    uint32_t read_size = m_BufSize;
     if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) {
       if (m_FileLen < (FX_FILESIZE)read_size) {
         read_pos = 0;
-        read_size = (FX_DWORD)m_FileLen;
+        read_size = (uint32_t)m_FileLen;
       } else {
         read_pos = m_FileLen - read_size;
       }
     }
 
     if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size))
       return FALSE;
 
     m_BufOffset = read_pos;
   }
   ch = m_pFileBuf[pos - m_BufOffset];
   return TRUE;
 }
 
-FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, FX_DWORD size) {
+FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, uint32_t size) {
   if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size))
     return FALSE;
   m_Pos += size;
   return TRUE;
 }
 
 void CPDF_SyntaxParser::GetNextWordInternal(bool* bIsNumber) {
   m_WordSize = 0;
   if (bIsNumber)
     *bIsNumber = true;
@@ skipping 240 matching lines @@
 CFX_ByteString CPDF_SyntaxParser::GetNextWord(bool* bIsNumber) {
   GetNextWordInternal(bIsNumber);
   return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
   return GetNextWord(nullptr);
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjectHolder* pObjList,
-                                          FX_DWORD objnum,
-                                          FX_DWORD gennum,
+                                          uint32_t objnum,
+                                          uint32_t gennum,
                                           FX_BOOL bDecrypt) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth)
     return nullptr;
 
   FX_FILESIZE SavedPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0)
     return nullptr;
 
   if (bIsNumber) {
     FX_FILESIZE SavedPos = m_Pos;
     CFX_ByteString nextword = GetNextWord(&bIsNumber);
     if (bIsNumber) {
       CFX_ByteString nextword2 = GetNextWord(nullptr);
       if (nextword2 == "R") {
-        FX_DWORD objnum = FXSYS_atoui(word);
+        uint32_t objnum = FXSYS_atoui(word);
         return new CPDF_Reference(pObjList, objnum);
       }
     }
     m_Pos = SavedPos;
     return new CPDF_Number(word);
   }
 
   if (word == "true" || word == "false")
     return new CPDF_Boolean(word == "true");
 
@@ skipping 85 matching lines @@
   }
 
   if (word == ">>")
     m_Pos = SavedPos;
 
   return nullptr;
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(
     CPDF_IndirectObjectHolder* pObjList,
-    FX_DWORD objnum,
-    FX_DWORD gennum) {
+    uint32_t objnum,
+    uint32_t gennum) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth)
     return nullptr;
 
   FX_FILESIZE SavedPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0)
     return nullptr;
 
@@ skipping 106 matching lines @@
   if (byte1 == '\r' && byte2 == '\n')
     return 2;
 
   if (byte1 == '\r' || byte1 == '\n')
     return 1;
 
   return 0;
 }
 
 CPDF_Stream* CPDF_SyntaxParser::ReadStream(CPDF_Dictionary* pDict,
-                                           FX_DWORD objnum,
-                                           FX_DWORD gennum) {
+                                           uint32_t objnum,
+                                           uint32_t gennum) {
   CPDF_Object* pLenObj = pDict->GetElement("Length");
   FX_FILESIZE len = -1;
   CPDF_Reference* pLenObjRef = ToReference(pLenObj);
 
   bool differingObjNum = !pLenObjRef || (pLenObjRef->GetObjList() &&
                                          pLenObjRef->GetRefObjNum() != objnum);
   if (pLenObj && differingObjNum)
     len = pLenObj->GetInteger();
 
   // Locate the start of stream.
   ToNextLine();
   FX_FILESIZE streamStartPos = m_Pos;
 
   const CFX_ByteStringC kEndStreamStr("endstream");
   const CFX_ByteStringC kEndObjStr("endobj");
 
   IPDF_CryptoHandler* pCryptoHandler =
-      objnum == (FX_DWORD)m_MetadataObjnum ? nullptr : m_pCryptoHandler.get();
+      objnum == (uint32_t)m_MetadataObjnum ? nullptr : m_pCryptoHandler.get();
   if (!pCryptoHandler) {
     FX_BOOL bSearchForKeyword = TRUE;
     if (len >= 0) {
       pdfium::base::CheckedNumeric<FX_FILESIZE> pos = m_Pos;
       pos += len;
       if (pos.IsValid() && pos.ValueOrDie() < m_FileLen)
         m_Pos = pos.ValueOrDie();
 
       m_Pos += ReadEOLMarkers(m_Pos);
       FXSYS_memset(m_WordBuffer, 0, kEndStreamStr.GetLength() + 1);
@@ skipping 114 matching lines @@
   if (m_WordSize == static_cast<unsigned int>(kEndObjStr.GetLength()) &&
       numMarkers != 0 &&
       FXSYS_memcmp(m_WordBuffer, kEndObjStr.GetPtr(), kEndObjStr.GetLength()) ==
           0) {
     m_Pos = streamStartPos;
   }
   return pStream;
 }
 
 void CPDF_SyntaxParser::InitParser(IFX_FileRead* pFileAccess,
-                                   FX_DWORD HeaderOffset) {
+                                   uint32_t HeaderOffset) {
   FX_Free(m_pFileBuf);
 
   m_pFileBuf = FX_Alloc(uint8_t, m_BufSize);
   m_HeaderOffset = HeaderOffset;
   m_FileLen = pFileAccess->GetSize();
   m_Pos = 0;
   m_pFileAccess = pFileAccess;
   m_BufOffset = 0;
   pFileAccess->ReadBlock(
       m_pFileBuf, 0,
       (size_t)((FX_FILESIZE)m_BufSize > m_FileLen ? m_FileLen : m_BufSize));
 }
 
 uint32_t CPDF_SyntaxParser::GetDirectNum() {
   bool bIsNumber;
   GetNextWordInternal(&bIsNumber);
   if (!bIsNumber)
     return 0;
 
   m_WordBuffer[m_WordSize] = 0;
   return FXSYS_atoui(reinterpret_cast<const FX_CHAR*>(m_WordBuffer));
 }
 
 bool CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos,
                                     FX_FILESIZE limit,
                                     const CFX_ByteStringC& tag,
                                     FX_BOOL checkKeyword) {
-  const FX_DWORD taglen = tag.GetLength();
+  const uint32_t taglen = tag.GetLength();
 
   bool bCheckLeft = !PDFCharIsDelimiter(tag[0]) && !PDFCharIsWhitespace(tag[0]);
   bool bCheckRight = !PDFCharIsDelimiter(tag[taglen - 1]) &&
                      !PDFCharIsWhitespace(tag[taglen - 1]);
 
   uint8_t ch;
   if (bCheckRight && startpos + (int32_t)taglen <= limit &&
       GetCharAt(startpos + (int32_t)taglen, ch)) {
     if (PDFCharIsNumeric(ch) || PDFCharIsOther(ch) ||
         (checkKeyword && PDFCharIsDelimiter(ch))) {
@@ skipping 83 matching lines @@
 int32_t CPDF_SyntaxParser::SearchMultiWord(const CFX_ByteStringC& tags,
                                            FX_BOOL bWholeWord,
                                            FX_FILESIZE limit) {
   int32_t ntags = 1;
   for (int i = 0; i < tags.GetLength(); ++i) {
     if (tags[i] == 0)
       ++ntags;
   }
 
   std::vector<SearchTagRecord> patterns(ntags);
-  FX_DWORD start = 0;
-  FX_DWORD itag = 0;
-  FX_DWORD max_len = 0;
+  uint32_t start = 0;
+  uint32_t itag = 0;
+  uint32_t max_len = 0;
   for (int i = 0; i <= tags.GetLength(); ++i) {
     if (tags[i] == 0) {
-      FX_DWORD len = i - start;
+      uint32_t len = i - start;
       max_len = std::max(len, max_len);
       patterns[itag].m_pTag = tags.GetCStr() + start;
       patterns[itag].m_Len = len;
       patterns[itag].m_Offset = 0;
       start = i + 1;
       ++itag;
     }
   }
 
   const FX_FILESIZE pos_limit = m_Pos + limit;
@@ skipping 48 matching lines @@
     if (limit && m_Pos == limit)
       return -1;
   }
   return -1;
 }
 
 void CPDF_SyntaxParser::SetEncrypt(
     std::unique_ptr<IPDF_CryptoHandler> pCryptoHandler) {
   m_pCryptoHandler = std::move(pCryptoHandler);
 }