Switch to standard integer types in net/.

net/disk_cache/blockfile/index_table_v3_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "net/disk_cache/blockfile/addr.h"
 #include "net/disk_cache/blockfile/disk_format_v3.h"
 #include "net/disk_cache/blockfile/index_table_v3.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using disk_cache::EntryCell;
 using disk_cache::IndexCell;
 using disk_cache::IndexTable;
 using disk_cache::IndexTableInitData;
 
@@ skipping 35 matching lines @@
   // |num_entries| is the capacity of the main table. The extra table is half
   // the size of the main table.
   explicit TestCacheTables(int num_entries);
   ~TestCacheTables() {}
 
   void GetInitData(IndexTableInitData* result);
   void CopyFrom(const TestCacheTables& other);
   base::Time start_time() const { return start_time_; }
 
  private:
-  scoped_ptr<uint64[]> main_bitmap_;
+  scoped_ptr<uint64_t[]> main_bitmap_;
   scoped_ptr<disk_cache::IndexBucket[]> main_table_;
   scoped_ptr<disk_cache::IndexBucket[]> extra_table_;
   base::Time start_time_;
   int num_bitmap_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCacheTables);
 };
 
 TestCacheTables::TestCacheTables(int num_entries) {
   DCHECK_GE(num_entries, 1024);
   DCHECK_EQ(num_entries, num_entries / 1024 * 1024);
   main_table_.reset(new disk_cache::IndexBucket[num_entries]);
   extra_table_.reset(new disk_cache::IndexBucket[num_entries / 2]);
   memset(main_table_.get(), 0, num_entries * sizeof(*main_table_.get()));
   memset(extra_table_.get(), 0, num_entries / 2 * sizeof(*extra_table_.get()));
 
   // We allow IndexBitmap smaller than a page because the code should not really
   // depend on that.
   num_bitmap_bytes_ = (num_entries + num_entries / 2) / 8;
   size_t required_size = sizeof(disk_cache::IndexHeaderV3) + num_bitmap_bytes_;
-  main_bitmap_.reset(new uint64[required_size / sizeof(uint64)]);
+  main_bitmap_.reset(new uint64_t[required_size / sizeof(uint64_t)]);
   memset(main_bitmap_.get(), 0, required_size);
 
   disk_cache::IndexHeaderV3* header =
       reinterpret_cast<disk_cache::IndexHeaderV3*>(main_bitmap_.get());
 
   header->magic = disk_cache::kIndexMagicV3;
   header->version = disk_cache::kVersion3;
   header->table_len = num_entries + num_entries / 2;
   header->max_bucket = num_entries / 4 - 1;
 
@@ skipping 10 matching lines @@
   result->index_bitmap =
       reinterpret_cast<disk_cache::IndexBitmap*>(main_bitmap_.get());
 
   result->main_table = main_table_.get();
   result->extra_table = extra_table_.get();
 
   result->backup_header.reset(new disk_cache::IndexHeaderV3);
   memcpy(result->backup_header.get(), result->index_bitmap,
          sizeof(result->index_bitmap->header));
 
-  result->backup_bitmap.reset(new uint32[num_bitmap_bytes_ / sizeof(uint32)]);
+  result->backup_bitmap.reset(
+      new uint32_t[num_bitmap_bytes_ / sizeof(uint32_t)]);
   memcpy(result->backup_bitmap.get(), result->index_bitmap->bitmap,
          num_bitmap_bytes_);
 }
 
 void TestCacheTables::CopyFrom(const TestCacheTables& other) {
   disk_cache::IndexBitmap* this_bitmap =
     reinterpret_cast<disk_cache::IndexBitmap*>(main_bitmap_.get());
   disk_cache::IndexBitmap* other_bitmap =
     reinterpret_cast<disk_cache::IndexBitmap*>(other.main_bitmap_.get());
 
@@ skipping 14 matching lines @@
   this_bitmap->header.max_bucket = other_bitmap->header.max_bucket;
   this_bitmap->header.create_time = other_bitmap->header.create_time;
   this_bitmap->header.base_time = other_bitmap->header.base_time;
   this_bitmap->header.flags = other_bitmap->header.flags;
   start_time_ = other.start_time_;
 }
 
 }  // namespace
 
 TEST(DiskCacheIndexTable, EntryCell) {
-  uint32 hash = 0x55aa6699;
+  uint32_t hash = 0x55aa6699;
   disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, 0x4531);
   bool small_table = true;
   int cell_num = 88;
   int reuse = 6;
   int timestamp = 123456;
   disk_cache::EntryState state = disk_cache::ENTRY_MODIFIED;
   disk_cache::EntryGroup group = disk_cache::ENTRY_HIGH_USE;
 
   for (int i = 0; i < 4; i++) {
     SCOPED_TRACE(i);
@@ skipping 108 matching lines @@
   IndexTableInitData init_data;
   cache.GetInitData(&init_data);
 
   IndexTable index(NULL);
   index.Init(&init_data);
 
   // Write some entries.
   disk_cache::CellList entries;
   for (int i = 0; i < 250; i++) {
     SCOPED_TRACE(i);
-    uint32 hash = i * i * 1111 + i * 11;
+    uint32_t hash = i * i * 1111 + i * 11;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
     disk_cache::CellInfo info = { hash, addr };
     entries.push_back(info);
   }
 
   // Read them back.
   for (size_t i = 0; i < entries.size(); i++) {
     SCOPED_TRACE(i);
-    uint32 hash = entries[i].hash;
+    uint32_t hash = entries[i].hash;
     disk_cache::Addr addr = entries[i].address;
 
     disk_cache::EntrySet found_entries = index.LookupEntries(hash);
     ASSERT_EQ(1u, found_entries.cells.size());
     EXPECT_TRUE(found_entries.cells[0].IsValid());
     EXPECT_EQ(hash, found_entries.cells[0].hash());
     EXPECT_EQ(addr.value(), found_entries.cells[0].GetAddress().value());
 
     EntryCell entry = index.FindEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
     EXPECT_EQ(hash, entry.hash());
     EXPECT_EQ(addr.value(), entry.GetAddress().value());
 
     // Delete the first 100 entries.
     if (i < 100)
       index.SetSate(hash, addr, disk_cache::ENTRY_DELETED);
   }
 
   // See what we have now.
   for (size_t i = 0; i < entries.size(); i++) {
     SCOPED_TRACE(i);
-    uint32 hash = entries[i].hash;
+    uint32_t hash = entries[i].hash;
     disk_cache::Addr addr = entries[i].address;
 
     disk_cache::EntrySet found_entries = index.LookupEntries(hash);
     if (i < 100) {
       EXPECT_EQ(0u, found_entries.cells.size());
     } else {
       ASSERT_EQ(1u, found_entries.cells.size());
       EXPECT_TRUE(found_entries.cells[0].IsValid());
       EXPECT_EQ(hash, found_entries.cells[0].hash());
       EXPECT_EQ(addr.value(), found_entries.cells[0].GetAddress().value());
     }
   }
 }
 
 // Tests handling of multiple entries with the same hash.
 TEST(DiskCacheIndexTable, SameHash) {
   TestCacheTables cache(1024);
   IndexTableInitData init_data;
   cache.GetInitData(&init_data);
 
   IndexTable index(NULL);
   index.Init(&init_data);
 
   disk_cache::CellList entries;
-  uint32 hash = 0x55aa55bb;
+  uint32_t hash = 0x55aa55bb;
   for (int i = 0; i < 6; i++) {
     SCOPED_TRACE(i);
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
     disk_cache::CellInfo info = { hash, addr };
     entries.push_back(info);
   }
 
@@ skipping 119 matching lines @@
 
   IndexTable index(NULL);
   index.Init(&init_data);
 
   base::Time time = cache.start_time();
 
   // Write some entries.
   disk_cache::CellList entries;
   for (int i = 0; i < 44; i++) {
     SCOPED_TRACE(i);
-    uint32 hash = i;  // The entries will be ordered on the table.
+    uint32_t hash = i;  // The entries will be ordered on the table.
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     if (i < 10 || i == 40)
       addr = disk_cache::Addr(disk_cache::BLOCK_EVICTED, 1, 6, i * 13 + 1);
 
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
     disk_cache::CellInfo info = { hash, addr };
     entries.push_back(info);
 
@@ skipping 97 matching lines @@
     cache.reset(new TestCacheTables(size));
     cache.get()->CopyFrom(*old_cache.get());
 
     IndexTableInitData init_data;
     cache.get()->GetInitData(&init_data);
     index.Init(&init_data);
 
     // Write some entries.
     for (int i = 0; i < 250; i++, entry_id++) {
       SCOPED_TRACE(entry_id);
-      uint32 hash = entry_id * i * 321 + entry_id * 13;
+      uint32_t hash = entry_id * i * 321 + entry_id * 13;
       disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, entry_id * 17 + 1);
       EntryCell entry = index.CreateEntryCell(hash, addr);
       EXPECT_TRUE(entry.IsValid());
 
       disk_cache::CellInfo info = { hash, addr };
       entries.push_back(info);
     }
     size *= 2;
   }
 
