Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_parser/cpdf_standard_crypto_handler.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_parser/cpdf_standard_crypto_handler.h"
 
 #include <time.h>
 
 #include "core/fdrm/crypto/include/fx_crypt.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_parser.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
 #include "core/fpdfapi/fpdf_parser/ipdf_security_handler.h"
 
 IPDF_CryptoHandler::~IPDF_CryptoHandler() {}
 
-void IPDF_CryptoHandler::Decrypt(FX_DWORD objnum,
-                                 FX_DWORD gennum,
+void IPDF_CryptoHandler::Decrypt(uint32_t objnum,
+                                 uint32_t gennum,
                                  CFX_ByteString& str) {
   CFX_BinaryBuf dest_buf;
   void* context = DecryptStart(objnum, gennum);
   DecryptStream(context, (const uint8_t*)str, str.GetLength(), dest_buf);
   DecryptFinish(context, dest_buf);
   str = dest_buf;
 }
 
 void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt,
-                                            FX_DWORD objnum,
-                                            FX_DWORD gennum,
+                                            uint32_t objnum,
+                                            uint32_t gennum,
                                             const uint8_t* src_buf,
-                                            FX_DWORD src_size,
+                                            uint32_t src_size,
                                             uint8_t* dest_buf,
-                                            FX_DWORD& dest_size) {
+                                            uint32_t& dest_size) {
   if (m_Cipher == FXCIPHER_NONE) {
     FXSYS_memcpy(dest_buf, src_buf, src_size);
     return;
   }
   uint8_t realkey[16];
   int realkeylen = 16;
   if (m_Cipher != FXCIPHER_AES || m_KeyLen != 32) {
     uint8_t key1[32];
     FXSYS_memcpy(key1, m_EncryptKey, m_KeyLen);
     key1[m_KeyLen + 0] = (uint8_t)objnum;
@@ skipping 44 matching lines @@
       FXSYS_memcpy(dest_buf, src_buf, src_size);
     }
     CRYPT_ArcFourCryptBlock(dest_buf, dest_size, realkey, realkeylen);
   }
 }
 
 struct AESCryptContext {
   uint8_t m_Context[2048];
   FX_BOOL m_bIV;
   uint8_t m_Block[16];
-  FX_DWORD m_BlockOffset;
+  uint32_t m_BlockOffset;
 };
 
-void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum,
-                                             FX_DWORD gennum,
+void* CPDF_StandardCryptoHandler::CryptStart(uint32_t objnum,
+                                             uint32_t gennum,
                                              FX_BOOL bEncrypt) {
   if (m_Cipher == FXCIPHER_NONE) {
     return this;
   }
   if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {
     AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
     pContext->m_bIV = TRUE;
     pContext->m_BlockOffset = 0;
     CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);
     if (bEncrypt) {
@@ skipping 30 matching lines @@
       CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
     }
     return pContext;
   }
   void* pContext = FX_Alloc(uint8_t, 1040);
   CRYPT_ArcFourSetup(pContext, realkey, realkeylen);
   return pContext;
 }
 FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context,
                                                 const uint8_t* src_buf,
