Remove FX_DWORD from fpdfsdk/ and testing/

fpdfsdk/javascript/JS_GlobalData.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 "fpdfsdk/javascript/JS_GlobalData.h"
 
 #include "core/fdrm/crypto/include/fx_crypt.h"
 #include "fpdfsdk/include/javascript/IJavaScript.h"
@@ skipping 310 matching lines @@
     p += sizeof(uint16_t);
 
     // uint16_t wTemp = (uint16_t)(('X' << 8) | 'F');
 
     if (wType == (uint16_t)(('X' << 8) | 'F')) {
       uint16_t wVersion = *((uint16_t*)p);
       p += sizeof(uint16_t);
 
       ASSERT(wVersion <= 2);
 
-      FX_DWORD dwCount = *((FX_DWORD*)p);
-      p += sizeof(FX_DWORD);
+      uint32_t dwCount = *((uint32_t*)p);
+      p += sizeof(uint32_t);
 
-      FX_DWORD dwSize = *((FX_DWORD*)p);
-      p += sizeof(FX_DWORD);
+      uint32_t dwSize = *((uint32_t*)p);
+      p += sizeof(uint32_t);
 
-      if (dwSize == nLength - sizeof(uint16_t) * 2 - sizeof(FX_DWORD) * 2) {
+      if (dwSize == nLength - sizeof(uint16_t) * 2 - sizeof(uint32_t) * 2) {
         for (int32_t i = 0, sz = dwCount; i < sz; i++) {
           if (p > pBuffer + nLength)
             break;
 
-          FX_DWORD dwNameLen = *((FX_DWORD*)p);
-          p += sizeof(FX_DWORD);
+          uint32_t dwNameLen = *((uint32_t*)p);
+          p += sizeof(uint32_t);
 
           if (p + dwNameLen > pBuffer + nLength)
             break;
 
           CFX_ByteString sEntry = CFX_ByteString(p, dwNameLen);
           p += sizeof(char) * dwNameLen;
 
           uint16_t wDataType = *((uint16_t*)p);
           p += sizeof(uint16_t);
 
           switch (wDataType) {
             case JS_GLOBALDATA_TYPE_NUMBER: {
               double dData = 0;
               switch (wVersion) {
                 case 1: {
-                  FX_DWORD dwData = *((FX_DWORD*)p);
-                  p += sizeof(FX_DWORD);
+                  uint32_t dwData = *((uint32_t*)p);
+                  p += sizeof(uint32_t);
                   dData = dwData;
                 } break;
                 case 2: {
                   dData = *((double*)p);
                   p += sizeof(double);
                 } break;
               }
               SetGlobalVariableNumber(sEntry, dData);
               SetGlobalVariablePersistent(sEntry, TRUE);
             } break;
             case JS_GLOBALDATA_TYPE_BOOLEAN: {
               uint16_t wData = *((uint16_t*)p);
               p += sizeof(uint16_t);
               SetGlobalVariableBoolean(sEntry, (bool)(wData == 1));
               SetGlobalVariablePersistent(sEntry, TRUE);
             } break;
             case JS_GLOBALDATA_TYPE_STRING: {
-              FX_DWORD dwLength = *((FX_DWORD*)p);
-              p += sizeof(FX_DWORD);
+              uint32_t dwLength = *((uint32_t*)p);
+              p += sizeof(uint32_t);
 
               if (p + dwLength > pBuffer + nLength)
                 break;
 
               SetGlobalVariableString(sEntry, CFX_ByteString(p, dwLength));
               SetGlobalVariablePersistent(sEntry, TRUE);
               p += sizeof(char) * dwLength;
             } break;
             case JS_GLOBALDATA_TYPE_NULL: {
               SetGlobalVariableNull(sEntry);
               SetGlobalVariablePersistent(sEntry, TRUE);
             }
           }
         }
       }
     }
     FX_Free(pBuffer);
   }
 }
 
 void CJS_GlobalData::SaveGlobalPersisitentVariables() {
-  FX_DWORD nCount = 0;
+  uint32_t nCount = 0;
   CFX_BinaryBuf sData;
 
   for (int i = 0, sz = m_arrayGlobalData.GetSize(); i < sz; i++) {
     CJS_GlobalData_Element* pElement = m_arrayGlobalData.GetAt(i);
     if (pElement->bPersistent) {
       CFX_BinaryBuf sElement;
       MakeByteString(pElement->data.sKey, &pElement->data, sElement);
 
       if (sData.GetSize() + sElement.GetSize() > JS_MAXGLOBALDATA)
         break;
 
       sData.AppendBlock(sElement.GetBuffer(), sElement.GetSize());
       nCount++;
     }
   }
 
   CFX_BinaryBuf sFile;
 
   uint16_t wType = (uint16_t)(('X' << 8) | 'F');
   sFile.AppendBlock(&wType, sizeof(uint16_t));
   uint16_t wVersion = 2;
   sFile.AppendBlock(&wVersion, sizeof(uint16_t));
-  sFile.AppendBlock(&nCount, sizeof(FX_DWORD));
-  FX_DWORD dwSize = sData.GetSize();
-  sFile.AppendBlock(&dwSize, sizeof(FX_DWORD));
+  sFile.AppendBlock(&nCount, sizeof(uint32_t));
+  uint32_t dwSize = sData.GetSize();
+  sFile.AppendBlock(&dwSize, sizeof(uint32_t));
 
   sFile.AppendBlock(sData.GetBuffer(), sData.GetSize());
 
   CRYPT_ArcFourCryptBlock(sFile.GetBuffer(), sFile.GetSize(), JS_RC4KEY,
                           sizeof(JS_RC4KEY));
   WriteFileBuffer(m_sFilePath.c_str(), (const FX_CHAR*)sFile.GetBuffer(),
                   sFile.GetSize());
 }
 
 void CJS_GlobalData::LoadFileBuffer(const FX_WCHAR* sFilePath,
                                     uint8_t*& pBuffer,
                                     int32_t& nLength) {
   // UnSupport.
 }
 
 void CJS_GlobalData::WriteFileBuffer(const FX_WCHAR* sFilePath,
                                      const FX_CHAR* pBuffer,
                                      int32_t nLength) {
   // UnSupport.
 }
 
 void CJS_GlobalData::MakeByteString(const CFX_ByteString& name,
                                     CJS_KeyValue* pData,
                                     CFX_BinaryBuf& sData) {
   uint16_t wType = (uint16_t)pData->nType;
   switch (wType) {
     case JS_GLOBALDATA_TYPE_NUMBER: {
-      FX_DWORD dwNameLen = (FX_DWORD)name.GetLength();
-      sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD));
+      uint32_t dwNameLen = (uint32_t)name.GetLength();
+      sData.AppendBlock(&dwNameLen, sizeof(uint32_t));
       sData.AppendString(name);
       sData.AppendBlock(&wType, sizeof(uint16_t));
 
       double dData = pData->dData;
       sData.AppendBlock(&dData, sizeof(double));
     } break;
     case JS_GLOBALDATA_TYPE_BOOLEAN: {
-      FX_DWORD dwNameLen = (FX_DWORD)name.GetLength();
-      sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD));
+      uint32_t dwNameLen = (uint32_t)name.GetLength();
+      sData.AppendBlock(&dwNameLen, sizeof(uint32_t));
       sData.AppendString(name);
       sData.AppendBlock(&wType, sizeof(uint16_t));
 
       uint16_t wData = (uint16_t)pData->bData;
       sData.AppendBlock(&wData, sizeof(uint16_t));
     } break;
     case JS_GLOBALDATA_TYPE_STRING: {
-      FX_DWORD dwNameLen = (FX_DWORD)name.GetLength();
-      sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD));
+      uint32_t dwNameLen = (uint32_t)name.GetLength();
+      sData.AppendBlock(&dwNameLen, sizeof(uint32_t));
       sData.AppendString(name);
       sData.AppendBlock(&wType, sizeof(uint16_t));
 
-      FX_DWORD dwDataLen = (FX_DWORD)pData->sData.GetLength();
-      sData.AppendBlock(&dwDataLen, sizeof(FX_DWORD));
+      uint32_t dwDataLen = (uint32_t)pData->sData.GetLength();
+      sData.AppendBlock(&dwDataLen, sizeof(uint32_t));
       sData.AppendString(pData->sData);
     } break;
     case JS_GLOBALDATA_TYPE_NULL: {
-      FX_DWORD dwNameLen = (FX_DWORD)name.GetLength();
-      sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD));
+      uint32_t dwNameLen = (uint32_t)name.GetLength();
+      sData.AppendBlock(&dwNameLen, sizeof(uint32_t));
       sData.AppendString(name);
-      sData.AppendBlock(&wType, sizeof(FX_DWORD));
+      sData.AppendBlock(&wType, sizeof(uint32_t));
     } break;
     default:
       break;
   }
 }