Remove FX_WORD in favor of uint16_t.

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 299 matching lines @@
 
 void CJS_GlobalData::LoadGlobalPersistentVariables() {
   uint8_t* pBuffer = NULL;
   int32_t nLength = 0;
 
   LoadFileBuffer(m_sFilePath.c_str(), pBuffer, nLength);
   CRYPT_ArcFourCryptBlock(pBuffer, nLength, JS_RC4KEY, sizeof(JS_RC4KEY));
 
   if (pBuffer) {
     uint8_t* p = pBuffer;
-    FX_WORD wType = *((FX_WORD*)p);
-    p += sizeof(FX_WORD);
+    uint16_t wType = *((uint16_t*)p);
+    p += sizeof(uint16_t);
 
-    // FX_WORD wTemp = (FX_WORD)(('X' << 8) | 'F');
+    // uint16_t wTemp = (uint16_t)(('X' << 8) | 'F');
 
-    if (wType == (FX_WORD)(('X' << 8) | 'F')) {
-      FX_WORD wVersion = *((FX_WORD*)p);
-      p += sizeof(FX_WORD);
+    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);
 
       FX_DWORD dwSize = *((FX_DWORD*)p);
       p += sizeof(FX_DWORD);
 
-      if (dwSize == nLength - sizeof(FX_WORD) * 2 - sizeof(FX_DWORD) * 2) {
+      if (dwSize == nLength - sizeof(uint16_t) * 2 - sizeof(FX_DWORD) * 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);
 
           if (p + dwNameLen > pBuffer + nLength)
             break;
 
           CFX_ByteString sEntry = CFX_ByteString(p, dwNameLen);
           p += sizeof(char) * dwNameLen;
 
-          FX_WORD wDataType = *((FX_WORD*)p);
-          p += sizeof(FX_WORD);
+          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);
                   dData = dwData;
                 } break;
                 case 2: {
                   dData = *((double*)p);
                   p += sizeof(double);
                 } break;
               }
               SetGlobalVariableNumber(sEntry, dData);
               SetGlobalVariablePersistent(sEntry, TRUE);
             } break;
             case JS_GLOBALDATA_TYPE_BOOLEAN: {
-              FX_WORD wData = *((FX_WORD*)p);
-              p += sizeof(FX_WORD);
+              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);
 
               if (p + dwLength > pBuffer + nLength)
                 break;
 
@@ skipping 26 matching lines @@
       if (sData.GetSize() + sElement.GetSize() > JS_MAXGLOBALDATA)
         break;
 
       sData.AppendBlock(sElement.GetBuffer(), sElement.GetSize());
       nCount++;
     }
   }
 
   CFX_BinaryBuf sFile;
 
-  FX_WORD wType = (FX_WORD)(('X' << 8) | 'F');
-  sFile.AppendBlock(&wType, sizeof(FX_WORD));
-  FX_WORD wVersion = 2;
-  sFile.AppendBlock(&wVersion, sizeof(FX_WORD));
+  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(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) {
-  FX_WORD wType = (FX_WORD)pData->nType;
+  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));
       sData.AppendString(name);
-      sData.AppendBlock(&wType, sizeof(FX_WORD));
+      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));
       sData.AppendString(name);
-      sData.AppendBlock(&wType, sizeof(FX_WORD));
+      sData.AppendBlock(&wType, sizeof(uint16_t));
 
-      FX_WORD wData = (FX_WORD)pData->bData;
-      sData.AppendBlock(&wData, sizeof(FX_WORD));
+      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));
       sData.AppendString(name);
-      sData.AppendBlock(&wType, sizeof(FX_WORD));
+      sData.AppendBlock(&wType, sizeof(uint16_t));
 
       FX_DWORD dwDataLen = (FX_DWORD)pData->sData.GetLength();
       sData.AppendBlock(&dwDataLen, sizeof(FX_DWORD));
       sData.AppendString(pData->sData);
     } break;
     case JS_GLOBALDATA_TYPE_NULL: {
       FX_DWORD dwNameLen = (FX_DWORD)name.GetLength();
       sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD));
       sData.AppendString(name);
       sData.AppendBlock(&wType, sizeof(FX_DWORD));
     } break;
     default:
       break;
   }
 }