SkMD5: cleanup header and minor refactor

src/core/SkMD5.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * The following code is based on the description in RFC 1321.
  * http://www.ietf.org/rfc/rfc1321.txt
  */
 
-#include "SkTypes.h"
+//The following macros can be defined to affect the MD5 code generated.
+//SK_MD5_CLEAR_DATA causes all intermediate state to be overwritten with 0's.
+//SK_CPU_LENDIAN allows 32 bit <=> 8 bit conversions without copies (if alligned).
+//SK_CPU_FAST_UNALIGNED_ACCESS allows 32 bit <=> 8 bit conversions without copies if SK_CPU_LENDIAN.
+
 #include "SkMD5.h"
 #include <string.h>
 
 /** MD5 basic transformation. Transforms state based on block. */
 static void transform(uint32_t state[4], const uint8_t block[64]);
 
 /** Encodes input into output (4 little endian 32 bit values). */
 static void encode(uint8_t output[16], const uint32_t input[4]);
 
 /** Encodes input into output (little endian 64 bit value). */
 static void encode(uint8_t output[8], const uint64_t input);
 
 /** Decodes input (4 little endian 32 bit values) into storage, if required. */
 static const uint32_t* decode(uint32_t storage[16], const uint8_t input[64]);
 
 SkMD5::SkMD5() : byteCount(0) {
     // These are magic numbers from the specification.
     this->state[0] = 0x67452301;
     this->state[1] = 0xefcdab89;
     this->state[2] = 0x98badcfe;
     this->state[3] = 0x10325476;
 }
 
-void SkMD5::update(const uint8_t* input, size_t inputLength) {
+// Note that this treats the buffer as a series of uint8_t values.

[tomhudson, 2016/04/22 13:35:59]

Not sure this comment is helpful - it's sitting here right next to the code that
does the reinterpretation, which isn't very complex. Why should the user care?
Who needs to know?

Maybe this (or something like it - not sure why the reinterpret is really
important enough to matter) belongs in the header, or maybe it belongs in
/dev/null?

[hal.canary, 2016/04/22 14:13:15]

Done.

+bool SkMD5::write(const void* buf, size_t inputLength) {
+    const uint8_t* input = reinterpret_cast<const uint8_t*>(buf);
     unsigned int bufferIndex = (unsigned int)(this->byteCount & 0x3F);
     unsigned int bufferAvailable = 64 - bufferIndex;
 
     unsigned int inputIndex;
     if (inputLength >= bufferAvailable) {
         if (bufferIndex) {
             memcpy(&this->buffer[bufferIndex], input, bufferAvailable);
             transform(this->state, this->buffer);
             inputIndex = bufferAvailable;
         } else {
             inputIndex = 0;
         }
 
         for (; inputIndex + 63 < inputLength; inputIndex += 64) {
             transform(this->state, &input[inputIndex]);
         }
 
         bufferIndex = 0;
     } else {
         inputIndex = 0;
     }
 
     memcpy(&this->buffer[bufferIndex], &input[inputIndex], inputLength - inputIndex);
 
     this->byteCount += inputLength;
+    return true;
 }
 
 void SkMD5::finish(Digest& digest) {
     // Get the number of bits before padding.
     uint8_t bits[8];
     encode(bits, this->byteCount << 3);
 
     // Pad out to 56 mod 64.
     unsigned int bufferIndex = (unsigned int)(this->byteCount & 0x3F);
     unsigned int paddingLength = (bufferIndex < 56) ? (56 - bufferIndex) : (120 - bufferIndex);
@@ skipping 172 matching lines @@
 #endif
     for (size_t i = 0, j = 0; j < 64; i++, j += 4) {
         storage[i] =  ((uint32_t)input[j  ])        |
                      (((uint32_t)input[j+1]) <<  8) |
                      (((uint32_t)input[j+2]) << 16) |
                      (((uint32_t)input[j+3]) << 24);
     }
     return storage;
 #endif
 }