Switch to standard integer types in net/.

net/disk_cache/simple/simple_index_file.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_index_file.h"
 
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 #include "third_party/zlib/zlib.h"
 
 using base::File;
 
 namespace disk_cache {
 namespace {
 
 const int kEntryFilesHashLength = 16;
 const int kEntryFilesSuffixLength = 2;
 
-const uint64 kMaxEntiresInIndex = 100000000;
+const uint64_t kMaxEntiresInIndex = 100000000;
 
-uint32 CalculatePickleCRC(const base::Pickle& pickle) {
+uint32_t CalculatePickleCRC(const base::Pickle& pickle) {
   return crc32(crc32(0, Z_NULL, 0),
                reinterpret_cast<const Bytef*>(pickle.payload()),
                pickle.payload_size());
 }
 
 // Used in histograms. Please only add new values at the end.
 enum IndexFileState {
   INDEX_STATE_CORRUPT = 0,
   INDEX_STATE_STALE = 1,
   INDEX_STATE_FRESH = 2,
@@ skipping 43 matching lines @@
   static const size_t kEntryFilesLength =
       kEntryFilesHashLength + kEntryFilesSuffixLength;
   // Converting to std::string is OK since we never use UTF8 wide chars in our
   // file names.
   const base::FilePath::StringType base_name = file_path.BaseName().value();
   const std::string file_name(base_name.begin(), base_name.end());
   if (file_name.size() != kEntryFilesLength)
     return;
   const base::StringPiece hash_string(
       file_name.begin(), file_name.begin() + kEntryFilesHashLength);
-  uint64 hash_key = 0;
+  uint64_t hash_key = 0;
   if (!simple_util::GetEntryHashKeyFromHexString(hash_string, &hash_key)) {
     LOG(WARNING) << "Invalid entry hash key filename while restoring index from"
                  << " disk: " << file_name;
     return;
   }
 
   File::Info file_info;
   if (!base::GetFileInfo(file_path, &file_info)) {
     LOG(ERROR) << "Could not get file info for " << file_path.value();
     return;
   }
   base::Time last_used_time;
 #if defined(OS_POSIX)
   // For POSIX systems, a last access time is available. However, it's not
   // guaranteed to be more accurate than mtime. It is no worse though.
   last_used_time = file_info.last_accessed;
 #endif
   if (last_used_time.is_null())
     last_used_time = file_info.last_modified;
 
-  int64 file_size = file_info.size;
+  int64_t file_size = file_info.size;
   SimpleIndex::EntrySet::iterator it = entries->find(hash_key);
   if (it == entries->end()) {
     SimpleIndex::InsertInEntrySet(
         hash_key,
         EntryMetadata(last_used_time, file_size),
         entries);
   } else {
     // Summing up the total size of the entry through all the *_[0-1] files
     it->second.SetEntrySize(it->second.GetEntrySize() + file_size);
   }
@@ skipping 20 matching lines @@
 const char SimpleIndexFile::kIndexDirectory[] = "index-dir";
 // static
 const char SimpleIndexFile::kTempIndexFileName[] = "temp-index";
 
 SimpleIndexFile::IndexMetadata::IndexMetadata()
     : magic_number_(kSimpleIndexMagicNumber),
       version_(kSimpleVersion),
       number_of_entries_(0),
       cache_size_(0) {}
 
-SimpleIndexFile::IndexMetadata::IndexMetadata(
-    uint64 number_of_entries, uint64 cache_size)
+SimpleIndexFile::IndexMetadata::IndexMetadata(uint64_t number_of_entries,
+                                              uint64_t cache_size)
     : magic_number_(kSimpleIndexMagicNumber),
       version_(kSimpleVersion),
       number_of_entries_(number_of_entries),
       cache_size_(cache_size) {}
 
 void SimpleIndexFile::IndexMetadata::Serialize(base::Pickle* pickle) const {
   DCHECK(pickle);
   pickle->WriteUInt64(magic_number_);
   pickle->WriteUInt32(version_);
   pickle->WriteUInt64(number_of_entries_);
@@ skipping 95 matching lines @@
                                        const base::Closure& callback,
                                        SimpleIndexLoadResult* out_result) {
   base::Closure task = base::Bind(&SimpleIndexFile::SyncLoadIndexEntries,
                                   cache_type_,
                                   cache_last_modified, cache_directory_,
                                   index_file_, out_result);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
 void SimpleIndexFile::WriteToDisk(const SimpleIndex::EntrySet& entry_set,
-                                  uint64 cache_size,
+                                  uint64_t cache_size,
                                   const base::TimeTicks& start,
                                   bool app_on_background,
                                   const base::Closure& callback) {
   IndexMetadata index_metadata(entry_set.size(), cache_size);
   scoped_ptr<base::Pickle> pickle = Serialize(index_metadata, entry_set);
   base::Closure task =
       base::Bind(&SimpleIndexFile::SyncWriteToDisk,
                  cache_type_, cache_directory_, index_file_, temp_index_file_,
                  base::Passed(&pickle), start, app_on_background);
   if (callback.is_null())
@@ skipping 105 matching lines @@
 
   base::Pickle pickle(data, data_len);
   if (!pickle.data()) {
     LOG(WARNING) << "Corrupt Simple Index File.";
     return;
   }
 
   base::PickleIterator pickle_it(pickle);
   SimpleIndexFile::PickleHeader* header_p =
       pickle.headerT<SimpleIndexFile::PickleHeader>();
-  const uint32 crc_read = header_p->crc;
-  const uint32 crc_calculated = CalculatePickleCRC(pickle);
+  const uint32_t crc_read = header_p->crc;
+  const uint32_t crc_calculated = CalculatePickleCRC(pickle);
 
   if (crc_read != crc_calculated) {
     LOG(WARNING) << "Invalid CRC in Simple Index file.";
     return;
   }
 
   SimpleIndexFile::IndexMetadata index_metadata;
   if (!index_metadata.Deserialize(&pickle_it)) {
     LOG(ERROR) << "Invalid index_metadata on Simple Cache Index.";
     return;
   }
 
   if (!index_metadata.CheckIndexMetadata()) {
     LOG(ERROR) << "Invalid index_metadata on Simple Cache Index.";
     return;
   }
 
 #if !defined(OS_WIN)
   // TODO(gavinp): Consider using std::unordered_map.
   entries->resize(index_metadata.GetNumberOfEntries() + kExtraSizeForMerge);
 #endif
   while (entries->size() < index_metadata.GetNumberOfEntries()) {
-    uint64 hash_key;
+    uint64_t hash_key;
     EntryMetadata entry_metadata;
     if (!pickle_it.ReadUInt64(&hash_key) ||
         !entry_metadata.Deserialize(&pickle_it)) {
       LOG(WARNING) << "Invalid EntryMetadata in Simple Index file.";
       entries->clear();
       return;
     }
     SimpleIndex::InsertInEntrySet(hash_key, entry_metadata, entries);
   }
 
-  int64 cache_last_modified;
+  int64_t cache_last_modified;
   if (!pickle_it.ReadInt64(&cache_last_modified)) {
     entries->clear();
     return;
   }
   DCHECK(out_cache_last_modified);
   *out_cache_last_modified = base::Time::FromInternalValue(cache_last_modified);
 
   out_result->did_load = true;
 }
 
@@ skipping 23 matching lines @@
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache