Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/sha1.cc

 /*
  * SHA-1 in C
  * By Steve Reid <sreid@sea-to-sky.net>
  * 100% Public Domain
  *
  * -----------------
  * Modified 7/98
  * By James H. Brown <jbrown@burgoyne.com>
  * Still 100% Public Domain
  *
@@ skipping 57 matching lines @@
  * -----------------
  * Modified 02/2012
  * By Justin Uberti <juberti@google.com>
  * Remove underscore from SHA1 prefix to avoid conflict with OpenSSL
  * Remove test code
  * Untabify
  *
  * -----------------
  * Modified 03/2012
  * By Ronghua Wu <ronghuawu@google.com>
- * Change the typedef of uint32(8)_t to uint32(8). We need this because in the
+ * Change the typedef of uint32_t(8)_t to uint32_t(8). We need this because in

[Henrik Grunell WebRTC, 2015/10/05 12:00:19]

Don't change the change log. :)

[pbos-webrtc, 2015/10/05 12:23:23]

Oops, thanks!

+ *the
  * chromium android build, the stdio.h will include stdint.h which already
- * defined uint32(8)_t.
+ * defined uint32_t(8)_t.
  *
  * -----------------
  * Modified 04/2012
  * By Frank Barchard <fbarchard@google.com>
  * Ported to C++, Google style, change len to size_t, enable SHA1HANDSOFF
  *
  * Test Vectors (from FIPS PUB 180-1)
  * "abc"
  *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  * A million repetitions of "a"
  *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
  *
  * -----------------
  * Modified 05/2015
  * By Sergey Ulanov <sergeyu@chromium.org>
  * Removed static buffer to make computation thread-safe.
  */

[Henrik Grunell WebRTC, 2015/10/05 12:00:20]

Add an entry here with your modification.

[pbos-webrtc, 2015/10/05 12:23:23]

Done.

 
 // Enabling SHA1HANDSOFF preserves the caller's data buffer.
 // Disabling SHA1HANDSOFF the buffer will be modified (end swapped).
 #define SHA1HANDSOFF
 
 #include "webrtc/base/sha1.h"
 
 #include <stdio.h>
 #include <string.h>
 
@@ skipping 39 matching lines @@
          context->count[0], context->count[1],
          context->state[0],
          context->state[1],
          context->state[2],
          context->state[3],
          context->state[4]);
 }
 #endif /* VERBOSE */
 
 // Hash a single 512-bit block. This is the core of the algorithm.
