Cleanup: Use uint8_t type throughout in the 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 <stddef.h>
-#include <stdint.h>
 
 namespace {
 
 struct Context {
   uint32_t buf[4];
   uint32_t bits[2];
-  unsigned char in[64];
+  uint8_t in[64];
 };
 
 /*
  * Note: this code is harmless on little-endian machines.
  */
-void byteReverse(unsigned char *buf, unsigned longs) {
+void byteReverse(uint8_t* buf, unsigned longs) {
   uint32_t t;
   do {
     t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 |
         ((unsigned)buf[1] << 8 | buf[0]);
     *(uint32_t*)buf = t;
     buf += 4;
   } while (--longs);
 }
 
 /* The four core functions - F1 is optimized somewhat */
@@ skipping 111 matching lines @@
   ctx->buf[3] = 0x10325476;
   ctx->bits[0] = 0;
   ctx->bits[1] = 0;
 }
 
 /*
  * 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();
+  const uint8_t* inbuf = (const uint8_t*)data.data();
   size_t len = data.size();
   struct Context* ctx = (struct Context*)context;
-  const unsigned char* buf = (const unsigned char*)inbuf;
+  const uint8_t* buf = (const uint8_t*)inbuf;
   uint32_t t;
 
   /* Update bitcount */
 
   t = ctx->bits[0];
   if ((ctx->bits[0] = t + ((uint32_t)len << 3)) < t)
     ctx->bits[1]++; /* Carry from low to high */
   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;
+    uint8_t* p = (uint8_t*)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_t*)ctx->in);
     buf += t;
@@ skipping 15 matching lines @@
   memcpy(ctx->in, buf, len);
 }
 
 /*
  * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 void MD5Final(MD5Digest* digest, MD5Context* context) {
   struct Context* ctx = (struct Context*)context;
   unsigned count;
-  unsigned char* p;
+  uint8_t* p;
 
   /* Compute number of bytes mod 64 */
   count = (ctx->bits[0] >> 3) & 0x3F;
 
   /* Set the first char of padding to 0x80.  This is safe since there is
      always at least one byte free */
   p = ctx->in + count;
   *p++ = 0x80;
 
   /* Bytes of padding needed to make 64 bytes */
@@ skipping 14 matching lines @@
   }
   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_t*)ctx->in);
-  byteReverse((unsigned char*)ctx->buf, 4);
+  byteReverse((uint8_t*)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));
   MD5Final(digest, &context_copy);
@@ skipping 21 matching lines @@
   MD5Final(digest, &ctx);
 }
 
 std::string MD5String(const StringPiece& str) {
   MD5Digest digest;
   MD5Sum(str.data(), str.length(), &digest);
   return MD5DigestToBase16(digest);
 }
 
 }  // namespace base