@@ skipping 13 matching lines @@
   scoped_ptr<TestCacheTables> cache(new TestCacheTables(size));
   disk_cache::CellList entries;
 
   IndexTableInitData init_data;
   cache.get()->GetInitData(&init_data);
   index.Init(&init_data);
 
   // Write some entries.
   for (int i = 0; i < 8; i++) {
     SCOPED_TRACE(i);
-    uint32 hash = i * 256;
+    uint32_t hash = i * 256;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 7 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
     disk_cache::CellInfo info = { hash, addr };
     entries.push_back(info);
   }
 
   // Double the size.
   scoped_ptr<TestCacheTables> old_cache(cache.Pass());
   cache.reset(new TestCacheTables(size * 2));
   cache.get()->CopyFrom(*old_cache.get());
 
   cache.get()->GetInitData(&init_data);
   index.Init(&init_data);
 
   // Write more entries, starting with the upper half of the table.
   for (int i = 9; i < 11; i++) {
     SCOPED_TRACE(i);
-    uint32 hash = i * 256;
+    uint32_t hash = i * 256;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 7 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
     disk_cache::CellInfo info = { hash, addr };
     entries.push_back(info);
   }
 
   // Access all the entries.
   for (size_t i = 0; i < entries.size(); i++) {
@@ skipping 10 matching lines @@
   IndexTableInitData init_data;
   cache.GetInitData(&init_data);
   MockIndexBackend backend;
 
   IndexTable index(&backend);
   index.Init(&init_data);
 
   // Write some entries.
   for (int i = 0; i < 512; i++) {
     SCOPED_TRACE(i);
-    uint32 hash = 0;
+    uint32_t hash = 0;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
   }
 
   EXPECT_TRUE(backend.grow_called());
 }
 
 TEST(DiskCacheIndexTable, SaveIndex) {
   TestCacheTables cache(1024);
   IndexTableInitData init_data;
   cache.GetInitData(&init_data);
   MockIndexBackend backend;
 
   IndexTable index(&backend);
   index.Init(&init_data);
 
-  uint32 hash = 0;
+  uint32_t hash = 0;
   disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, 6);
   EntryCell entry = index.CreateEntryCell(hash, addr);
   EXPECT_TRUE(entry.IsValid());
 
   index.OnBackupTimer();
   int expected = (1024 + 512) / 8 + sizeof(disk_cache::IndexHeaderV3);
   EXPECT_EQ(expected, backend.buffer_len());
 }