Switch to standard integer types in net/.

net/tools/disk_cache_memory_test/disk_cache_memory_test.cc

 // Copyright 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 <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <vector>
 
@@ skipping 143 matching lines @@
   return false;
 }
 
 // Parses range property lines from /proc/<PID>/smaps, e.g.:
 // Private_Dirty:        16 kB
 //
 // Returns |false| iff it recognizes a new range line. Outputs non-zero |size|
 // only if parsing succeeded.
 bool ParseRangeProperty(const std::string& line,
                         std::vector<std::string>* tokens,
-                        uint64* size,
+                        uint64_t* size,
                         bool* is_private_dirty) {
   *tokens = base::SplitString(line, base::kWhitespaceASCII,
                               base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 
   // If the line is long, attempt to parse new range outside of this scope.
   if (tokens->size() > 3)
     return false;
 
   // Skip the line on other parsing error occasions.
   if (tokens->size() < 3)
     return true;
   const std::string& type = (*tokens)[0];
   if (type != kPrivateDirty)
     return true;
   const std::string& unit = (*tokens)[2];
   if (unit != kKb) {
     LOG(WARNING) << "Discarding value not in kB: " << line;
     return true;
   }
   const std::string& size_str = (*tokens)[1];
-  uint64 map_size = 0;
+  uint64_t map_size = 0;
   if (!base::StringToUint64(size_str, &map_size))
     return true;
   *is_private_dirty = true;
   *size = map_size;
   return true;
 }
 
-uint64 GetMemoryConsumption() {
+uint64_t GetMemoryConsumption() {
   std::ifstream maps_file(
       base::StringPrintf("/proc/%d/smaps", getpid()).c_str());
   if (!maps_file.good()) {
     LOG(ERROR) << "Could not open smaps file.";
     return false;
   }
   std::string line;
   std::vector<std::string> tokens;
-  uint64 total_size = 0;
+  uint64_t total_size = 0;
   if (!std::getline(maps_file, line) || line.empty())
     return total_size;
   while (true) {
     bool is_anonymous_read_write = false;
     if (!ParseRangeLine(line, &tokens, &is_anonymous_read_write)) {
       LOG(WARNING) << "Parsing smaps - did not expect line: " << line;
     }
     if (!std::getline(maps_file, line) || line.empty())
       return total_size;
     bool is_private_dirty = false;
-    uint64 size = 0;
+    uint64_t size = 0;
     while (ParseRangeProperty(line, &tokens, &size, &is_private_dirty)) {
       if (is_anonymous_read_write && is_private_dirty) {
         total_size += size;
         is_private_dirty = false;
       }
       if (!std::getline(maps_file, line) || line.empty())
         return total_size;
     }
   }
   return total_size;
 }
 
 bool CacheMemTest(const std::vector<scoped_ptr<CacheSpec>>& specs) {
   std::vector<scoped_ptr<Backend>> backends;
   for (const auto& it : specs) {
     scoped_ptr<Backend> backend = CreateAndInitBackend(*it);
     if (!backend)
       return false;
     std::cout << "Number of entries in " << it->path.LossyDisplayName() << " : "
               << backend->GetEntryCount() << std::endl;
     backends.push_back(std::move(backend));
   }
-  const uint64 memory_consumption = GetMemoryConsumption();
+  const uint64_t memory_consumption = GetMemoryConsumption();
   std::cout << "Private dirty memory: " << memory_consumption << " kB"
             << std::endl;
   return true;
 }
 
 void PrintUsage(std::ostream* stream) {
   *stream << "Usage: disk_cache_mem_test "
           << "--spec-1=<spec> "
           << "[--spec-2=<spec>]"
           << std::endl
@@ skipping 44 matching lines @@
   }
   return CacheMemTest(specs);
 }
 
 }  // namespace
 }  // namespace disk_cache
 
 int main(int argc, char** argv) {
   return !disk_cache::Main(argc, argv);
 }