Use the types from stdint.h in MD5 API.

base/md5.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The original file was copied from sqlite, and was in the public domain.
 
 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest.  This code was
  * written by Colin Plumb in 1993, no copyright is claimed.
  * This code is in the public domain; do with it what you wish.
  *
  * Equivalent code is available from RSA Data Security, Inc.
  * This code has been tested against that, and is equivalent,
  * except that you don't need to include two pages of legalese
  * with every copy.
  *
  * To compute the message digest of a chunk of bytes, declare an
  * MD5Context structure, pass it to MD5Init, call MD5Update as
  * needed on buffers full of bytes, and then call MD5Final, which
  * will fill a supplied 16-byte array with the digest.
  */
 
 #include "base/md5.h"
 
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
 
 namespace {
 
 struct Context {
-  uint32 buf[4];
-  uint32 bits[2];
+  uint32_t buf[4];
+  uint32_t bits[2];
   unsigned char in[64];
 };
 
 /*
  * Note: this code is harmless on little-endian machines.
  */
 void byteReverse(unsigned char *buf, unsigned longs) {
-        uint32 t;
+        uint32_t t;
         do {
-                t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
-                            ((unsigned)buf[1]<<8 | buf[0]);
-                *(uint32 *)buf = t;
-                buf += 4;
+          t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 |

[Nico, 2015/04/01 17:38:40]

Hm, running clang-format on files that aren't clang-formatted is weird. Now the
inner block has an indent of 2 whikle the rest of the file uses an indent of 8.

[tfarina, 2015/04/01 17:57:48]

I'm open to do anything you prefer. I think we have some options here. Just let
me know and I will upload another patch. Sorry for not realizing you were not
asking me to run clang-format :/

1- go back to 8 spaces with indentation fixed.
2- clang-format the whole file (I agree this is worse).
3- make this function 2 spaces indented.

WebRTC's MD5 implementation seems to have indented everything 2 spaces:
https://chromium.googlesource.com/external/webrtc/+/master/webrtc/base/md5.cc

+              ((unsigned)buf[1] << 8 | buf[0]);
+          *(uint32_t*)buf = t;
+          buf += 4;
         } while (--longs);
 }
 
 /* The four core functions - F1 is optimized somewhat */
 
 /* #define F1(x, y, z) (x & y | ~x & z) */
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 #define F2(x, y, z) F1(z, x, y)
 #define F3(x, y, z) (x ^ y ^ z)
 #define F4(x, y, z) (y ^ (x | ~z))
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
  * reflect the addition of 16 longwords of new data.  MD5Update blocks
  * the data and converts bytes into longwords for this routine.
  */
-void MD5Transform(uint32 buf[4], const uint32 in[16]) {
-        register uint32 a, b, c, d;
+void MD5Transform(uint32_t buf[4], const uint32_t in[16]) {
+        uint32_t a, b, c, d;
 
         a = buf[0];
         b = buf[1];
         c = buf[2];
         d = buf[3];
 
         MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
         MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
         MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
         MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
@@ skipping 87 matching lines @@
 
 /*
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
 void MD5Update(MD5Context* context, const StringPiece& data) {
         const unsigned char* inbuf = (const unsigned char*)data.data();
         size_t len = data.size();
         struct Context *ctx = (struct Context *)context;
         const unsigned char* buf = (const unsigned char*)inbuf;
-        uint32 t;
+        uint32_t t;
 
         /* Update bitcount */
 
         t = ctx->bits[0];
-        if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
+        if ((ctx->bits[0] = t + ((uint32_t)len << 3)) < t)
                 ctx->bits[1]++; /* Carry from low to high */
-        ctx->bits[1] += static_cast<uint32>(len >> 29);
+        ctx->bits[1] += static_cast<uint32_t>(len >> 29);
 
         t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
 
         /* Handle any leading odd-sized chunks */
 
         if (t) {
                 unsigned char *p = (unsigned char *)ctx->in + t;
 
                 t = 64-t;
                 if (len < t) {
                         memcpy(p, buf, len);
                         return;
                 }
                 memcpy(p, buf, t);
                 byteReverse(ctx->in, 16);
-                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                MD5Transform(ctx->buf, (uint32_t *)ctx->in);
                 buf += t;
                 len -= t;
         }
 
         /* Process data in 64-byte chunks */
 
         while (len >= 64) {
                 memcpy(ctx->in, buf, 64);
                 byteReverse(ctx->in, 16);
-                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                MD5Transform(ctx->buf, (uint32_t *)ctx->in);
                 buf += 64;
                 len -= 64;
         }
 
         /* Handle any remaining bytes of data. */
 
         memcpy(ctx->in, buf, len);
 }
 
 /*
@@ skipping 14 matching lines @@
         *p++ = 0x80;
 
         /* Bytes of padding needed to make 64 bytes */
         count = 64 - 1 - count;
 
         /* Pad out to 56 mod 64 */
         if (count < 8) {
                 /* Two lots of padding:  Pad the first block to 64 bytes */
                 memset(p, 0, count);
                 byteReverse(ctx->in, 16);
-                MD5Transform(ctx->buf, (uint32 *)ctx->in);
+                MD5Transform(ctx->buf, (uint32_t *)ctx->in);
 
                 /* Now fill the next block with 56 bytes */
                 memset(ctx->in, 0, 56);
         } else {
                 /* Pad block to 56 bytes */
                 memset(p, 0, count-8);
         }
         byteReverse(ctx->in, 14);
 
         /* Append length in bits and transform */
         memcpy(&ctx->in[14 * sizeof(ctx->bits[0])],
                &ctx->bits[0],
                sizeof(ctx->bits[0]));
         memcpy(&ctx->in[15 * sizeof(ctx->bits[1])],
                &ctx->bits[1],
                sizeof(ctx->bits[1]));
 
-        MD5Transform(ctx->buf, (uint32 *)ctx->in);
+        MD5Transform(ctx->buf, (uint32_t *)ctx->in);
         byteReverse((unsigned char *)ctx->buf, 4);
         memcpy(digest->a, ctx->buf, 16);
         memset(ctx, 0, sizeof(*ctx));    /* In case it's sensitive */
 }
 
 void MD5IntermediateFinal(MD5Digest* digest, const MD5Context* context) {
   /* MD5Final mutates the MD5Context*. Make a copy for generating the
      intermediate value. */
   MD5Context context_copy;
   memcpy(&context_copy, context, sizeof(context_copy));
@@ skipping 23 matching lines @@
   MD5Final(digest, &ctx);
 }
 
 std::string MD5String(const StringPiece& str) {
   MD5Digest digest;
   MD5Sum(str.data(), str.length(), &digest);
   return MD5DigestToBase16(digest);
 }
 
 }  // namespace base