Switch to standard integer types in net/.

net/disk_cache/entry_unittest.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.
 
-#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"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/disk_cache_test_base.h"
@@ skipping 1611 matching lines @@
     ++count;
     disk_cache::MemEntryImpl* mem_entry =
         reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
     EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type());
     mem_entry->Close();
   }
   EXPECT_EQ(1, count);
 }
 
 // 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);
   int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
   EXPECT_EQ(0, cb.GetResult(ret));
 
   ret = entry->WriteSparseData(offset, buf_1, size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
 
   ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
 }
 
 // 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;
 
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
   memset(buf_1->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
   EXPECT_EQ(size, cb.GetResult(ret));
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
@@ skipping 76 matching lines @@
 
   const int kSize = 16 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
   EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
   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());
   EXPECT_EQ(kSize, cb.GetResult(rv));
   EXPECT_EQ(0x20F0000, start);
 
   start = 0;
   rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
   EXPECT_EQ(0, cb.GetResult(rv));
   rv = entry->GetAvailableRange(
@@ skipping 58 matching lines @@
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // Do small writes (180 bytes) that get increasingly close to a 1024-byte
   // boundary. All data should be dropped until a boundary is crossed, at which
   // point the data after the boundary is saved (at least for a while).
   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);
 
     rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
 
     rv = entry->GetAvailableRange(offset - 100, kSize, &start, cb.callback());
     EXPECT_EQ(0, cb.GetResult(rv));
 
@@ skipping 33 matching lines @@
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 180;
   scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
   scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
   // 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));
 
     rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
     EXPECT_EQ(offset, start);
 
     rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
     EXPECT_EQ(kSize, cb.GetResult(rv));
@@ skipping 116 matching lines @@
       entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
   EXPECT_EQ(1024,
             entry->WriteSparseData(
                 10000, buf.get(), 1024, net::CompletionCallback()));
 
   // Writes in the middle of an entry and spans 2 child entries.
   EXPECT_EQ(8192,
             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());
   EXPECT_EQ(1024, cb.GetResult(rv));
   EXPECT_EQ(0, start);
 
   // Test that number of bytes is reported correctly when we start from the
   // middle of a filled region.
   rv = entry->GetAvailableRange(512, 10000, &start, cb.callback());
   EXPECT_EQ(512, cb.GetResult(rv));
@@ skipping 71 matching lines @@
   std::string key1("the first key");
   std::string key2("the second key");
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
 
   const int kSize = 4 * 1024;
   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));
     // Keep the second map under the default size.
     if (i < 9)
       EXPECT_EQ(kSize, WriteSparseData(entry2, offset, buf.get(), kSize));
 
     offset *= 4;
   }
 
@@ skipping 67 matching lines @@
   UseCurrentThread();
   InitCache();
   std::string key("the key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 4 * 1024;
   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,
               entry->WriteSparseData(
                   offset, buf.get(), kSize, net::CompletionCallback()));
     offset *= 4;
   }
   EXPECT_EQ(9, cache_->GetEntryCount());
 
   entry->Close();
@@ skipping 37 matching lines @@
   // This read should not change anything.
   if (memory_only_ || simple_cache_mode_)
     EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize));
   else
     EXPECT_EQ(0, ReadSparseData(entry, 24000, buf2.get(), kSize));
 
   EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
   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());
     EXPECT_EQ(100, cb.GetResult(rv));
     EXPECT_EQ(500, start);
   } else {
     rv = entry->GetAvailableRange(0, 2048, &start, cb.callback());
     EXPECT_EQ(1024, cb.GetResult(rv));
     EXPECT_EQ(1024, start);
   }
@@ skipping 111 matching lines @@
   const int kSize = 40 * 1024;
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // This will open and write two "real" entries.
   net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
   int rv = entry->WriteSparseData(
       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()) {
     // We may or may not have finished writing to the entry. If we have not,
     // we cannot start another operation at this time.
     EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv);
   }
 
   // We cancel the pending operation, and register multiple notifications.
   entry->CancelSparseIO();
@@ skipping 221 matching lines @@
   entry = NULL;
 
   // Corrupt the last byte of the data.
   base::FilePath entry_file0_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
   base::File entry_file0(entry_file0_path,
                          base::File::FLAG_WRITE | base::File::FLAG_OPEN);
   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;
   return true;
 }
 
 // Tests that the simple cache can detect entries that have bad data.
 TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) {
   SetSimpleCacheMode();
   InitCache();
@@ skipping 32 matching lines @@
 
   const int kReadBufferSize = 200;
   EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
             ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 
   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;
   return file.SetLength(length);
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) {
   SetSimpleCacheMode();
   InitCache();
 
@@ skipping 10 matching lines @@
   // succed.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   entry->Close();
   entry = NULL;
 
   // Truncate the file such that the length isn't sufficient to have an EOF
   // record.
   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));
   EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) {
   // Test sequence:
   // Create, Write, Read, Close.
@@ skipping 1416 matching lines @@
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   entry->Close();
 }