Switch to standard integer types in net/.

net/disk_cache/simple/simple_backend_impl.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_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 
 #if defined(OS_POSIX)
 #include <sys/resource.h>
 #endif
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "net/base/net_errors.h"
@@ skipping 172 matching lines @@
     : public SimpleEntryImpl::ActiveEntryProxy {
  public:
   ~ActiveEntryProxy() override {
     if (backend_) {
       DCHECK_EQ(1U, backend_->active_entries_.count(entry_hash_));
       backend_->active_entries_.erase(entry_hash_);
     }
   }
 
   static scoped_ptr<SimpleEntryImpl::ActiveEntryProxy> Create(
-      int64 entry_hash,
+      int64_t entry_hash,
       SimpleBackendImpl* backend) {
     scoped_ptr<SimpleEntryImpl::ActiveEntryProxy>
         proxy(new ActiveEntryProxy(entry_hash, backend));
     return proxy.Pass();
   }
 
  private:
-  ActiveEntryProxy(uint64 entry_hash,
-                   SimpleBackendImpl* backend)
-      : entry_hash_(entry_hash),
-        backend_(backend->AsWeakPtr()) {}
+  ActiveEntryProxy(uint64_t entry_hash, SimpleBackendImpl* backend)
+      : entry_hash_(entry_hash), backend_(backend->AsWeakPtr()) {}
 
-  uint64 entry_hash_;
+  uint64_t entry_hash_;
   base::WeakPtr<SimpleBackendImpl> backend_;
 };
 
 SimpleBackendImpl::SimpleBackendImpl(
     const FilePath& path,
     int max_bytes,
     net::CacheType cache_type,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     net::NetLog* net_log)
     : path_(path),
@@ skipping 39 matching lines @@
     return false;
   orig_max_size_ = max_bytes;
   index_->SetMaxSize(max_bytes);
   return true;
 }
 
 int SimpleBackendImpl::GetMaxFileSize() const {
   return static_cast<int>(index_->max_size() / kMaxFileRatio);
 }
 