-void SHA1Transform(uint32 state[5], const uint8 buffer[64]) {
+void SHA1Transform(uint32_t state[5], const uint8_t buffer[64]) {
   union CHAR64LONG16 {
-    uint8 c[64];
-    uint32 l[16];
+    uint8_t c[64];
+    uint32_t l[16];
   };
 #ifdef SHA1HANDSOFF
-  uint8 workspace[64];
+  uint8_t workspace[64];
   memcpy(workspace, buffer, 64);
   CHAR64LONG16* block = reinterpret_cast<CHAR64LONG16*>(workspace);
 #else
   // Note(fbarchard): This option does modify the user's data buffer.
   CHAR64LONG16* block = const_cast<CHAR64LONG16*>(
       reinterpret_cast<const CHAR64LONG16*>(buffer));
 #endif
 
   // Copy context->state[] to working vars.
-  uint32 a = state[0];
-  uint32 b = state[1];
-  uint32 c = state[2];
-  uint32 d = state[3];
-  uint32 e = state[4];
+  uint32_t a = state[0];
+  uint32_t b = state[1];
+  uint32_t c = state[2];
+  uint32_t d = state[3];
+  uint32_t e = state[4];
 
   // 4 rounds of 20 operations each. Loop unrolled.
   // Note(fbarchard): The following has lint warnings for multiple ; on
   // a line and no space after , but is left as-is to be similar to the
   // original code.
   R0(a,b,c,d,e,0); R0(e,a,b,c,d,1); R0(d,e,a,b,c,2); R0(c,d,e,a,b,3);
   R0(b,c,d,e,a,4); R0(a,b,c,d,e,5); R0(e,a,b,c,d,6); R0(d,e,a,b,c,7);
   R0(c,d,e,a,b,8); R0(b,c,d,e,a,9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
   R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
   R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
@@ skipping 28 matching lines @@
   // SHA1 initialization constants.
   context->state[0] = 0x67452301;
   context->state[1] = 0xEFCDAB89;
   context->state[2] = 0x98BADCFE;
   context->state[3] = 0x10325476;
   context->state[4] = 0xC3D2E1F0;
   context->count[0] = context->count[1] = 0;
 }
 
 // Run your data through this.
-void SHA1Update(SHA1_CTX* context, const uint8* data, size_t input_len) {
+void SHA1Update(SHA1_CTX* context, const uint8_t* data, size_t input_len) {
   size_t i = 0;
 
 #ifdef VERBOSE
   SHAPrintContext(context, "before");
 #endif
 
   // Compute number of bytes mod 64.
   size_t index = (context->count[0] >> 3) & 63;
 
   // Update number of bits.
-  // TODO: Use uint64 instead of 2 uint32 for count.
+  // TODO: Use uint64_t instead of 2 uint32_t for count.
   // count[0] has low 29 bits for byte count + 3 pad 0's making 32 bits for
   // bit count.
-  // Add bit count to low uint32
-  context->count[0] += static_cast<uint32>(input_len << 3);
-  if (context->count[0] < static_cast<uint32>(input_len << 3)) {
+  // Add bit count to low uint32_t
+  context->count[0] += static_cast<uint32_t>(input_len << 3);
+  if (context->count[0] < static_cast<uint32_t>(input_len << 3)) {
     ++context->count[1];  // if overlow (carry), add one to high word
   }
-  context->count[1] += static_cast<uint32>(input_len >> 29);
+  context->count[1] += static_cast<uint32_t>(input_len >> 29);
   if ((index + input_len) > 63) {
     i = 64 - index;
     memcpy(&context->buffer[index], data, i);
     SHA1Transform(context->state, context->buffer);
     for (; i + 63 < input_len; i += 64) {
       SHA1Transform(context->state, data + i);
     }
     index = 0;
   }
   memcpy(&context->buffer[index], &data[i], input_len - i);
 
 #ifdef VERBOSE
   SHAPrintContext(context, "after ");
 #endif
 }
 
 // Add padding and return the message digest.
-void SHA1Final(SHA1_CTX* context, uint8 digest[SHA1_DIGEST_SIZE]) {
-  uint8 finalcount[8];
+void SHA1Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]) {
+  uint8_t finalcount[8];
   for (int i = 0; i < 8; ++i) {
     // Endian independent
-    finalcount[i] = static_cast<uint8>(
-        (context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8) ) & 255);
+    finalcount[i] = static_cast<uint8_t>(
+        (context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255);
   }
-  SHA1Update(context, reinterpret_cast<const uint8*>("\200"), 1);
+  SHA1Update(context, reinterpret_cast<const uint8_t*>("\200"), 1);
   while ((context->count[0] & 504) != 448) {
-    SHA1Update(context, reinterpret_cast<const uint8*>("\0"), 1);
+    SHA1Update(context, reinterpret_cast<const uint8_t*>("\0"), 1);
   }
   SHA1Update(context, finalcount, 8);  // Should cause a SHA1Transform().
   for (int i = 0; i < SHA1_DIGEST_SIZE; ++i) {
-    digest[i] = static_cast<uint8>(
-        (context->state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
+    digest[i] = static_cast<uint8_t>(
+        (context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
   }
 
   // Wipe variables.
   memset(context->buffer, 0, 64);
   memset(context->state, 0, 20);
   memset(context->count, 0, 8);
   memset(finalcount, 0, 8);   // SWR
 
 #ifdef SHA1HANDSOFF  // Make SHA1Transform overwrite its own static vars.
   SHA1Transform(context->state, context->buffer);
 #endif
 }
 
 }  // namespace rtc