Remove FX_DWORD from core/ and delete definition

core/fdrm/crypto/fx_crypt_sha.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/fdrm/crypto/include/fx_crypt.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ skipping 66 matching lines @@
   digest[2] += c;
   digest[3] += d;
   digest[4] += e;
 }
 void CRYPT_SHA1Start(void* context) {
   SHA_State* s = (SHA_State*)context;
   SHA_Core_Init(s->h);
   s->blkused = 0;
   s->lenhi = s->lenlo = 0;
 }
-void CRYPT_SHA1Update(void* context, const uint8_t* data, FX_DWORD size) {
+void CRYPT_SHA1Update(void* context, const uint8_t* data, uint32_t size) {
   SHA_State* s = (SHA_State*)context;
   unsigned char* q = (unsigned char*)data;
   unsigned int wordblock[16];
   int len = size;
   unsigned int lenw = len;
   int i;
   s->lenlo += lenw;
   s->lenhi += (s->lenlo < lenw);
   if (s->blkused && s->blkused + len < 64) {
     FXSYS_memcpy(s->block + s->blkused, q, len);
@@ skipping 42 matching lines @@
   c[7] = (lenlo >> 0) & 0xFF;
   CRYPT_SHA1Update(s, c, 8);
   for (i = 0; i < 5; i++) {
     digest[i * 4] = (s->h[i] >> 24) & 0xFF;
     digest[i * 4 + 1] = (s->h[i] >> 16) & 0xFF;
     digest[i * 4 + 2] = (s->h[i] >> 8) & 0xFF;
     digest[i * 4 + 3] = (s->h[i]) & 0xFF;
   }
 }
 void CRYPT_SHA1Generate(const uint8_t* data,
-                        FX_DWORD size,
+                        uint32_t size,
                         uint8_t digest[20]) {
   SHA_State s;
   CRYPT_SHA1Start(&s);
   CRYPT_SHA1Update(&s, data, size);
   CRYPT_SHA1Finish(&s, digest);
 }
 typedef struct {
-  FX_DWORD total[2];
-  FX_DWORD state[8];
+  uint32_t total[2];
+  uint32_t state[8];
   uint8_t buffer[64];
 } sha256_context;
 #define GET_FX_DWORD(n, b, i)                                           \
   {                                                                     \
-    (n) = ((FX_DWORD)(b)[(i)] << 24) | ((FX_DWORD)(b)[(i) + 1] << 16) | \
-          ((FX_DWORD)(b)[(i) + 2] << 8) | ((FX_DWORD)(b)[(i) + 3]);     \
+    (n) = ((uint32_t)(b)[(i)] << 24) | ((uint32_t)(b)[(i) + 1] << 16) | \
+          ((uint32_t)(b)[(i) + 2] << 8) | ((uint32_t)(b)[(i) + 3]);     \
   }
 #define PUT_FX_DWORD(n, b, i)            \
   {                                      \
     (b)[(i)] = (uint8_t)((n) >> 24);     \
     (b)[(i) + 1] = (uint8_t)((n) >> 16); \
     (b)[(i) + 2] = (uint8_t)((n) >> 8);  \
     (b)[(i) + 3] = (uint8_t)((n));       \
   }
 void CRYPT_SHA256Start(void* context) {
   sha256_context* ctx = (sha256_context*)context;
   ctx->total[0] = 0;
   ctx->total[1] = 0;
   ctx->state[0] = 0x6A09E667;
   ctx->state[1] = 0xBB67AE85;
   ctx->state[2] = 0x3C6EF372;
   ctx->state[3] = 0xA54FF53A;
   ctx->state[4] = 0x510E527F;
   ctx->state[5] = 0x9B05688C;
   ctx->state[6] = 0x1F83D9AB;
   ctx->state[7] = 0x5BE0CD19;
 }
 static void sha256_process(sha256_context* ctx, const uint8_t data[64]) {
-  FX_DWORD temp1, temp2, W[64];
-  FX_DWORD A, B, C, D, E, F, G, H;
+  uint32_t temp1, temp2, W[64];
+  uint32_t A, B, C, D, E, F, G, H;
   GET_FX_DWORD(W[0], data, 0);
   GET_FX_DWORD(W[1], data, 4);
   GET_FX_DWORD(W[2], data, 8);
   GET_FX_DWORD(W[3], data, 12);
   GET_FX_DWORD(W[4], data, 16);
   GET_FX_DWORD(W[5], data, 20);
   GET_FX_DWORD(W[6], data, 24);
   GET_FX_DWORD(W[7], data, 28);
   GET_FX_DWORD(W[8], data, 32);
   GET_FX_DWORD(W[9], data, 36);
@@ skipping 93 matching lines @@
   P(B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
   ctx->state[0] += A;
   ctx->state[1] += B;
   ctx->state[2] += C;
   ctx->state[3] += D;
   ctx->state[4] += E;
   ctx->state[5] += F;
   ctx->state[6] += G;
   ctx->state[7] += H;
 }
-void CRYPT_SHA256Update(void* context, const uint8_t* input, FX_DWORD length) {
+void CRYPT_SHA256Update(void* context, const uint8_t* input, uint32_t length) {
   sha256_context* ctx = (sha256_context*)context;
-  FX_DWORD left, fill;
+  uint32_t left, fill;
   if (!length) {
     return;
   }
   left = ctx->total[0] & 0x3F;
   fill = 64 - left;
   ctx->total[0] += length;
   ctx->total[0] &= 0xFFFFFFFF;
   if (ctx->total[0] < length) {
     ctx->total[1]++;
   }
@@ skipping 12 matching lines @@
   if (length) {
     FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length);
   }
 }
 static const uint8_t sha256_padding[64] = {
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 void CRYPT_SHA256Finish(void* context, uint8_t digest[32]) {
   sha256_context* ctx = (sha256_context*)context;
-  FX_DWORD last, padn;
-  FX_DWORD high, low;
+  uint32_t last, padn;
+  uint32_t high, low;
   uint8_t msglen[8];
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
   PUT_FX_DWORD(high, msglen, 0);
   PUT_FX_DWORD(low, msglen, 4);
   last = ctx->total[0] & 0x3F;
   padn = (last < 56) ? (56 - last) : (120 - last);
   CRYPT_SHA256Update(ctx, sha256_padding, padn);
   CRYPT_SHA256Update(ctx, msglen, 8);
   PUT_FX_DWORD(ctx->state[0], digest, 0);
   PUT_FX_DWORD(ctx->state[1], digest, 4);
   PUT_FX_DWORD(ctx->state[2], digest, 8);
   PUT_FX_DWORD(ctx->state[3], digest, 12);
   PUT_FX_DWORD(ctx->state[4], digest, 16);
   PUT_FX_DWORD(ctx->state[5], digest, 20);
   PUT_FX_DWORD(ctx->state[6], digest, 24);
   PUT_FX_DWORD(ctx->state[7], digest, 28);
 }
 void CRYPT_SHA256Generate(const uint8_t* data,
-                          FX_DWORD size,
+                          uint32_t size,
                           uint8_t digest[32]) {
   sha256_context ctx;
   CRYPT_SHA256Start(&ctx);
   CRYPT_SHA256Update(&ctx, data, size);
   CRYPT_SHA256Finish(&ctx, digest);
 }
 typedef struct {
   uint64_t total[2];
   uint64_t state[8];
   uint8_t buffer[128];
@@ skipping 169 matching lines @@
   }
   ctx->state[0] += A;
   ctx->state[1] += B;
   ctx->state[2] += C;
   ctx->state[3] += D;
   ctx->state[4] += E;
   ctx->state[5] += F;
   ctx->state[6] += G;
   ctx->state[7] += H;
 }
-void CRYPT_SHA384Update(void* context, const uint8_t* input, FX_DWORD length) {
+void CRYPT_SHA384Update(void* context, const uint8_t* input, uint32_t length) {
   sha384_context* ctx = (sha384_context*)context;
-  FX_DWORD left, fill;
+  uint32_t left, fill;
   if (!length) {
     return;
   }
-  left = (FX_DWORD)ctx->total[0] & 0x7F;
+  left = (uint32_t)ctx->total[0] & 0x7F;
   fill = 128 - left;
   ctx->total[0] += length;
   if (ctx->total[0] < length) {
     ctx->total[1]++;
   }
   if (left && length >= fill) {
     FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, fill);
     sha384_process(ctx, ctx->buffer);
     length -= fill;
     input += fill;
     left = 0;
   }
   while (length >= 128) {
     sha384_process(ctx, input);
     length -= 128;
     input += 128;
   }
   if (length) {
     FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length);
   }
 }
 void CRYPT_SHA384Finish(void* context, uint8_t digest[48]) {
   sha384_context* ctx = (sha384_context*)context;
-  FX_DWORD last, padn;
+  uint32_t last, padn;
   uint8_t msglen[16];
   FXSYS_memset(msglen, 0, 16);
   uint64_t high, low;
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
   PUT_FX_64DWORD(high, msglen, 0);
   PUT_FX_64DWORD(low, msglen, 8);
-  last = (FX_DWORD)ctx->total[0] & 0x7F;
+  last = (uint32_t)ctx->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
   CRYPT_SHA384Update(ctx, sha384_padding, padn);
   CRYPT_SHA384Update(ctx, msglen, 16);
   PUT_FX_64DWORD(ctx->state[0], digest, 0);
   PUT_FX_64DWORD(ctx->state[1], digest, 8);
   PUT_FX_64DWORD(ctx->state[2], digest, 16);
   PUT_FX_64DWORD(ctx->state[3], digest, 24);
   PUT_FX_64DWORD(ctx->state[4], digest, 32);
   PUT_FX_64DWORD(ctx->state[5], digest, 40);
 }
 void CRYPT_SHA384Generate(const uint8_t* data,
-                          FX_DWORD size,
+                          uint32_t size,
                           uint8_t digest[64]) {
   sha384_context context;
   CRYPT_SHA384Start(&context);
   CRYPT_SHA384Update(&context, data, size);
   CRYPT_SHA384Finish(&context, digest);
 }
 void CRYPT_SHA512Start(void* context) {
   if (!context) {
     return;
   }
   sha384_context* ctx = (sha384_context*)context;
   FXSYS_memset(ctx, 0, sizeof(sha384_context));
   ctx->state[0] = FX_ato64i("6a09e667f3bcc908");
   ctx->state[1] = FX_ato64i("bb67ae8584caa73b");
   ctx->state[2] = FX_ato64i("3c6ef372fe94f82b");
   ctx->state[3] = FX_ato64i("a54ff53a5f1d36f1");
   ctx->state[4] = FX_ato64i("510e527fade682d1");
   ctx->state[5] = FX_ato64i("9b05688c2b3e6c1f");
   ctx->state[6] = FX_ato64i("1f83d9abfb41bd6b");
   ctx->state[7] = FX_ato64i("5be0cd19137e2179");
 }
-void CRYPT_SHA512Update(void* context, const uint8_t* data, FX_DWORD size) {
+void CRYPT_SHA512Update(void* context, const uint8_t* data, uint32_t size) {
   CRYPT_SHA384Update(context, data, size);
 }
 void CRYPT_SHA512Finish(void* context, uint8_t digest[64]) {
   sha384_context* ctx = (sha384_context*)context;
-  FX_DWORD last, padn;
+  uint32_t last, padn;
   uint8_t msglen[16];
   FXSYS_memset(msglen, 0, 16);
   uint64_t high, low;
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
   PUT_FX_64DWORD(high, msglen, 0);
   PUT_FX_64DWORD(low, msglen, 8);
-  last = (FX_DWORD)ctx->total[0] & 0x7F;
+  last = (uint32_t)ctx->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
   CRYPT_SHA512Update(ctx, sha384_padding, padn);
   CRYPT_SHA512Update(ctx, msglen, 16);
   PUT_FX_64DWORD(ctx->state[0], digest, 0);
   PUT_FX_64DWORD(ctx->state[1], digest, 8);
   PUT_FX_64DWORD(ctx->state[2], digest, 16);
   PUT_FX_64DWORD(ctx->state[3], digest, 24);
   PUT_FX_64DWORD(ctx->state[4], digest, 32);
   PUT_FX_64DWORD(ctx->state[5], digest, 40);
   PUT_FX_64DWORD(ctx->state[6], digest, 48);
   PUT_FX_64DWORD(ctx->state[7], digest, 56);
 }
 void CRYPT_SHA512Generate(const uint8_t* data,
-                          FX_DWORD size,
+                          uint32_t size,
                           uint8_t digest[64]) {
   sha384_context context;
   CRYPT_SHA512Start(&context);
   CRYPT_SHA512Update(&context, data, size);
   CRYPT_SHA512Finish(&context, digest);
 }
 #ifdef __cplusplus
 };
 #endif