-void SimpleBackendImpl::OnDoomStart(uint64 entry_hash) {
+void SimpleBackendImpl::OnDoomStart(uint64_t entry_hash) {
   DCHECK_EQ(0u, entries_pending_doom_.count(entry_hash));
   entries_pending_doom_.insert(
       std::make_pair(entry_hash, std::vector<Closure>()));
 }
 
-void SimpleBackendImpl::OnDoomComplete(uint64 entry_hash) {
+void SimpleBackendImpl::OnDoomComplete(uint64_t entry_hash) {
   DCHECK_EQ(1u, entries_pending_doom_.count(entry_hash));
-  base::hash_map<uint64, std::vector<Closure> >::iterator it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator it =
       entries_pending_doom_.find(entry_hash);
   std::vector<Closure> to_run_closures;
   to_run_closures.swap(it->second);
   entries_pending_doom_.erase(it);
 
   std::for_each(to_run_closures.begin(), to_run_closures.end(),
                 std::mem_fun_ref(&Closure::Run));
 }
 
-void SimpleBackendImpl::DoomEntries(std::vector<uint64>* entry_hashes,
+void SimpleBackendImpl::DoomEntries(std::vector<uint64_t>* entry_hashes,
                                     const net::CompletionCallback& callback) {
-  scoped_ptr<std::vector<uint64> >
-      mass_doom_entry_hashes(new std::vector<uint64>());
+  scoped_ptr<std::vector<uint64_t>> mass_doom_entry_hashes(
+      new std::vector<uint64_t>());
   mass_doom_entry_hashes->swap(*entry_hashes);
 
-  std::vector<uint64> to_doom_individually_hashes;
+  std::vector<uint64_t> to_doom_individually_hashes;
 
   // For each of the entry hashes, there are two cases:
   // 1. The entry is either open or pending doom, and so it should be doomed
   //    individually to avoid flakes.
   // 2. The entry is not in use at all, so we can call
   //    SimpleSynchronousEntry::DoomEntrySet and delete the files en masse.
   for (int i = mass_doom_entry_hashes->size() - 1; i >= 0; --i) {
-    const uint64 entry_hash = (*mass_doom_entry_hashes)[i];
+    const uint64_t entry_hash = (*mass_doom_entry_hashes)[i];
     DCHECK(active_entries_.count(entry_hash) == 0 ||
            entries_pending_doom_.count(entry_hash) == 0);
     if (!active_entries_.count(entry_hash) &&
         !entries_pending_doom_.count(entry_hash)) {
       continue;
     }
 
     to_doom_individually_hashes.push_back(entry_hash);
 
     (*mass_doom_entry_hashes)[i] = mass_doom_entry_hashes->back();
     mass_doom_entry_hashes->resize(mass_doom_entry_hashes->size() - 1);
   }
 
   net::CompletionCallback barrier_callback =
       MakeBarrierCompletionCallback(to_doom_individually_hashes.size() + 1,
                                     callback);
-  for (std::vector<uint64>::const_iterator
+  for (std::vector<uint64_t>::const_iterator
            it = to_doom_individually_hashes.begin(),
-           end = to_doom_individually_hashes.end(); it != end; ++it) {
+           end = to_doom_individually_hashes.end();
+       it != end; ++it) {
     const int doom_result = DoomEntryFromHash(*it, barrier_callback);
     DCHECK_EQ(net::ERR_IO_PENDING, doom_result);
     index_->Remove(*it);
   }
 
-  for (std::vector<uint64>::const_iterator it = mass_doom_entry_hashes->begin(),
-                                           end = mass_doom_entry_hashes->end();
+  for (std::vector<uint64_t>::const_iterator
+           it = mass_doom_entry_hashes->begin(),
+           end = mass_doom_entry_hashes->end();
        it != end; ++it) {
     index_->Remove(*it);
     OnDoomStart(*it);
   }
 
   // Taking this pointer here avoids undefined behaviour from calling
   // base::Passed before mass_doom_entry_hashes.get().
-  std::vector<uint64>* mass_doom_entry_hashes_ptr =
+  std::vector<uint64_t>* mass_doom_entry_hashes_ptr =
       mass_doom_entry_hashes.get();
   PostTaskAndReplyWithResult(worker_pool_.get(),
                              FROM_HERE,
                              base::Bind(&SimpleSynchronousEntry::DoomEntrySet,
                                         mass_doom_entry_hashes_ptr,
                                         path_),
                              base::Bind(&SimpleBackendImpl::DoomEntriesComplete,
                                         AsWeakPtr(),
                                         base::Passed(&mass_doom_entry_hashes),
                                         barrier_callback));
 }
 
 net::CacheType SimpleBackendImpl::GetCacheType() const {
   return net::DISK_CACHE;
 }
 
-int32 SimpleBackendImpl::GetEntryCount() const {
+int32_t SimpleBackendImpl::GetEntryCount() const {
   // TODO(pasko): Use directory file count when index is not ready.
   return index_->GetEntryCount();
 }
 
 int SimpleBackendImpl::OpenEntry(const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
-  const uint64 entry_hash = simple_util::GetEntryHashKey(key);
+  const uint64_t entry_hash = simple_util::GetEntryHashKey(key);
 
   // TODO(gavinp): Factor out this (not quite completely) repetitive code
   // block from OpenEntry/CreateEntry/DoomEntry.
-  base::hash_map<uint64, std::vector<Closure> >::iterator it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator it =
       entries_pending_doom_.find(entry_hash);
   if (it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::OpenEntry,
                    base::Unretained(this), key, entry);
     it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
   }
   scoped_refptr<SimpleEntryImpl> simple_entry =
       CreateOrFindActiveEntry(entry_hash, key);
   CompletionCallback backend_callback =
       base::Bind(&SimpleBackendImpl::OnEntryOpenedFromKey,
                  AsWeakPtr(),
                  key,
                  entry,
                  simple_entry,
                  callback);
   return simple_entry->OpenEntry(entry, backend_callback);
 }
 
 int SimpleBackendImpl::CreateEntry(const std::string& key,
                                    Entry** entry,
                                    const CompletionCallback& callback) {
   DCHECK_LT(0u, key.size());
-  const uint64 entry_hash = simple_util::GetEntryHashKey(key);
+  const uint64_t entry_hash = simple_util::GetEntryHashKey(key);
 
-  base::hash_map<uint64, std::vector<Closure> >::iterator it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator it =
       entries_pending_doom_.find(entry_hash);
   if (it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::CreateEntry,
                    base::Unretained(this), key, entry);
     it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
   }
   scoped_refptr<SimpleEntryImpl> simple_entry =
       CreateOrFindActiveEntry(entry_hash, key);
   return simple_entry->CreateEntry(entry, callback);
 }
 
 int SimpleBackendImpl::DoomEntry(const std::string& key,
                                  const net::CompletionCallback& callback) {
-  const uint64 entry_hash = simple_util::GetEntryHashKey(key);
+  const uint64_t entry_hash = simple_util::GetEntryHashKey(key);
 
-  base::hash_map<uint64, std::vector<Closure> >::iterator it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator it =
       entries_pending_doom_.find(entry_hash);
   if (it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::DoomEntry, base::Unretained(this), key);
     it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
   }
   scoped_refptr<SimpleEntryImpl> simple_entry =
       CreateOrFindActiveEntry(entry_hash, key);
@@ skipping 49 matching lines @@
       return;
     }
     if (index_initialization_error_code != net::OK) {
       callback.Run(index_initialization_error_code);
       return;
     }
     if (!hashes_to_enumerate_)
       hashes_to_enumerate_ = backend_->index()->GetAllHashes().Pass();
 
     while (!hashes_to_enumerate_->empty()) {
-      uint64 entry_hash = hashes_to_enumerate_->back();
+      uint64_t entry_hash = hashes_to_enumerate_->back();
       hashes_to_enumerate_->pop_back();
       if (backend_->index()->Has(entry_hash)) {
         *next_entry = NULL;
         CompletionCallback continue_iteration = base::Bind(
             &SimpleIterator::CheckIterationReturnValue,
             weak_factory_.GetWeakPtr(),
             next_entry,
             callback);
         int error_code_open = backend_->OpenEntryFromHash(entry_hash,
                                                           next_entry,
@@ skipping 14 matching lines @@
                                  int error_code) {
     if (error_code == net::ERR_FAILED) {
       OpenNextEntry(entry, callback);
       return;
     }
     callback.Run(error_code);
   }
 
  private:
   base::WeakPtr<SimpleBackendImpl> backend_;
-  scoped_ptr<std::vector<uint64> > hashes_to_enumerate_;
+  scoped_ptr<std::vector<uint64_t>> hashes_to_enumerate_;
   base::WeakPtrFactory<SimpleIterator> weak_factory_;
 };
 
 scoped_ptr<Backend::Iterator> SimpleBackendImpl::CreateIterator() {
   return scoped_ptr<Iterator>(new SimpleIterator(AsWeakPtr()));
 }
 
 void SimpleBackendImpl::GetStats(base::StringPairs* stats) {
   std::pair<std::string, std::string> item;
   item.first = "Cache type";
@@ skipping 15 matching lines @@
 }
 
 void SimpleBackendImpl::IndexReadyForDoom(Time initial_time,
                                           Time end_time,
                                           const CompletionCallback& callback,
                                           int result) {
   if (result != net::OK) {
     callback.Run(result);
     return;
   }
-  scoped_ptr<std::vector<uint64>> removed_key_hashes(
+  scoped_ptr<std::vector<uint64_t>> removed_key_hashes(
       index_->GetEntriesBetween(initial_time, end_time).release());
   DoomEntries(removed_key_hashes.get(), callback);
 }
 
 void SimpleBackendImpl::IndexReadyForSizeCalculation(
     const CompletionCallback& callback,
     int result) {
   if (result == net::OK)
     result = static_cast<int>(index_->GetCacheSize());
   callback.Run(result);
 }
 
 SimpleBackendImpl::DiskStatResult SimpleBackendImpl::InitCacheStructureOnDisk(
     const base::FilePath& path,
-    uint64 suggested_max_size) {
+    uint64_t suggested_max_size) {
   DiskStatResult result;
   result.max_size = suggested_max_size;
   result.net_error = net::OK;
   if (!FileStructureConsistent(path)) {
     LOG(ERROR) << "Simple Cache Backend: wrong file structure on disk: "
                << path.LossyDisplayName();
     result.net_error = net::ERR_FAILED;
   } else {
     bool mtime_result =
         disk_cache::simple_util::GetMTime(path, &result.cache_dir_mtime);
     DCHECK(mtime_result);
     if (!result.max_size) {
-      int64 available = base::SysInfo::AmountOfFreeDiskSpace(path);
+      int64_t available = base::SysInfo::AmountOfFreeDiskSpace(path);
       result.max_size = disk_cache::PreferredCacheSize(available);
     }
     DCHECK(result.max_size);
   }
   return result;
 }
 
 scoped_refptr<SimpleEntryImpl> SimpleBackendImpl::CreateOrFindActiveEntry(
-    const uint64 entry_hash,
+    const uint64_t entry_hash,
     const std::string& key) {
   DCHECK_EQ(entry_hash, simple_util::GetEntryHashKey(key));
   std::pair<EntryMap::iterator, bool> insert_result =
       active_entries_.insert(EntryMap::value_type(entry_hash, NULL));
   EntryMap::iterator& it = insert_result.first;
   const bool did_insert = insert_result.second;
   if (did_insert) {
     SimpleEntryImpl* entry = it->second =
         new SimpleEntryImpl(cache_type_, path_, entry_hash,
                             entry_operations_mode_,this, net_log_);
     entry->SetKey(key);
     entry->SetActiveEntryProxy(ActiveEntryProxy::Create(entry_hash, this));
   }
   DCHECK(it->second);
   // It's possible, but unlikely, that we have an entry hash collision with a
   // currently active entry.
   if (key != it->second->key()) {
     it->second->Doom();
     DCHECK_EQ(0U, active_entries_.count(entry_hash));
     return CreateOrFindActiveEntry(entry_hash, key);
   }
   return make_scoped_refptr(it->second);
 }
 
-int SimpleBackendImpl::OpenEntryFromHash(uint64 entry_hash,
+int SimpleBackendImpl::OpenEntryFromHash(uint64_t entry_hash,
                                          Entry** entry,
                                          const CompletionCallback& callback) {
-  base::hash_map<uint64, std::vector<Closure> >::iterator it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator it =
       entries_pending_doom_.find(entry_hash);
   if (it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::OpenEntryFromHash,
                    base::Unretained(this), entry_hash, entry);
     it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
   }
 
   EntryMap::iterator has_active = active_entries_.find(entry_hash);
   if (has_active != active_entries_.end()) {
     return OpenEntry(has_active->second->key(), entry, callback);
   }
 
   scoped_refptr<SimpleEntryImpl> simple_entry = new SimpleEntryImpl(
       cache_type_, path_, entry_hash, entry_operations_mode_, this, net_log_);
   CompletionCallback backend_callback =
       base::Bind(&SimpleBackendImpl::OnEntryOpenedFromHash,
                  AsWeakPtr(), entry_hash, entry, simple_entry, callback);
   return simple_entry->OpenEntry(entry, backend_callback);
 }
 
-int SimpleBackendImpl::DoomEntryFromHash(uint64 entry_hash,
+int SimpleBackendImpl::DoomEntryFromHash(uint64_t entry_hash,
                                          const CompletionCallback& callback) {
   Entry** entry = new Entry*();
   scoped_ptr<Entry*> scoped_entry(entry);
 
-  base::hash_map<uint64, std::vector<Closure> >::iterator pending_it =
+  base::hash_map<uint64_t, std::vector<Closure>>::iterator pending_it =
       entries_pending_doom_.find(entry_hash);
   if (pending_it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::DoomEntryFromHash,
                    base::Unretained(this), entry_hash);
     pending_it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
   }
 
   EntryMap::iterator active_it = active_entries_.find(entry_hash);
   if (active_it != active_entries_.end())
     return active_it->second->DoomEntry(callback);
 
   // There's no pending dooms, nor any open entry. We can make a trivial
   // call to DoomEntries() to delete this entry.
-  std::vector<uint64> entry_hash_vector;
+  std::vector<uint64_t> entry_hash_vector;
   entry_hash_vector.push_back(entry_hash);
   DoomEntries(&entry_hash_vector, callback);
   return net::ERR_IO_PENDING;
 }
 
 void SimpleBackendImpl::OnEntryOpenedFromHash(
-    uint64 hash,
+    uint64_t hash,
     Entry** entry,
     const scoped_refptr<SimpleEntryImpl>& simple_entry,
     const CompletionCallback& callback,
     int error_code) {
   if (error_code != net::OK) {
     callback.Run(error_code);
     return;
   }
   DCHECK(*entry);
   std::pair<EntryMap::iterator, bool> insert_result =
@@ skipping 32 matching lines @@
       final_code = net::ERR_FAILED;
     } else {
       DCHECK_EQ(simple_entry->entry_hash(), simple_util::GetEntryHashKey(key));
     }
     SIMPLE_CACHE_UMA(BOOLEAN, "KeyMatchedOnOpen", cache_type_, key_matches);
   }
   callback.Run(final_code);
 }
 
 void SimpleBackendImpl::DoomEntriesComplete(
-    scoped_ptr<std::vector<uint64> > entry_hashes,
+    scoped_ptr<std::vector<uint64_t>> entry_hashes,
     const net::CompletionCallback& callback,
     int result) {
-  for (const uint64& entry_hash : *entry_hashes)
+  for (const uint64_t& entry_hash : *entry_hashes)
     OnDoomComplete(entry_hash);
   callback.Run(result);
 }
 
 // static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   // We only need to do this if we there is an active task runner.
   if (base::ThreadTaskRunnerHandle::IsSet())
     g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache