Remove FX_DWORD from XFA.

xfa/fxfa/parser/xfa_basic_imp.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 "xfa/fxfa/parser/xfa_basic_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_algorithm.h"
@@ skipping 24 matching lines @@
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return NULL;
 }
 
-const XFA_PACKETINFO* XFA_GetPacketByID(FX_DWORD dwPacket) {
+const XFA_PACKETINFO* XFA_GetPacketByID(uint32_t dwPacket) {
   int32_t iStart = 0, iEnd = g_iXFAPacketCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
-    FX_DWORD dwFind = (g_XFAPacketData + iMid)->eName;
+    uint32_t dwFind = (g_XFAPacketData + iMid)->eName;
     if (dwPacket == dwFind) {
       return g_XFAPacketData + iMid;
     } else if (dwPacket < dwFind) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return NULL;
 }
@@ skipping 49 matching lines @@
   } while (iStart <= iEnd);
   return NULL;
 }
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeByID(XFA_ATTRIBUTE eName) {
   return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName) : NULL;
 }
 FX_BOOL XFA_GetAttributeDefaultValue(void*& pValue,
                                      XFA_ELEMENT eElement,
                                      XFA_ATTRIBUTE eAttribute,
                                      XFA_ATTRIBUTETYPE eType,
-                                     FX_DWORD dwPacket) {
+                                     uint32_t dwPacket) {
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
   if (pInfo == NULL) {
     return FALSE;
   }
   if (dwPacket && (dwPacket & pInfo->dwPackets) == 0) {
     return FALSE;
   }
   if (pInfo->eType == eType) {
     pValue = pInfo->pDefValue;
     return TRUE;
   } else if (pInfo->eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pAttr =
         XFA_GetNotsureAttribute(eElement, eAttribute, eType);
     if (pAttr) {
       pValue = pAttr->pValue;
       return TRUE;
     }
   }
   return FALSE;
 }
 XFA_ATTRIBUTEENUM XFA_GetAttributeDefaultValue_Enum(XFA_ELEMENT eElement,
                                                     XFA_ATTRIBUTE eAttribute,
-                                                    FX_DWORD dwPacket) {
+                                                    uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Enum, dwPacket)) {
     return (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   }
   return XFA_ATTRIBUTEENUM_Unknown;
 }
 CFX_WideStringC XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT eElement,
                                                    XFA_ATTRIBUTE eAttribute,
-                                                   FX_DWORD dwPacket) {
+                                                   uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Cdata, dwPacket)) {
     return (const FX_WCHAR*)pValue;
   }
   return NULL;
 }
 FX_BOOL XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT eElement,
                                              XFA_ATTRIBUTE eAttribute,
-                                             FX_DWORD dwPacket) {
+                                             uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Boolean, dwPacket)) {
     return (FX_BOOL)(uintptr_t)pValue;
   }
   return FALSE;
 }
 int32_t XFA_GetAttributeDefaultValue_Integer(XFA_ELEMENT eElement,
                                              XFA_ATTRIBUTE eAttribute,
-                                             FX_DWORD dwPacket) {
+                                             uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Integer, dwPacket)) {
     return (int32_t)(uintptr_t)pValue;
   }
   return 0;
 }
 CXFA_Measurement XFA_GetAttributeDefaultValue_Measure(XFA_ELEMENT eElement,
                                                       XFA_ATTRIBUTE eAttribute,
-                                                      FX_DWORD dwPacket) {
+                                                      uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Measure, dwPacket)) {
     return *(CXFA_Measurement*)pValue;
   }
   return CXFA_Measurement();
 }
 int32_t XFA_GetElementCount() {
   return g_iXFAElementCount;
 }
