SkBitmapHasher: use 64-bit-truncated MD5 instead of 64-bit CityHash

src/utils/SkBitmapHasher.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.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapHasher.h"
-#include "SkCityHash.h"
 #include "SkEndian.h"
 #include "SkImageEncoder.h"
+
+#ifdef BITMAPHASHER_USES_TRUNCATED_MD5
+#include "SkMD5.h"
+#else
+#include "SkCityHash.h"
 #include "SkStream.h"
+#endif
 
 /**
  * Write an integer value to a stream in little-endian order.
  */
 static void write_int_to_buffer(uint32_t val, SkWStream* out) {
     val = SkEndian_SwapLE32(val);
     for (size_t byte = 0; byte < 4; ++byte) {
         out->write8((uint8_t)(val & 0xff));
         val = val >> 8;
     }
 }
 
 /*static*/ bool SkBitmapHasher::ComputeDigestInternal(const SkBitmap& bitmap,
                                                       SkHashDigest *result) {
+#ifdef BITMAPHASHER_USES_TRUNCATED_MD5
+    SkMD5 out;
+#else
     size_t pixelBufferSize = bitmap.width() * bitmap.height() * 4;
     size_t totalBufferSize = pixelBufferSize + 2 * sizeof(uint32_t);
 
     SkAutoMalloc bufferManager(totalBufferSize);
     char *bufferStart = static_cast<char *>(bufferManager.get());
     SkMemoryWStream out(bufferStart, totalBufferSize);
+#endif
 
     // start with the x/y dimensions
     write_int_to_buffer(SkToU32(bitmap.width()), &out);
     write_int_to_buffer(SkToU32(bitmap.height()), &out);
 
     // add all the pixel data
     SkAutoTDelete<SkImageEncoder> enc(CreateARGBImageEncoder());
     if (!enc->encodeStream(&out, bitmap, SkImageEncoder::kDefaultQuality)) {
         return false;
     }
 
+#ifdef BITMAPHASHER_USES_TRUNCATED_MD5
+    SkMD5::Digest digest;
+    out.finish(digest);
+    *result = *((SkHashDigest *)&digest);

[bungeman-skia, 2013/05/03 15:21:00]

While I did write this, I wrote it more as an easy means of testing timings, not
really thinking about correctness. I'm somewhat uncomfortable with the fact that
the value of result will be endian dependent like this. If we know that
SkHashDigest is uint64_t then I would prefer something like

*result = (digest.data[0] << (0*8)) +
          (digest.data[1] << (1*8)) +
          (digest.data[2] << (2*8)) +
          (digest.data[3] << (3*8)) +
          (digest.data[4] << (4*8)) +
          (digest.data[5] << (5*8)) +
          (digest.data[6] << (6*8)) +
          (digest.data[7] << (7*8));

So that we're always looking at digest.data as if it were little endian. This
way the same image will have the same 'result' on big, little, and middle-endian
machines.

[epoger, 2013/05/03 16:28:00]

Good idea, thanks for the catch.  I implemented it a bit differently, in the
hopes of code reuse later. Tell me what you think.

+#else
     *result = SkCityHash::Compute64(bufferStart, totalBufferSize);
+#endif
     return true;
 }
 
 /*static*/ bool SkBitmapHasher::ComputeDigest(const SkBitmap& bitmap, SkHashDigest *result) {
     if (ComputeDigestInternal(bitmap, result)) {
         return true;
     }
 
     // Hmm, that didn't work. Maybe if we create a new
     // kARGB_8888_Config version of the bitmap it will work better?
     SkBitmap copyBitmap;
     if (!bitmap.copyTo(&copyBitmap, SkBitmap::kARGB_8888_Config)) {
         return false;
     }
     return ComputeDigestInternal(copyBitmap, result);
 }