Switch to standard integer types in net/.

net/tools/dump_cache/dump_files.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.
 
 // Performs basic inspection of the disk cache files with minimal disruption
 // to the actual files (they still may change if an error is detected on the
 // files).
 
 #include "net/tools/dump_cache/dump_files.h"
 
 #include <stdio.h>
 
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/disk_cache/blockfile/block_files.h"
 #include "net/disk_cache/blockfile/disk_format.h"
 #include "net/disk_cache/blockfile/mapped_file.h"
 #include "net/disk_cache/blockfile/stats.h"
 #include "net/disk_cache/blockfile/storage_block-inl.h"
 #include "net/disk_cache/blockfile/storage_block.h"
 #include "net/url_request/view_cache_helper.h"
@@ skipping 35 matching lines @@
   if (!block_files.Init(false)) {
     printf("Unable to init block files\n");
     return;
   }
 
   disk_cache::Addr address(addr);
   disk_cache::MappedFile* file = block_files.GetFile(address);
   if (!file)
     return;
 
-  size_t length = (2 + disk_cache::Stats::kDataSizesLength) * sizeof(int32) +
-                  disk_cache::Stats::MAX_COUNTER * sizeof(int64);
+  size_t length = (2 + disk_cache::Stats::kDataSizesLength) * sizeof(int32_t) +
+                  disk_cache::Stats::MAX_COUNTER * sizeof(int64_t);
 
   size_t offset = address.start_block() * address.BlockSize() +
                   disk_cache::kBlockHeaderSize;
 
-  scoped_ptr<int32[]> buffer(new int32[length]);
+  scoped_ptr<int32_t[]> buffer(new int32_t[length]);
   if (!file->Read(buffer.get(), length, offset))
     return;
 
   printf("Stats:\nSignatrure: 0x%x\n", buffer[0]);
   printf("Total size: %d\n", buffer[1]);
   for (int i = 0; i < disk_cache::Stats::kDataSizesLength; i++)
     printf("Size(%d): %d\n", i, buffer[i + 2]);
 
-  int64* counters = reinterpret_cast<int64*>(
-                        buffer.get() + 2 + disk_cache::Stats::kDataSizesLength);
+  int64_t* counters = reinterpret_cast<int64_t*>(
+      buffer.get() + 2 + disk_cache::Stats::kDataSizesLength);
   for (int i = 0; i < disk_cache::Stats::MAX_COUNTER; i++)
     printf("Count(%d): %" PRId64 "\n", i, *counters++);
   printf("-------------------------\n\n");
 }
 
 // Dumps the contents of the Index-file header.
 void DumpIndexHeader(const base::FilePath& name,
                      disk_cache::CacheAddr* stats_addr) {
   disk_cache::IndexHeader header;
   if (!ReadHeader(name, reinterpret_cast<char*>(&header), sizeof(header)))
@@ skipping 196 matching lines @@
   size_t offset = address.start_block() * address.BlockSize() +
                   disk_cache::kBlockHeaderSize;
   if (!file->Read(buffer.get(), size, offset))
     return false;
 
   base::StringAppendF(out, "0x%x:\n", addr);
   net::ViewCacheHelper::HexDump(buffer.get(), size, out);
   return true;
 }
 
-std::string ToLocalTime(int64 time_us) {
+std::string ToLocalTime(int64_t time_us) {
   base::Time time = base::Time::FromInternalValue(time_us);
   base::Time::Exploded e;
   time.LocalExplode(&e);
   return base::StringPrintf("%d/%d/%d %d:%d:%d.%d", e.year, e.month,
                             e.day_of_month, e.hour, e.minute, e.second,
                             e.millisecond);
 }
 
 void DumpEntry(disk_cache::CacheAddr addr,
                const disk_cache::EntryStore& entry,
@@ skipping 163 matching lines @@
   // We need a message loop, although we really don't run any task.
   base::MessageLoopForIO loop;
   CacheDumper dumper(input_path);
   if (!dumper.Init())
     return -1;
 
   printf("list, addr,      next,       prev,       entry\n");
 
   const int kMaxLength = 1 * 1000 * 1000;
   for (int i = 0; i < 5; i++) {
-    int32 size = header.lru.sizes[i];
+    int32_t size = header.lru.sizes[i];
     if (size < 0 || size > kMaxLength) {
       printf("Wrong size %d\n", size);
       size = kMaxLength;
     }
 
     disk_cache::CacheAddr addr = header.lru.tails[i];
     int count = 0;
     for (; size && addr; size--) {
       count++;
       disk_cache::RankingsNode rankings;
@@ skipping 85 matching lines @@
   disk_cache::BlockFileHeader header;
   if (!ReadHeader(file, reinterpret_cast<char*>(&header), sizeof(header)))
     return -1;
 
   std::string out;
   net::ViewCacheHelper::HexDump(reinterpret_cast<char*>(&header.allocation_map),
                                 sizeof(header.allocation_map), &out);
   printf("%s\n", out.c_str());
   return 0;
 }