MD5Update function uses StringPiece instead of raw buffer.

chrome/browser/safe_browsing/prefix_set.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.
 
 #include "chrome/browser/safe_browsing/prefix_set.h"
 
 #include <algorithm>
 #include <math.h>
 
 #include "base/file_util.h"
@@ skipping 174 matching lines @@
 
   // Check for bogus sizes before allocating any space.
   const size_t expected_bytes =
       sizeof(header) + index_bytes + deltas_bytes + sizeof(MD5Digest);
   if (static_cast<int64>(expected_bytes) != size_64)
     return NULL;
 
   // The file looks valid, start building the digest.
   base::MD5Context context;
   base::MD5Init(&context);
-  base::MD5Update(&context, &header, sizeof(header));
+  base::MD5Update(&context, base::StringPiece(reinterpret_cast<char*>(&header),
+                                              sizeof(header)));
 
   // Read the index vector.  Herb Sutter indicates that vectors are
   // guaranteed to be contiuguous, so reading to where element 0 lives
   // is valid.
   index.resize(header.index_size);
   read = fread(&(index[0]), sizeof(index[0]), index.size(), file.get());
   if (read != index.size())
     return NULL;
-  base::MD5Update(&context, &(index[0]), index_bytes);
+  base::MD5Update(&context,
+                  base::StringPiece(reinterpret_cast<char*>(&(index[0])),
+                                    index_bytes));
 
   // Read vector of deltas.
   deltas.resize(header.deltas_size);
   read = fread(&(deltas[0]), sizeof(deltas[0]), deltas.size(), file.get());
   if (read != deltas.size())
     return NULL;
-  base::MD5Update(&context, &(deltas[0]), deltas_bytes);
+  base::MD5Update(&context,
+                  base::StringPiece(reinterpret_cast<char*>(&(deltas[0])),
+                                    deltas_bytes));
 
   base::MD5Digest calculated_digest;
   base::MD5Final(&calculated_digest, &context);
 
   base::MD5Digest file_digest;
   read = fread(&file_digest, sizeof(file_digest), 1, file.get());
   if (read != 1)
     return NULL;
 
   if (0 != memcmp(&file_digest, &calculated_digest, sizeof(file_digest)))
@@ skipping 22 matching lines @@
     return false;
 
   base::MD5Context context;
   base::MD5Init(&context);
 
   // TODO(shess): The I/O code in safe_browsing_store_file.cc would
   // sure be useful about now.
   size_t written = fwrite(&header, sizeof(header), 1, file.get());
   if (written != 1)
     return false;
-  base::MD5Update(&context, &header, sizeof(header));
+  base::MD5Update(&context, base::StringPiece(reinterpret_cast<char*>(&header),
+                                              sizeof(header)));
 
   // As for reads, the standard guarantees the ability to access the
   // contents of the vector by a pointer to an element.
   const size_t index_bytes = sizeof(index_[0]) * index_.size();
   written = fwrite(&(index_[0]), sizeof(index_[0]), index_.size(), file.get());
   if (written != index_.size())
     return false;
-  base::MD5Update(&context, &(index_[0]), index_bytes);
+  base::MD5Update(&context,
+                  base::StringPiece(reinterpret_cast<const char*>(&(index_[0])),
+                                    index_bytes));
 
   const size_t deltas_bytes = sizeof(deltas_[0]) * deltas_.size();
   written = fwrite(&(deltas_[0]), sizeof(deltas_[0]), deltas_.size(),
                    file.get());
   if (written != deltas_.size())
     return false;
-  base::MD5Update(&context, &(deltas_[0]), deltas_bytes);
+  base::MD5Update(&context,
+                  base::StringPiece(
+                      reinterpret_cast<const char*>(&(deltas_[0])),
+                      deltas_bytes));
 
   base::MD5Digest digest;
   base::MD5Final(&digest, &context);
   written = fwrite(&digest, sizeof(digest), 1, file.get());
   if (written != 1)
     return false;
 
   // TODO(shess): Can this code check that the close was successful?
   file.reset();
 
@@ skipping 60 matching lines @@
   }
 
   for (size_t di = 0; di < deltas_.size(); ++di) {
     checksum ^= static_cast<uint32>(deltas_[di]);
   }
 
   return checksum == checksum_;
 }
 
 }  // namespace safe_browsing