Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/safe_browsing/safe_browsing_store_file.cc

 // Copyright (c) 2012 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/safe_browsing_store_file.h"
 
+#include <stddef.h>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "components/safe_browsing_db/prefix_set.h"
 
 namespace safe_browsing {
 
 namespace {
 
 // NOTE(shess): kFileMagic should not be a byte-wise palindrome, so
 // that byte-order changes force corruption.
-const int32 kFileMagic = 0x600D71FE;
+const int32_t kFileMagic = 0x600D71FE;
 
 // Version history:
 // Version 6: aad08754/r2814 by erikkay@google.com on 2008-10-02 (sqlite)
 // Version 7: 6afe28a5/r37435 by shess@chromium.org on 2010-01-28
 // Version 8: d3dd0715/r259791 by shess@chromium.org on 2014-03-27
-const int32 kFileVersion = 8;
+const int32_t kFileVersion = 8;
 
 // ReadAndVerifyHeader() returns this in case of error.
-const int32 kInvalidVersion = -1;
+const int32_t kInvalidVersion = -1;
 
 // Starting with version 8, the storage is sorted and can be sharded to allow
 // updates to be done with lower memory requirements.  Newly written files will
 // be sharded to need less than this amount of memory during update.  Larger
 // values are preferred to minimize looping overhead during processing.
-const int64 kUpdateStorageBytes = 100 * 1024;
+const int64_t kUpdateStorageBytes = 100 * 1024;
 
 // Prevent excessive sharding by setting a lower limit on the shard stride.
 // Smaller values should work fine, but very small values will probably lead to
 // poor performance.  Shard stride is indirectly related to
 // |kUpdateStorageBytes|, setting that very small will bump against this.
-const uint32 kMinShardStride = 1 << 24;
+const uint32_t kMinShardStride = 1 << 24;
 
 // Strides over the entire SBPrefix space.
-const uint64 kMaxShardStride = 1ULL << 32;
+const uint64_t kMaxShardStride = 1ULL << 32;
 
 // Maximum SBPrefix value.
 const SBPrefix kMaxSBPrefix = 0xFFFFFFFF;
 
 // Header at the front of the main database file.
 struct FileHeader {
-  int32 magic, version;
-  uint32 add_chunk_count, sub_chunk_count;
-  uint32 shard_stride;
+  int32_t magic, version;
+  uint32_t add_chunk_count, sub_chunk_count;
+  uint32_t shard_stride;
   // TODO(shess): Is this where 64-bit will bite me?  Perhaps write a
   // specialized read/write?
 };
 
 // Header for each chunk in the chunk-accumulation file.
 struct ChunkHeader {
-  uint32 add_prefix_count, sub_prefix_count;
-  uint32 add_hash_count, sub_hash_count;
+  uint32_t add_prefix_count, sub_prefix_count;
+  uint32_t add_hash_count, sub_hash_count;
 };
 
 // Header for each shard of data in the main database file.
 struct ShardHeader {
-  uint32 add_prefix_count, sub_prefix_count;
-  uint32 add_hash_count, sub_hash_count;
+  uint32_t add_prefix_count, sub_prefix_count;
+  uint32_t add_hash_count, sub_hash_count;
 };
 
 // Enumerate different format-change events for histogramming
 // purposes.  DO NOT CHANGE THE ORDERING OF THESE VALUES.
 enum FormatEventType {
   // Corruption detected, broken down by file format.
   FORMAT_EVENT_FILE_CORRUPT,
   FORMAT_EVENT_SQLITE_CORRUPT,  // Obsolete
 
   // The type of format found in the file.  The expected case (new
@@ skipping 109 matching lines @@
 
 // Write all of |values| to |fp|, and fold the data into the checksum
 // in |context|, if non-NULL.  Returns true if all items successful.
 template <typename CT>
 bool WriteContainer(const CT& values, FILE* fp,
                     base::MD5Context* context) {
   return WriteRange(values.begin(), values.end(), fp, context);
 }
 
 // Delete the chunks in |deleted| from |chunks|.
-void DeleteChunksFromSet(const base::hash_set<int32>& deleted,
-                         std::set<int32>* chunks) {
-  for (std::set<int32>::iterator iter = chunks->begin();
+void DeleteChunksFromSet(const base::hash_set<int32_t>& deleted,
+                         std::set<int32_t>* chunks) {
+  for (std::set<int32_t>::iterator iter = chunks->begin();
        iter != chunks->end();) {
-    std::set<int32>::iterator prev = iter++;
+    std::set<int32_t>::iterator prev = iter++;
     if (deleted.count(*prev) > 0)
       chunks->erase(prev);
   }
 }
 
 bool ReadAndVerifyChecksum(FILE* fp, base::MD5Context* context) {
   base::MD5Digest calculated_digest;
   base::MD5IntermediateFinal(&calculated_digest, context);
 
   base::MD5Digest file_digest;
   if (!ReadItem(&file_digest, fp, context))
     return false;
 
   return memcmp(&file_digest, &calculated_digest, sizeof(file_digest)) == 0;
 }
 
 // Helper function to read the file header and chunk TOC.  Rewinds |fp| and
 // initializes |context|.  The header is left in |header|, with the version
 // returned.  kInvalidVersion is returned for sanity check or checksum failure.
 int ReadAndVerifyHeader(const base::FilePath& filename,
                         FileHeader* header,
-                        std::set<int32>* add_chunks,
-                        std::set<int32>* sub_chunks,
+                        std::set<int32_t>* add_chunks,
+                        std::set<int32_t>* sub_chunks,
                         FILE* fp,
                         base::MD5Context* context) {
   DCHECK(header);
   DCHECK(add_chunks);
   DCHECK(sub_chunks);
   DCHECK(fp);
   DCHECK(context);
 
   base::MD5Init(context);
   if (!FileRewind(fp))
@@ skipping 19 matching lines @@
     RecordFormatEvent(FORMAT_EVENT_HEADER_CHECKSUM_FAILURE);
     return kInvalidVersion;
   }
 
   return kFileVersion;
 }
 
 // Helper function to write out the initial header and chunks-contained data.
 // Rewinds |fp|, initializes |context|, then writes a file header and
 // |add_chunks| and |sub_chunks|.
-bool WriteHeader(uint32 out_stride,
-                 const std::set<int32>& add_chunks,
-                 const std::set<int32>& sub_chunks,
+bool WriteHeader(uint32_t out_stride,
+                 const std::set<int32_t>& add_chunks,
+                 const std::set<int32_t>& sub_chunks,
                  FILE* fp,
                  base::MD5Context* context) {
   if (!FileRewind(fp))
     return false;
 
   base::MD5Init(context);
   FileHeader header;
   header.magic = kFileMagic;
   header.version = kFileVersion;
   header.add_chunk_count = add_chunks.size();
@@ skipping 116 matching lines @@
     sub_full_hashes_.clear();
   }
 
   // Merge data from |beg|..|end| into receiver's state, then process the state.
   // The current state and the range given should corrospond to the same sorted
   // shard of data from different sources.  |add_del_cache| and |sub_del_cache|
   // indicate the chunk ids which should be deleted during processing (see
   // SBProcessSubs).
   void MergeDataAndProcess(const StateInternalPos& beg,
                            const StateInternalPos& end,
-                           const base::hash_set<int32>& add_del_cache,
-                           const base::hash_set<int32>& sub_del_cache) {
+                           const base::hash_set<int32_t>& add_del_cache,
+                           const base::hash_set<int32_t>& sub_del_cache) {
     container_merge(&add_prefixes_,
                     beg.add_prefixes_iter_,
                     end.add_prefixes_iter_,
                     SBAddPrefixLess<SBAddPrefix,SBAddPrefix>);
 
     container_merge(&sub_prefixes_,
                     beg.sub_prefixes_iter_,
                     end.sub_prefixes_iter_,
                     SBAddPrefixLess<SBSubPrefix,SBSubPrefix>);
 
@@ skipping 89 matching lines @@
 
 // Helper to read the entire database state, used by GetAddPrefixes() and
 // GetAddFullHashes().  Those functions are generally used only for smaller
 // files.  Returns false in case of errors reading the data.
 bool ReadDbStateHelper(const base::FilePath& filename,
                        StateInternal* db_state) {
   base::ScopedFILE file(base::OpenFile(filename, "rb"));
   if (file.get() == NULL)
     return false;
 
-  std::set<int32> add_chunks;
-  std::set<int32> sub_chunks;
+  std::set<int32_t> add_chunks;
+  std::set<int32_t> sub_chunks;
 
   base::MD5Context context;
   FileHeader header;
   const int version =
       ReadAndVerifyHeader(filename, &header, &add_chunks, &sub_chunks,
                           file.get(), &context);
   if (version == kInvalidVersion)
     return false;
 
-  uint64 in_min = 0;
-  uint64 in_stride = header.shard_stride;
+  uint64_t in_min = 0;
+  uint64_t in_stride = header.shard_stride;
   if (!in_stride)
     in_stride = kMaxShardStride;
   if (!IsPowerOfTwo(in_stride))
     return false;
 
   do {
     ShardHeader shard_header;
     if (!ReadItem(&shard_header, file.get(), &context))
       return false;
 
     if (!db_state->AppendData(shard_header.add_prefix_count,
                               shard_header.sub_prefix_count,
                               shard_header.add_hash_count,
                               shard_header.sub_hash_count,
                               file.get(), &context)) {
       return false;
     }
 
     in_min += in_stride;
   } while (in_min <= kMaxSBPrefix);
 
   if (!ReadAndVerifyChecksum(file.get(), &context))
     return false;
 
-  int64 size = 0;
+  int64_t size = 0;
   if (!base::GetFileSize(filename, &size))
     return false;
 
-  return static_cast<int64>(ftell(file.get())) == size;
+  return static_cast<int64_t>(ftell(file.get())) == size;
 }
 
 }  // namespace
 
 SafeBrowsingStoreFile::SafeBrowsingStoreFile(
     const scoped_refptr<const base::SequencedTaskRunner>& task_runner)
     : task_runner_(task_runner),
       chunks_written_(0),
       empty_(false),
       corruption_seen_(false) {
@@ skipping 29 matching lines @@
   // The file was either empty or never opened.  The empty case is
   // presumed not to be invalid.  The never-opened case can happen if
   // BeginUpdate() fails for any databases, and should already have
   // caused the corruption callback to fire.
   if (!file_.get())
     return true;
 
   if (!FileRewind(file_.get()))
     return OnCorruptDatabase();
 
-  int64 size = 0;
+  int64_t size = 0;
   if (!base::GetFileSize(filename_, &size))
     return OnCorruptDatabase();
 
   base::MD5Context context;
   base::MD5Init(&context);
 
   // Read everything except the final digest.
   size_t bytes_left = static_cast<size_t>(size);
-  CHECK(size == static_cast<int64>(bytes_left));
+  CHECK(size == static_cast<int64_t>(bytes_left));
   if (bytes_left < sizeof(base::MD5Digest))
     return OnCorruptDatabase();
   bytes_left -= sizeof(base::MD5Digest);
 
   // Fold the contents of the file into the checksum.
   while (bytes_left > 0) {
     char buf[4096];
     const size_t c = std::min(sizeof(buf), bytes_left);
     const size_t ret = fread(buf, 1, c, file_.get());
 
@@ skipping 17 matching lines @@
   DCHECK(CalledOnValidThread());
   filename_ = filename;
   corruption_callback_ = corruption_callback;
 }
 
 bool SafeBrowsingStoreFile::BeginChunk() {
   DCHECK(CalledOnValidThread());
   return ClearChunkBuffers();
 }
 
-bool SafeBrowsingStoreFile::WriteAddPrefix(int32 chunk_id, SBPrefix prefix) {
+bool SafeBrowsingStoreFile::WriteAddPrefix(int32_t chunk_id, SBPrefix prefix) {
   DCHECK(CalledOnValidThread());
   add_prefixes_.push_back(SBAddPrefix(chunk_id, prefix));
   return true;
 }
 
 bool SafeBrowsingStoreFile::GetAddPrefixes(SBAddPrefixes* add_prefixes) {
   DCHECK(CalledOnValidThread());
 
   add_prefixes->clear();
   if (!base::PathExists(filename_))
@@ skipping 16 matching lines @@
     return true;
 
   StateInternal db_state;
   if (!ReadDbStateHelper(filename_, &db_state))
     return OnCorruptDatabase();
 
   add_full_hashes->swap(db_state.add_full_hashes_);
   return true;
 }
 
-bool SafeBrowsingStoreFile::WriteAddHash(int32 chunk_id,
+bool SafeBrowsingStoreFile::WriteAddHash(int32_t chunk_id,
                                          const SBFullHash& full_hash) {
   DCHECK(CalledOnValidThread());
   add_hashes_.push_back(SBAddFullHash(chunk_id, full_hash));
   return true;
 }
 
-bool SafeBrowsingStoreFile::WriteSubPrefix(int32 chunk_id,
-                                           int32 add_chunk_id,
+bool SafeBrowsingStoreFile::WriteSubPrefix(int32_t chunk_id,
+                                           int32_t add_chunk_id,
                                            SBPrefix prefix) {
   DCHECK(CalledOnValidThread());
   sub_prefixes_.push_back(SBSubPrefix(chunk_id, add_chunk_id, prefix));
   return true;
 }
 
-bool SafeBrowsingStoreFile::WriteSubHash(int32 chunk_id, int32 add_chunk_id,
+bool SafeBrowsingStoreFile::WriteSubHash(int32_t chunk_id,
+                                         int32_t add_chunk_id,
                                          const SBFullHash& full_hash) {
   DCHECK(CalledOnValidThread());
   sub_hashes_.push_back(SBSubFullHash(chunk_id, add_chunk_id, full_hash));
   return true;
 }
 
 bool SafeBrowsingStoreFile::OnCorruptDatabase() {
   DCHECK(CalledOnValidThread());
 
   if (!corruption_seen_)
@@ skipping 113 matching lines @@
   DCHECK(file_.get() || empty_);
   DCHECK(new_file_.get());
   CHECK(builder);
   CHECK(add_full_hashes_result);
 
   // Rewind the temporary storage.
   if (!FileRewind(new_file_.get()))
     return false;
 
   // Get chunk file's size for validating counts.
-  int64 update_size = 0;
+  int64_t update_size = 0;
   if (!base::GetFileSize(TemporaryFileForFilename(filename_), &update_size))
     return OnCorruptDatabase();
 
   // Track update size to answer questions at http://crbug.com/72216 .
   // Log small updates as 1k so that the 0 (underflow) bucket can be
   // used for "empty" in SafeBrowsingDatabase.
   UMA_HISTOGRAM_COUNTS("SB2.DatabaseUpdateKilobytes",
                        std::max(static_cast<int>(update_size / 1024), 1));
 
   // Chunk updates to integrate.
   StateInternal new_state;
 
   // Read update chunks.
   for (int i = 0; i < chunks_written_; ++i) {
     ChunkHeader header;
 
-    int64 ofs = ftell(new_file_.get());
+    int64_t ofs = ftell(new_file_.get());
     if (ofs == -1)
       return false;
 
     if (!ReadItem(&header, new_file_.get(), NULL))
       return false;
 
     // As a safety measure, make sure that the header describes a sane
     // chunk, given the remaining file size.
-    int64 expected_size = ofs + sizeof(ChunkHeader);
+    int64_t expected_size = ofs + sizeof(ChunkHeader);
     expected_size += header.add_prefix_count * sizeof(SBAddPrefix);
     expected_size += header.sub_prefix_count * sizeof(SBSubPrefix);
     expected_size += header.add_hash_count * sizeof(SBAddFullHash);
     expected_size += header.sub_hash_count * sizeof(SBSubFullHash);
     if (expected_size > update_size)
       return false;
 
     if (!new_state.AppendData(header.add_prefix_count, header.sub_prefix_count,
                               header.add_hash_count, header.sub_hash_count,
                               new_file_.get(), NULL)) {
       return false;
     }
   }
 
   // The state was accumulated by chunk, sort by prefix.
   new_state.SortData();
 
   // These strides control how much data is loaded into memory per pass.
   // Strides must be an even power of two.  |in_stride| will be derived from the
   // input file.  |out_stride| will be derived from an estimate of the resulting
   // file's size.  |process_stride| will be the max of both.
-  uint64 in_stride = kMaxShardStride;
-  uint64 out_stride = kMaxShardStride;
-  uint64 process_stride = 0;
+  uint64_t in_stride = kMaxShardStride;
+  uint64_t out_stride = kMaxShardStride;
+  uint64_t process_stride = 0;
 
   // Used to verify the input's checksum if |!empty_|.
   base::MD5Context in_context;
 
   if (!empty_) {
     DCHECK(file_.get());
 
     FileHeader header = {0};
     int version = ReadAndVerifyHeader(filename_, &header,
                                       &add_chunks_cache_, &sub_chunks_cache_,
                                       file_.get(), &in_context);
     if (version == kInvalidVersion)
       return OnCorruptDatabase();
 
     if (header.shard_stride)
       in_stride = header.shard_stride;
 
     // The header checksum should have prevented this case, but the code will be
     // broken if this is not correct.
     if (!IsPowerOfTwo(in_stride))
       return OnCorruptDatabase();
   }
 
   // We no longer need to track deleted chunks.
   DeleteChunksFromSet(add_del_cache_, &add_chunks_cache_);
   DeleteChunksFromSet(sub_del_cache_, &sub_chunks_cache_);
 
   // Calculate |out_stride| to break the file down into reasonable shards.
   {
-    int64 original_size = 0;
+    int64_t original_size = 0;
     if (!empty_ && !base::GetFileSize(filename_, &original_size))
       return OnCorruptDatabase();
 
     // Approximate the final size as everything.  Subs and deletes will reduce
     // the size, but modest over-sharding won't hurt much.
-    int64 shard_size = original_size + update_size;
+    int64_t shard_size = original_size + update_size;
 
     // Keep splitting until a single stride of data fits the target.
     size_t shifts = 0;
     while (out_stride > kMinShardStride && shard_size > kUpdateStorageBytes) {
       out_stride >>= 1;
       shard_size >>= 1;
       ++shifts;
     }
     UMA_HISTOGRAM_COUNTS("SB2.OutShardShifts", shifts);
 
     DCHECK(IsPowerOfTwo(out_stride));
   }
 
   // Outer loop strides by the max of the input stride (to read integral shards)
   // and the output stride (to write integral shards).
   process_stride = std::max(in_stride, out_stride);
   DCHECK(IsPowerOfTwo(process_stride));
   DCHECK_EQ(0u, process_stride % in_stride);
   DCHECK_EQ(0u, process_stride % out_stride);
 
   // Start writing the new data to |new_file_|.
   base::MD5Context out_context;
   if (!WriteHeader(out_stride, add_chunks_cache_, sub_chunks_cache_,
                    new_file_.get(), &out_context)) {
     return false;
   }
 
   // Start at the beginning of the SBPrefix space.
-  uint64 in_min = 0;
-  uint64 out_min = 0;
-  uint64 process_min = 0;
+  uint64_t in_min = 0;
+  uint64_t out_min = 0;
+  uint64_t process_min = 0;
 
   // Start at the beginning of the updates.
   StateInternalPos new_pos = new_state.StateBegin();
 
   // Re-usable container for shard processing.
   StateInternal db_state;
 
   // Track aggregate counts for histograms.
   size_t add_prefix_count = 0;
   size_t sub_prefix_count = 0;
@@ skipping 125 matching lines @@
   DCHECK(CalledOnValidThread());
   bool ret = Close();
 
   // Delete stale staging file.
   const base::FilePath new_filename = TemporaryFileForFilename(filename_);
   base::DeleteFile(new_filename, false);
 
   return ret;
 }
 
-void SafeBrowsingStoreFile::SetAddChunk(int32 chunk_id) {
+void SafeBrowsingStoreFile::SetAddChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   add_chunks_cache_.insert(chunk_id);
 }
 
-bool SafeBrowsingStoreFile::CheckAddChunk(int32 chunk_id) {
+bool SafeBrowsingStoreFile::CheckAddChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   return add_chunks_cache_.count(chunk_id) > 0;
 }
 
-void SafeBrowsingStoreFile::GetAddChunks(std::vector<int32>* out) {
+void SafeBrowsingStoreFile::GetAddChunks(std::vector<int32_t>* out) {
   DCHECK(CalledOnValidThread());
   out->clear();
   out->insert(out->end(), add_chunks_cache_.begin(), add_chunks_cache_.end());
 }
 
-void SafeBrowsingStoreFile::SetSubChunk(int32 chunk_id) {
+void SafeBrowsingStoreFile::SetSubChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   sub_chunks_cache_.insert(chunk_id);
 }
 
-bool SafeBrowsingStoreFile::CheckSubChunk(int32 chunk_id) {
+bool SafeBrowsingStoreFile::CheckSubChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   return sub_chunks_cache_.count(chunk_id) > 0;
 }
 
-void SafeBrowsingStoreFile::GetSubChunks(std::vector<int32>* out) {
+void SafeBrowsingStoreFile::GetSubChunks(std::vector<int32_t>* out) {
   DCHECK(CalledOnValidThread());
   out->clear();
   out->insert(out->end(), sub_chunks_cache_.begin(), sub_chunks_cache_.end());
 }
 
-void SafeBrowsingStoreFile::DeleteAddChunk(int32 chunk_id) {
+void SafeBrowsingStoreFile::DeleteAddChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   add_del_cache_.insert(chunk_id);
 }
 
-void SafeBrowsingStoreFile::DeleteSubChunk(int32 chunk_id) {
+void SafeBrowsingStoreFile::DeleteSubChunk(int32_t chunk_id) {
   DCHECK(CalledOnValidThread());
   sub_del_cache_.insert(chunk_id);
 }
 
 // static
 bool SafeBrowsingStoreFile::DeleteStore(const base::FilePath& basename) {
   if (!base::DeleteFile(basename, false) &&
       base::PathExists(basename)) {
     NOTREACHED();
     return false;
@@ skipping 11 matching lines @@
   // also removed.
   const base::FilePath journal_filename(
       basename.value() + FILE_PATH_LITERAL("-journal"));
   if (base::PathExists(journal_filename))
     base::DeleteFile(journal_filename, false);
 
   return true;
 }
 
 }  // namespace safe_browsing