[blimp] Change to use SHA-256 instead of SHA-1 for unique ids

blimp/common/compositor/webp_decoder.cc

 // Copyright 2016 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.
 
 #include "blimp/common/compositor/webp_decoder.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"

[Wez, 2016/04/23 00:08:52]

Do we use string_util.h in here?

[nyquist, 2016/04/25 08:11:17]

Done.

 #include "blimp/common/blob_cache/blob_cache.h"
 #include "blimp/common/blob_cache/id_util.h"
 #include "blimp/common/blob_cache/in_memory_blob_cache.h"
 #include "blimp/common/proto/blob_cache.pb.h"
 #include "third_party/libwebp/webp/decode.h"
 #include "third_party/libwebp/webp/demux.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace blimp {
 namespace {
@@ skipping 14 matching lines @@
     return false;
   }
 
   BlobCacheImageMetadata deserialized;
   int signed_size = base::checked_cast<int>(input_size);
   if (!deserialized.ParseFromArray(input, signed_size)) {
     LOG(WARNING) << "Failed to parse BlobCacheImageMetadata";
     return false;
   }
 
-  // The cache uses the SHA1 hex string of the ID.
-  if (deserialized.id().length() != base::kSHA1Length) {
-    LOG(WARNING) << "Length of ID is not base::kSHA1Length ("
-                 << base::kSHA1Length << "), but "
+  if (!BlobIdHasCorrectLength(BlobId(deserialized.id()))) {
+    LOG(WARNING) << "Length of ID is not correct "
                  << deserialized.id().length();
     return false;
   }
   std::string hex_id = FormatBlobId(deserialized.id());
 
   // Declared here to still be in scope while decoding WebP data.
   BlobDataPtr cached;
 
   // Set to true if the client already has the data in its cache. If it does not
   // keeping |found_in_cache| as false will trigger caching the input in the
   // end of this function.
   bool found_in_cache = false;
 
   // Used later to decode the image and is initialized either based on a cached
   // item or from the |payload| of the proto.
   WebPData webp_data;
 
   if (g_blob_cache.Get().Contains(deserialized.id())) {
     // The image was found in the cache, so decode using cached data.
     cached = g_blob_cache.Get().Get(deserialized.id());
     webp_data.bytes = reinterpret_cast<const uint8_t*>(cached->data.data());
     webp_data.size = cached->data.size();
-    DVLOG(2) << "Found SHA1 " << hex_id << " with size = " << webp_data.size;
+    DVLOG(2) << "Found id " << hex_id << " with size = " << webp_data.size;
     found_in_cache = true;
   } else {
     // The image was not found in the cache, so decode using the payload.
     DCHECK(deserialized.has_payload());
     webp_data.bytes =
         reinterpret_cast<const uint8_t*>(deserialized.payload().c_str());
     webp_data.size = deserialized.payload().size();
   }
 
   // Read WebP feature information into |config.input|, which is a
@@ skipping 38 matching lines @@
   // Now free the buffer. It is safe to call this even when the buffer is
   // external and not allocated by WebPDecode.
   WebPFreeDecBuffer(&config.output);
 
   if (!success) {
     LOG(WARNING) << "Failed to decode WebP data.";
     return false;
   }
 
   if (!found_in_cache) {
-    DVLOG(2) << "Inserting image to cache with SHA1: " << hex_id
+    DVLOG(2) << "Inserting image to cache with id: " << hex_id
              << " size: " << webp_data.size;
     BlobDataPtr to_cache(new BlobData(std::string(
         reinterpret_cast<const char*>(webp_data.bytes), webp_data.size)));
     g_blob_cache.Get().Put(deserialized.id(), std::move(to_cache));
   }
 
   return true;
 }
 
 }  // namespace blimp