Switch to standard integer types in net/.

net/disk_cache/entry_unittest.cc

Index: net/disk_cache/entry_unittest.cc
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index e0605c519d49ae4980864d5d47b1b9a22c48d3df..7806da8adb1b10264144166c0fc3b9767582fc1e 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
@@ -1638,8 +1638,11 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
 }
 
 // Writes |buf_1| to offset and reads it back as |buf_2|.
-void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
-                    net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) {
+void VerifySparseIO(disk_cache::Entry* entry,
+                    int64_t offset,
+                    net::IOBuffer* buf_1,
+                    int size,
+                    net::IOBuffer* buf_2) {
   net::TestCompletionCallback cb;
 
   memset(buf_2->data(), 0, size);
@@ -1657,7 +1660,9 @@ void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
 
 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
 // same as the content of the provided |buffer|.
-void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
+void VerifyContentSparseIO(disk_cache::Entry* entry,
+                           int64_t offset,
+                           char* buffer,
                            int size) {
   net::TestCompletionCallback cb;
 
@@ -1754,7 +1759,7 @@ void DiskCacheEntryTest::GetAvailableRange() {
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));
 
   // We stop at the first empty block.
-  int64 start;
+  int64_t start;
   net::TestCompletionCallback cb;
   int rv = entry->GetAvailableRange(
       0x20F0000, kSize * 2, &start, cb.callback());
@@ -1833,7 +1838,7 @@ TEST_F(DiskCacheEntryTest, SparseWriteDropped) {
   int offset = 1024 - 500;
   int rv = 0;
   net::TestCompletionCallback cb;
-  int64 start;
+  int64_t start;
   for (int i = 0; i < 5; i++) {
     // Check result of last GetAvailableRange.
     EXPECT_EQ(0, rv);
@@ -1887,8 +1892,8 @@ TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped) {
   // Any starting offset is fine as long as it is 1024-bytes aligned.
   int rv = 0;
   net::TestCompletionCallback cb;
-  int64 start;
-  int64 offset = 1024 * 11;
+  int64_t start;
+  int64_t offset = 1024 * 11;
   for (; offset < 20000; offset += kSize) {
     rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
@@ -2025,7 +2030,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) {
             entry->WriteSparseData(
                 50000, buf.get(), 8192, net::CompletionCallback()));
 
-  int64 start;
+  int64_t start;
   net::TestCompletionCallback cb;
   // Test that we stop at a discontinuous child at the second block.
   int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback());
@@ -2117,7 +2122,7 @@ void DiskCacheEntryTest::DoomSparseEntry() {
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
-  int64 offset = 1024;
+  int64_t offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
     EXPECT_EQ(kSize, WriteSparseData(entry1, offset, buf.get(), kSize));
@@ -2205,7 +2210,7 @@ TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
-  int64 offset = 1024;
+  int64_t offset = 1024;
   // Write to a bunch of ranges.
   for (int i = 0; i < 12; i++) {
     EXPECT_EQ(kSize,
@@ -2263,7 +2268,7 @@ void DiskCacheEntryTest::PartialSparseEntry() {
   EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize));
 
   int rv;
-  int64 start;
+  int64_t start;
   net::TestCompletionCallback cb;
   if (memory_only_ || simple_cache_mode_) {
     rv = entry->GetAvailableRange(0, 600, &start, cb.callback());
@@ -2395,7 +2400,7 @@ TEST_F(DiskCacheEntryTest, CancelSparseIO) {
       1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
-  int64 offset = 0;
+  int64_t offset = 0;
   rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
   rv = cb5.GetResult(rv);
   if (!cb1.have_result()) {
@@ -2637,7 +2642,7 @@ bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
   if (!entry_file0.IsValid())
     return false;
 
-  int64 file_offset =
+  int64_t file_offset =
       sizeof(disk_cache::SimpleFileHeader) + key.size() + kDataSize - 2;
   EXPECT_EQ(1, entry_file0.Write(file_offset, "X", 1));
   *data_size = kDataSize;
@@ -2690,7 +2695,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
   entry->Doom();  // Should not crash.
 }
 
-bool TruncatePath(const base::FilePath& file_path, int64 length)  {
+bool TruncatePath(const base::FilePath& file_path, int64_t length) {
   base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
   if (!file.IsValid())
     return false;
@@ -2721,7 +2726,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) {
   int kTruncationBytes = -static_cast<int>(sizeof(disk_cache::SimpleFileEOF));
   const base::FilePath entry_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
-  const int64 invalid_size =
+  const int64_t invalid_size =
       disk_cache::simple_util::GetFileSizeFromKeyAndDataSize(key,
                                                              kTruncationBytes);
   EXPECT_TRUE(TruncatePath(entry_path, invalid_size));