@@ skipping 31 matching lines @@
 const uint8_t* XFA_GetElementAttributes(XFA_ELEMENT eElement, int32_t& iCount) {
   if (eElement >= g_iXFAElementCount) {
     return NULL;
   }
   const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementAttributeIndex + eElement;
   iCount = pElement->wCount;
   return g_XFAElementAttributeData + pElement->wStart;
 }
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeOfElement(XFA_ELEMENT eElement,
                                                    XFA_ATTRIBUTE eAttribute,
-                                                   FX_DWORD dwPacket) {
+                                                   uint32_t dwPacket) {
   int32_t iCount = 0;
   const uint8_t* pAttr = XFA_GetElementAttributes(eElement, iCount);
   if (pAttr == NULL || iCount < 1) {
     return NULL;
   }
   CFX_DSPATemplate<uint8_t> search;
   int32_t index = search.Lookup(eAttribute, pAttr, iCount);
   if (index < 0) {
     return NULL;
   }
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pInfo;
   return (dwPacket & pInfo->dwPackets) ? pInfo : NULL;
 }
 const XFA_ELEMENTINFO* XFA_GetChildOfElement(XFA_ELEMENT eElement,
                                              XFA_ELEMENT eChild,
-                                             FX_DWORD dwPacket) {
+                                             uint32_t dwPacket) {
   int32_t iCount = 0;
   const uint16_t* pChild = XFA_GetElementChildren(eElement, iCount);
   if (pChild == NULL || iCount < 1) {
     return NULL;
   }
   CFX_DSPATemplate<uint16_t> search;
   int32_t index = search.Lookup(eChild, pChild, iCount);
   if (index < 0) {
     return NULL;
   }
   const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eChild);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pInfo;
   return (dwPacket & pInfo->dwPackets) ? pInfo : NULL;
 }
 const XFA_PROPERTY* XFA_GetElementProperties(XFA_ELEMENT eElement,
                                              int32_t& iCount) {
   if (eElement >= g_iXFAElementCount) {
     return NULL;
   }
   const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementPropertyIndex + eElement;
   iCount = pElement->wCount;
   return g_XFAElementPropertyData + pElement->wStart;
 }
 const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_ELEMENT eElement,
                                              XFA_ELEMENT eProperty,
-                                             FX_DWORD dwPacket) {
+                                             uint32_t dwPacket) {
   int32_t iCount = 0;
   const XFA_PROPERTY* pProperty = XFA_GetElementProperties(eElement, iCount);
   if (pProperty == NULL || iCount < 1) {
     return NULL;
   }
   int32_t iStart = 0, iEnd = iCount - 1, iMid;
   do {
     iMid = (iStart + iEnd) / 2;
     XFA_ELEMENT eName = (XFA_ELEMENT)pProperty[iMid].eName;
     if (eProperty == eName) {
@@ skipping 261 matching lines @@
     : m_wsBuffer(wsBuffer), m_iPosition(0), m_iRefCount(1) {}
 void CXFA_WideTextRead::Release() {
   if (--m_iRefCount < 1) {
     delete this;
   }
 }
 IFX_Stream* CXFA_WideTextRead::Retain() {
   m_iRefCount++;
   return this;
 }
-FX_DWORD CXFA_WideTextRead::GetAccessModes() const {
+uint32_t CXFA_WideTextRead::GetAccessModes() const {
   return FX_STREAMACCESS_Read | FX_STREAMACCESS_Text;
 }
 int32_t CXFA_WideTextRead::GetLength() const {
   return m_wsBuffer.GetLength() * sizeof(FX_WCHAR);
 }
 int32_t CXFA_WideTextRead::Seek(FX_STREAMSEEK eSeek, int32_t iOffset) {
   switch (eSeek) {
     case FX_STREAMSEEK_Begin:
       m_iPosition = iOffset;
       break;
@@ skipping 29 matching lines @@
   m_iPosition += iMaxLength;
   bEOS = IsEOF();
   return iMaxLength;
 }
 uint16_t CXFA_WideTextRead::GetCodePage() const {
   return (sizeof(FX_WCHAR) == 2) ? FX_CODEPAGE_UTF16LE : FX_CODEPAGE_UTF32LE;
 }
 uint16_t CXFA_WideTextRead::SetCodePage(uint16_t wCodePage) {
   return GetCodePage();
 }