-                                                FX_DWORD src_size,
+                                                uint32_t src_size,
                                                 CFX_BinaryBuf& dest_buf,
                                                 FX_BOOL bEncrypt) {
   if (!context) {
     return FALSE;
   }
   if (m_Cipher == FXCIPHER_NONE) {
     dest_buf.AppendBlock(src_buf, src_size);
     return TRUE;
   }
   if (m_Cipher == FXCIPHER_RC4) {
     int old_size = dest_buf.GetSize();
     dest_buf.AppendBlock(src_buf, src_size);
     CRYPT_ArcFourCrypt(context, dest_buf.GetBuffer() + old_size, src_size);
     return TRUE;
   }
   AESCryptContext* pContext = (AESCryptContext*)context;
   if (pContext->m_bIV && bEncrypt) {
     dest_buf.AppendBlock(pContext->m_Block, 16);
     pContext->m_bIV = FALSE;
   }
-  FX_DWORD src_off = 0;
-  FX_DWORD src_left = src_size;
+  uint32_t src_off = 0;
+  uint32_t src_left = src_size;
   while (1) {
-    FX_DWORD copy_size = 16 - pContext->m_BlockOffset;
+    uint32_t copy_size = 16 - pContext->m_BlockOffset;
     if (copy_size > src_left) {
       copy_size = src_left;
     }
     FXSYS_memcpy(pContext->m_Block + pContext->m_BlockOffset, src_buf + src_off,
                  copy_size);
     src_off += copy_size;
     src_left -= copy_size;
     pContext->m_BlockOffset += copy_size;
     if (pContext->m_BlockOffset == 16) {
       if (!bEncrypt && pContext->m_bIV) {
@@ skipping 48 matching lines @@
   } else if (pContext->m_BlockOffset == 16) {
     uint8_t block_buf[16];
     CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, 16);
     if (block_buf[15] <= 16) {
       dest_buf.AppendBlock(block_buf, 16 - block_buf[15]);
     }
   }
   FX_Free(pContext);
   return TRUE;
 }
-void* CPDF_StandardCryptoHandler::DecryptStart(FX_DWORD objnum,
-                                               FX_DWORD gennum) {
+void* CPDF_StandardCryptoHandler::DecryptStart(uint32_t objnum,
+                                               uint32_t gennum) {
   return CryptStart(objnum, gennum, FALSE);
 }
-FX_DWORD CPDF_StandardCryptoHandler::DecryptGetSize(FX_DWORD src_size) {
+uint32_t CPDF_StandardCryptoHandler::DecryptGetSize(uint32_t src_size) {
   return m_Cipher == FXCIPHER_AES ? src_size - 16 : src_size;
 }
 
 FX_BOOL CPDF_StandardCryptoHandler::Init(
     CPDF_Dictionary* pEncryptDict,
     IPDF_SecurityHandler* pSecurityHandler) {
   const uint8_t* key;
   if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) {
     return FALSE;
   }
@@ skipping 37 matching lines @@
   m_Cipher = cipher;
   m_KeyLen = keylen;
   FXSYS_memcpy(m_EncryptKey, key, keylen);
   if (m_Cipher == FXCIPHER_AES) {
     m_pAESContext = FX_Alloc(uint8_t, 2048);
   }
   return TRUE;
 }
 FX_BOOL CPDF_StandardCryptoHandler::DecryptStream(void* context,
                                                   const uint8_t* src_buf,
-                                                  FX_DWORD src_size,
+                                                  uint32_t src_size,
                                                   CFX_BinaryBuf& dest_buf) {
   return CryptStream(context, src_buf, src_size, dest_buf, FALSE);
 }
 FX_BOOL CPDF_StandardCryptoHandler::DecryptFinish(void* context,
                                                   CFX_BinaryBuf& dest_buf) {
   return CryptFinish(context, dest_buf, FALSE);
 }
-FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum,
-                                                    FX_DWORD version,
+uint32_t CPDF_StandardCryptoHandler::EncryptGetSize(uint32_t objnum,
+                                                    uint32_t version,
                                                     const uint8_t* src_buf,
-                                                    FX_DWORD src_size) {
+                                                    uint32_t src_size) {
   if (m_Cipher == FXCIPHER_AES) {
     return src_size + 32;
   }
   return src_size;
 }
-FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum,
-                                                   FX_DWORD gennum,
+FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(uint32_t objnum,
+                                                   uint32_t gennum,
                                                    const uint8_t* src_buf,
-                                                   FX_DWORD src_size,
+                                                   uint32_t src_size,
                                                    uint8_t* dest_buf,
-                                                   FX_DWORD& dest_size) {
+                                                   uint32_t& dest_size) {
   CryptBlock(TRUE, objnum, gennum, src_buf, src_size, dest_buf, dest_size);
   return TRUE;
 }
 CPDF_StandardCryptoHandler::CPDF_StandardCryptoHandler() {
   m_pAESContext = NULL;
   m_Cipher = FXCIPHER_NONE;
   m_KeyLen = 0;
 }
 CPDF_StandardCryptoHandler::~CPDF_StandardCryptoHandler() {
   FX_Free(m_pAESContext);
 }