Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_page/fpdf_page_parser.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_page/pageint.h"
 
 #include <vector>
 
@@ skipping 237 matching lines @@
   m_ParamBuf[index].m_Type = ContentParam::NUMBER;
   FX_atonum(CFX_ByteStringC(str, len), m_ParamBuf[index].m_Number.m_bInteger,
             &m_ParamBuf[index].m_Number.m_Integer);
 }
 void CPDF_StreamContentParser::AddObjectParam(CPDF_Object* pObj) {
   int index = GetNextParamPos();
   m_ParamBuf[index].m_Type = ContentParam::OBJECT;
   m_ParamBuf[index].m_pObject = pObj;
 }
 void CPDF_StreamContentParser::ClearAllParams() {
-  FX_DWORD index = m_ParamStartPos;
-  for (FX_DWORD i = 0; i < m_ParamCount; i++) {
+  uint32_t index = m_ParamStartPos;
+  for (uint32_t i = 0; i < m_ParamCount; i++) {
     if (m_ParamBuf[index].m_Type == 0) {
       if (CPDF_Object* pObject = m_ParamBuf[index].m_pObject)
         pObject->Release();
     }
     index++;
     if (index == PARAM_BUF_SIZE) {
       index = 0;
     }
   }
   m_ParamStartPos = 0;
   m_ParamCount = 0;
 }
 
-CPDF_Object* CPDF_StreamContentParser::GetObject(FX_DWORD index) {
+CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
   if (index >= m_ParamCount) {
     return NULL;
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= PARAM_BUF_SIZE) {
     real_index -= PARAM_BUF_SIZE;
   }
   ContentParam& param = m_ParamBuf[real_index];
   if (param.m_Type == ContentParam::NUMBER) {
     CPDF_Number* pNumber = param.m_Number.m_bInteger
@@ skipping 11 matching lines @@
     param.m_pObject = pName;
     return pName;
   }
   if (param.m_Type == ContentParam::OBJECT) {
     return param.m_pObject;
   }
   ASSERT(FALSE);
   return NULL;
 }
 
-CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index) {
+CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
   if (index >= m_ParamCount) {
     return CFX_ByteString();
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= PARAM_BUF_SIZE) {
     real_index -= PARAM_BUF_SIZE;
   }
   ContentParam& param = m_ParamBuf[real_index];
   if (param.m_Type == ContentParam::NAME) {
     return CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len);
   }
   if (param.m_Type == 0 && param.m_pObject) {
     return param.m_pObject->GetString();
   }
   return CFX_ByteString();
 }
 
-FX_FLOAT CPDF_StreamContentParser::GetNumber(FX_DWORD index) {
+FX_FLOAT CPDF_StreamContentParser::GetNumber(uint32_t index) {
   if (index >= m_ParamCount) {
     return 0;
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= PARAM_BUF_SIZE) {
     real_index -= PARAM_BUF_SIZE;
   }
   ContentParam& param = m_ParamBuf[real_index];
   if (param.m_Type == ContentParam::NUMBER) {
     return param.m_Number.m_bInteger ? (FX_FLOAT)param.m_Number.m_Integer
                                      : param.m_Number.m_Float;
   }
   if (param.m_Type == 0 && param.m_pObject) {
     return param.m_pObject->GetNumber();
   }
   return 0;
 }
 
-FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index) {
+FX_FLOAT CPDF_StreamContentParser::GetNumber16(uint32_t index) {
   return GetNumber(index);
 }
 
 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
                                                 FX_BOOL bColor,
                                                 FX_BOOL bText,
                                                 FX_BOOL bGraph) {
   pObj->m_GeneralState = m_pCurStates->m_GeneralState;
   pObj->m_ClipPath = m_pCurStates->m_ClipPath;
   pObj->m_ContentMark = m_CurContentMark;
@@ skipping 124 matching lines @@
        &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
       {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
       {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
       {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
       {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
   });
 }
 
 void CPDF_StreamContentParser::OnOperator(const FX_CHAR* op) {
   int i = 0;
-  FX_DWORD opid = 0;
+  uint32_t opid = 0;
   while (i < 4 && op[i]) {
     opid = (opid << 8) + op[i];
     i++;
   }
   while (i < 4) {
     opid <<= 8;
     i++;
   }
 
   static const OpCodes s_OpCodes = InitializeOpCodes();
@@ skipping 69 matching lines @@
       }
     }
     if (type != CPDF_StreamParser::Name) {
       break;
     }
     CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1,
                        m_pSyntax->GetWordSize() - 1);
     std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
         m_pSyntax->ReadNextObject());
     if (!key.IsEmpty()) {
-      FX_DWORD dwObjNum = pObj ? pObj->GetObjNum() : 0;
+      uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
       if (dwObjNum)
         pDict->SetAtReference(key, m_pDocument, dwObjNum);
       else
         pDict->SetAt(key, pObj.release());
     }
   }
   PDF_ReplaceAbbr(pDict);
   CPDF_Object* pCSObj = NULL;
   if (pDict->KeyExist("ColorSpace")) {
     pCSObj = pDict->GetElementValue("ColorSpace");
@@ skipping 1050 matching lines @@
   }
   if (PathClipType) {
     if (!matrix.IsIdentity()) {
       Path.Transform(&matrix);
       matrix.SetIdentity();
     }
     m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
   }
 }
 
-FX_DWORD CPDF_StreamContentParser::Parse(const uint8_t* pData,
-                                         FX_DWORD dwSize,
-                                         FX_DWORD max_cost) {
+uint32_t CPDF_StreamContentParser::Parse(const uint8_t* pData,
+                                         uint32_t dwSize,
+                                         uint32_t max_cost) {
   if (m_Level > _FPDF_MAX_FORM_LEVEL_) {
     return dwSize;
   }
-  FX_DWORD InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
+  uint32_t InitObjCount = m_pObjectHolder->GetPageObjectList()->size();
   CPDF_StreamParser syntax(pData, dwSize);
   CPDF_StreamParserAutoClearer auto_clearer(&m_pSyntax, &syntax);
   while (1) {
-    FX_DWORD cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
+    uint32_t cost = m_pObjectHolder->GetPageObjectList()->size() - InitObjCount;
     if (max_cost && cost >= max_cost) {
       break;
     }
     switch (syntax.ParseNextElement()) {
       case CPDF_StreamParser::EndOfData:
         return m_pSyntax->GetPos();
       case CPDF_StreamParser::Keyword:
         OnOperator((char*)syntax.GetWordBuf());
         ClearAllParams();
         break;
@@ skipping 134 matching lines @@
       for (const auto& op : replacements) {
         if (op.is_replace_key)
           pDict->ReplaceKey(op.key, op.replacement);
         else
           pDict->SetAtName(op.key, op.replacement);
       }
       break;
     }
     case CPDF_Object::ARRAY: {
       CPDF_Array* pArray = pObj->AsArray();
-      for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
+      for (uint32_t i = 0; i < pArray->GetCount(); i++) {
         CPDF_Object* pElement = pArray->GetElement(i);
         if (pElement->IsName()) {
           CFX_ByteString name = pElement->GetString();
           CFX_ByteStringC fullname = PDF_FindFullName(
               PDF_InlineValueAbbr, FX_ArraySize(PDF_InlineValueAbbr), name);
           if (!fullname.IsEmpty()) {
             pArray->SetAt(i, new CPDF_Name(fullname));
           }
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }