Remove kint32max.

net/disk_cache/blockfile/index_table_v3.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 "net/disk_cache/blockfile/index_table_v3.h"
 
 #include <algorithm>
+#include <limits>
 #include <set>
 #include <utility>
 
 #include "base/bits.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 
 using base::Time;
 using base::TimeDelta;
 using disk_cache::CellInfo;
 using disk_cache::CellList;
 using disk_cache::IndexCell;
 using disk_cache::IndexIterator;
 
 namespace {
 
 // The following constants describe the bitfields of an IndexCell so they are
 // implicitly synchronized with the descrption of IndexCell on file_format_v3.h.
-const uint64 kCellLocationMask = (1 << 22) - 1;
-const uint64 kCellIdMask = (1 << 18) - 1;
-const uint64 kCellTimestampMask = (1 << 20) - 1;
-const uint64 kCellReuseMask = (1 << 4) - 1;
-const uint8 kCellStateMask = (1 << 3) - 1;
-const uint8 kCellGroupMask = (1 << 3) - 1;
-const uint8 kCellSumMask = (1 << 2) - 1;
+const uint64_t kCellLocationMask = (1 << 22) - 1;
+const uint64_t kCellIdMask = (1 << 18) - 1;
+const uint64_t kCellTimestampMask = (1 << 20) - 1;
+const uint64_t kCellReuseMask = (1 << 4) - 1;
+const uint8_t kCellStateMask = (1 << 3) - 1;
+const uint8_t kCellGroupMask = (1 << 3) - 1;
+const uint8_t kCellSumMask = (1 << 2) - 1;
 
-const uint64 kCellSmallTableLocationMask = (1 << 16) - 1;
-const uint64 kCellSmallTableIdMask = (1 << 24) - 1;
+const uint64_t kCellSmallTableLocationMask = (1 << 16) - 1;
+const uint64_t kCellSmallTableIdMask = (1 << 24) - 1;
 
 const int kCellIdOffset = 22;
 const int kCellTimestampOffset = 40;
 const int kCellReuseOffset = 60;
 const int kCellGroupOffset = 3;
 const int kCellSumOffset = 6;
 
 const int kCellSmallTableIdOffset = 16;
 
 // The number of bits that a hash has to be shifted to grab the part that
 // defines the cell id.
 const int kHashShift = 14;
 const int kSmallTableHashShift = 8;
 
 // Unfortunately we have to break the abstaction a little here: the file number
 // where entries are stored is outside of the control of this code, and it is
 // usually part of the stored address. However, for small tables we only store
 // 16 bits of the address so the file number is never stored on a cell. We have
 // to infere the file number from the type of entry (normal vs evicted), and
 // the knowledge that given that the table will not keep more than 64k entries,
 // a single file of each type is enough.
 const int kEntriesFile = disk_cache::BLOCK_ENTRIES - 1;
 const int kEvictedEntriesFile = disk_cache::BLOCK_EVICTED - 1;
 const int kMaxLocation = 1 << 22;
 const int kMinFileNumber = 1 << 16;
 
-uint32 GetCellLocation(const IndexCell& cell) {
+uint32_t GetCellLocation(const IndexCell& cell) {
   return cell.first_part & kCellLocationMask;
 }
 
-uint32 GetCellSmallTableLocation(const IndexCell& cell) {
+uint32_t GetCellSmallTableLocation(const IndexCell& cell) {
   return cell.first_part & kCellSmallTableLocationMask;
 }
 
-uint32 GetCellId(const IndexCell& cell) {
+uint32_t GetCellId(const IndexCell& cell) {
   return (cell.first_part >> kCellIdOffset) & kCellIdMask;
 }
 
-uint32 GetCellSmallTableId(const IndexCell& cell) {
+uint32_t GetCellSmallTableId(const IndexCell& cell) {
   return (cell.first_part >> kCellSmallTableIdOffset) &
          kCellSmallTableIdMask;
 }
 
 int GetCellTimestamp(const IndexCell& cell) {
   return (cell.first_part >> kCellTimestampOffset) & kCellTimestampMask;
 }
 
 int GetCellReuse(const IndexCell& cell) {
   return (cell.first_part >> kCellReuseOffset) & kCellReuseMask;
 }
 
 int GetCellState(const IndexCell& cell) {
   return cell.last_part & kCellStateMask;
 }
 
 int GetCellGroup(const IndexCell& cell) {
   return (cell.last_part >> kCellGroupOffset) & kCellGroupMask;
 }
 
 int GetCellSum(const IndexCell& cell) {
   return (cell.last_part >> kCellSumOffset) & kCellSumMask;
 }
 
-void SetCellLocation(IndexCell* cell, uint32 address) {
-  DCHECK_LE(address, static_cast<uint32>(kCellLocationMask));
+void SetCellLocation(IndexCell* cell, uint32_t address) {
+  DCHECK_LE(address, static_cast<uint32_t>(kCellLocationMask));
   cell->first_part &= ~kCellLocationMask;
   cell->first_part |= address;
 }
 
-void SetCellSmallTableLocation(IndexCell* cell, uint32 address) {
-  DCHECK_LE(address, static_cast<uint32>(kCellSmallTableLocationMask));
+void SetCellSmallTableLocation(IndexCell* cell, uint32_t address) {
+  DCHECK_LE(address, static_cast<uint32_t>(kCellSmallTableLocationMask));
   cell->first_part &= ~kCellSmallTableLocationMask;
   cell->first_part |= address;
 }
 
-void SetCellId(IndexCell* cell, uint32 hash) {
-  DCHECK_LE(hash, static_cast<uint32>(kCellIdMask));
+void SetCellId(IndexCell* cell, uint32_t hash) {
+  DCHECK_LE(hash, static_cast<uint32_t>(kCellIdMask));
   cell->first_part &= ~(kCellIdMask << kCellIdOffset);
-  cell->first_part |= static_cast<int64>(hash) << kCellIdOffset;
+  cell->first_part |= static_cast<int64_t>(hash) << kCellIdOffset;
 }
 
-void SetCellSmallTableId(IndexCell* cell, uint32 hash) {
-  DCHECK_LE(hash, static_cast<uint32>(kCellSmallTableIdMask));
+void SetCellSmallTableId(IndexCell* cell, uint32_t hash) {
+  DCHECK_LE(hash, static_cast<uint32_t>(kCellSmallTableIdMask));
   cell->first_part &= ~(kCellSmallTableIdMask << kCellSmallTableIdOffset);
-  cell->first_part |= static_cast<int64>(hash) << kCellSmallTableIdOffset;
+  cell->first_part |= static_cast<int64_t>(hash) << kCellSmallTableIdOffset;
 }
 
 void SetCellTimestamp(IndexCell* cell, int timestamp) {
   DCHECK_LT(timestamp, 1 << 20);
   DCHECK_GE(timestamp, 0);
   cell->first_part &= ~(kCellTimestampMask << kCellTimestampOffset);
-  cell->first_part |= static_cast<int64>(timestamp) << kCellTimestampOffset;
+  cell->first_part |= static_cast<int64_t>(timestamp) << kCellTimestampOffset;
 }
 
 void SetCellReuse(IndexCell* cell, int count) {
   DCHECK_LT(count, 16);
   DCHECK_GE(count, 0);
   cell->first_part &= ~(kCellReuseMask << kCellReuseOffset);
-  cell->first_part |= static_cast<int64>(count) << kCellReuseOffset;
+  cell->first_part |= static_cast<int64_t>(count) << kCellReuseOffset;
 }
 
 void SetCellState(IndexCell* cell, disk_cache::EntryState state) {
   cell->last_part &= ~kCellStateMask;
   cell->last_part |= state;
 }
 
 void SetCellGroup(IndexCell* cell, disk_cache::EntryGroup group) {
   cell->last_part &= ~(kCellGroupMask << kCellGroupOffset);
   cell->last_part |= group << kCellGroupOffset;
 }
 
 void SetCellSum(IndexCell* cell, int sum) {
   DCHECK_LT(sum, 4);
   DCHECK_GE(sum, 0);
   cell->last_part &= ~(kCellSumMask << kCellSumOffset);
   cell->last_part |= sum << kCellSumOffset;
 }
 
 // This is a very particular way to calculate the sum, so it will not match if
 // compared a gainst a pure 2 bit, modulo 2 sum.
 int CalculateCellSum(const IndexCell& cell) {
-  uint32* words = bit_cast<uint32*>(&cell);
-  uint8* bytes = bit_cast<uint8*>(&cell);
-  uint32 result = words[0] + words[1];
+  uint32_t* words = bit_cast<uint32_t*>(&cell);
+  uint8_t* bytes = bit_cast<uint8_t*>(&cell);
+  uint32_t result = words[0] + words[1];
   result += result >> 16;
   result += (result >> 8) + (bytes[8] & 0x3f);
   result += result >> 4;
   result += result >> 2;
   return result & 3;
 }
 
 bool SanityCheck(const IndexCell& cell) {
   if (GetCellSum(cell) != CalculateCellSum(cell))
     return false;
@@ skipping 74 matching lines @@
     iterator->cells.clear();
   }
   if (time == iterator->timestamp) {
     CellInfo cell_info = { cell.hash(), cell.GetAddress() };
     iterator->cells.push_back(cell_info);
   }
 }
 
 void InitIterator(IndexIterator* iterator) {
   iterator->cells.clear();
-  iterator->timestamp = iterator->forward ? kint32max : 0;
+  iterator->timestamp =
+      iterator->forward ? std::numeric_limits<int32_t>::max() : 0;
 }
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryCell::~EntryCell() {
 }
 
 bool EntryCell::IsValid() const {
   return GetCellLocation(cell_) != 0;
 }
 
 // This code has to map the cell address (up to 22 bits) to a general cache Addr
 // (up to 24 bits of general addressing). It also set the implied file_number
 // in the case of small tables. See also the comment by the definition of
 // kEntriesFile.
 Addr EntryCell::GetAddress() const {
-  uint32 location = GetLocation();
+  uint32_t location = GetLocation();
   int file_number = FileNumberFromLocation(location);
   if (small_table_) {
     DCHECK_EQ(0, file_number);
     file_number = (GetGroup() == ENTRY_EVICTED) ? kEvictedEntriesFile :
                                                   kEntriesFile;
   }
   DCHECK_NE(0, file_number);
   FileType file_type = (GetGroup() == ENTRY_EVICTED) ? BLOCK_EVICTED :
                                                        BLOCK_ENTRIES;
   return Addr(file_type, 1, file_number, StartBlockFromLocation(location));
@@ skipping 25 matching lines @@
 
 void EntryCell::SetReuse(int count) {
   SetCellReuse(&cell_, count);
 }
 
 void EntryCell::SetTimestamp(int timestamp) {
   SetCellTimestamp(&cell_, timestamp);
 }
 
 // Static.
-EntryCell EntryCell::GetEntryCellForTest(int32 cell_num,
-                                         uint32 hash,
+EntryCell EntryCell::GetEntryCellForTest(int32_t cell_num,
+                                         uint32_t hash,
                                          Addr address,
                                          IndexCell* cell,
                                          bool small_table) {
   if (cell) {
     EntryCell entry_cell(cell_num, hash, *cell, small_table);
     return entry_cell;
   }
 
   return EntryCell(cell_num, hash, address, small_table);
 }
 
 void EntryCell::SerializaForTest(IndexCell* destination) {
   FixSum();
   Serialize(destination);
 }
 
 EntryCell::EntryCell() : cell_num_(0), hash_(0), small_table_(false) {
   cell_.Clear();
 }
 
-EntryCell::EntryCell(int32 cell_num,
-                     uint32 hash,
+EntryCell::EntryCell(int32_t cell_num,
+                     uint32_t hash,
                      Addr address,
                      bool small_table)
-    : cell_num_(cell_num),
-      hash_(hash),
-      small_table_(small_table) {
+    : cell_num_(cell_num), hash_(hash), small_table_(small_table) {
   DCHECK(IsValidAddress(address) || !address.value());
 
   cell_.Clear();
   SetCellState(&cell_, ENTRY_NEW);
   SetCellGroup(&cell_, ENTRY_NO_USE);
   if (small_table) {
     DCHECK(address.FileNumber() == kEntriesFile ||
            address.FileNumber() == kEvictedEntriesFile);
     SetCellSmallTableLocation(&cell_, address.start_block());
     SetCellSmallTableId(&cell_, hash >> kSmallTableHashShift);
   } else {
-    uint32 location = address.FileNumber() << 16 | address.start_block();
+    uint32_t location = address.FileNumber() << 16 | address.start_block();
     SetCellLocation(&cell_, location);
     SetCellId(&cell_, hash >> kHashShift);
   }
 }
 
-EntryCell::EntryCell(int32 cell_num,
-                     uint32 hash,
+EntryCell::EntryCell(int32_t cell_num,
+                     uint32_t hash,
                      const IndexCell& cell,
                      bool small_table)
     : cell_num_(cell_num),
       hash_(hash),
       cell_(cell),
-      small_table_(small_table) {
-}
+      small_table_(small_table) {}
 
 void EntryCell::FixSum() {
   SetCellSum(&cell_, CalculateCellSum(cell_));
 }
 
-uint32 EntryCell::GetLocation() const {
+uint32_t EntryCell::GetLocation() const {
   if (small_table_)
     return GetCellSmallTableLocation(cell_);
 
   return GetCellLocation(cell_);
 }
 
-uint32 EntryCell::RecomputeHash() {
+uint32_t EntryCell::RecomputeHash() {
   if (small_table_) {
     hash_ &= (1 << kSmallTableHashShift) - 1;
     hash_ |= GetCellSmallTableId(cell_) << kSmallTableHashShift;
     return hash_;
   }
 
   hash_ &= (1 << kHashShift) - 1;
   hash_ |= GetCellId(cell_) << kHashShift;
   return hash_;
 }
@@ skipping 107 matching lines @@
   // bitmap with 1 bit per cell, and that bitmap has num_words 32-bit words.
   int num_words = (header_->table_len + 31) / 32;
 
   if (old_extra_table) {
     // All the cells from the extra table are moving to the new tables so before
     // creating the bitmaps, clear the part of the bitmap referring to the extra
     // table.
     int old_main_table_bit_words = ((mask_ >> 1) + 1) * kCellsPerBucket / 32;
     DCHECK_GT(num_words, old_main_table_bit_words);
     memset(params->index_bitmap->bitmap + old_main_table_bit_words, 0,
-           (num_words - old_main_table_bit_words) * sizeof(int32));
+           (num_words - old_main_table_bit_words) * sizeof(int32_t));
 
     DCHECK(growing);
     int old_num_words = (backup_header_.get()->table_len + 31) / 32;
     DCHECK_GT(old_num_words, old_main_table_bit_words);
     memset(backup_bitmap_storage_.get() + old_main_table_bit_words, 0,
-           (old_num_words - old_main_table_bit_words) * sizeof(int32));
+           (old_num_words - old_main_table_bit_words) * sizeof(int32_t));
   }
   bitmap_.reset(new Bitmap(params->index_bitmap->bitmap, header_->table_len,
                            num_words));
 
   if (growing) {
     int old_num_words = (backup_header_.get()->table_len + 31) / 32;
     DCHECK_GE(num_words, old_num_words);
-    scoped_ptr<uint32[]> storage(new uint32[num_words]);
+    scoped_ptr<uint32_t[]> storage(new uint32_t[num_words]);
     memcpy(storage.get(), backup_bitmap_storage_.get(),
-           old_num_words * sizeof(int32));
+           old_num_words * sizeof(int32_t));
     memset(storage.get() + old_num_words, 0,
-           (num_words - old_num_words) * sizeof(int32));
+           (num_words - old_num_words) * sizeof(int32_t));
 
     backup_bitmap_storage_.swap(storage);
     backup_header_->table_len = header_->table_len;
   } else {
     backup_bitmap_storage_.reset(params->backup_bitmap.release());
     backup_header_.reset(params->backup_header.release());
   }
 
   num_words = (backup_header_->table_len + 31) / 32;
   backup_bitmap_.reset(new Bitmap(backup_bitmap_storage_.get(),
@@ skipping 23 matching lines @@
 
 // The general method for locating cells is to:
 // 1. Get the first bucket. This usually means directly indexing the table (as
 //     this method does), or iterating through all possible buckets.
 // 2. Iterate through all the cells in that first bucket.
 // 3. If there is a linked bucket, locate it directly in the extra table.
 // 4. Go back to 2, as needed.
 //
 // One consequence of this pattern is that we never start looking at buckets in
 // the extra table, unless we are following a link from the main table.
-EntrySet IndexTable::LookupEntries(uint32 hash) {
+EntrySet IndexTable::LookupEntries(uint32_t hash) {
   EntrySet entries;
   int bucket_num = static_cast<int>(hash & mask_);
   IndexBucket* bucket = &main_table_[bucket_num];
   do {
     for (int i = 0; i < kCellsPerBucket; i++) {
       IndexCell* current_cell = &bucket->cells[i];
       if (!GetLocation(*current_cell))
         continue;
       if (!SanityCheck(*current_cell)) {
         NOTREACHED();
@@ skipping 16 matching lines @@
             entries.evicted_count++;
         }
       }
     }
     bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
                                &bucket);
   } while (bucket_num);
   return entries;
 }
 
-EntryCell IndexTable::CreateEntryCell(uint32 hash, Addr address) {
+EntryCell IndexTable::CreateEntryCell(uint32_t hash, Addr address) {
   DCHECK(IsValidAddress(address));
   DCHECK(address.FileNumber() || address.start_block());
 
   int bucket_num = static_cast<int>(hash & mask_);
   int cell_num = 0;
   IndexBucket* bucket = &main_table_[bucket_num];
   IndexCell* current_cell = NULL;
   bool found = false;
   do {
     for (int i = 0; i < kCellsPerBucket && !found; i++) {
@@ skipping 33 matching lines @@
   if (found) {
     bitmap_->Set(cell_num, true);
     backup_bitmap_->Set(cell_num, true);
     header()->used_cells++;
     modified_ = true;
   }
 
   return entry_cell;
 }
 
-EntryCell IndexTable::FindEntryCell(uint32 hash, Addr address) {
+EntryCell IndexTable::FindEntryCell(uint32_t hash, Addr address) {
   return FindEntryCellImpl(hash, address, false);
 }
 
 int IndexTable::CalculateTimestamp(Time time) {
   TimeDelta delta = time - Time::FromInternalValue(header_->base_time);
   return std::max(delta.InMinutes(), 0);
 }
 
 base::Time IndexTable::TimeFromTimestamp(int timestamp) {
   return Time::FromInternalValue(header_->base_time) +
          TimeDelta::FromMinutes(timestamp);
 }
 
-void IndexTable::SetSate(uint32 hash, Addr address, EntryState state) {
+void IndexTable::SetSate(uint32_t hash, Addr address, EntryState state) {
   EntryCell cell = FindEntryCellImpl(hash, address, state == ENTRY_FREE);
   if (!cell.IsValid()) {
     NOTREACHED();
     return;
   }
 
   EntryState old_state = cell.GetState();
   switch (state) {
     case ENTRY_FREE:
       DCHECK_EQ(old_state, ENTRY_DELETED);
@@ skipping 27 matching lines @@
     cell.Clear();
     Write(cell);
     header()->used_cells--;
     return;
   }
   cell.SetState(state);
 
   Save(&cell);
 }
 
-void IndexTable::UpdateTime(uint32 hash, Addr address, base::Time current) {
+void IndexTable::UpdateTime(uint32_t hash, Addr address, base::Time current) {
   EntryCell cell = FindEntryCell(hash, address);
   if (!cell.IsValid())
     return;
 
   int minutes = CalculateTimestamp(current);
 
   // Keep about 3 months of headroom.
   const int kMaxTimestamp = (1 << 20) - 60 * 24 * 90;
   if (minutes > kMaxTimestamp) {
     // TODO(rvargas):
@@ skipping 44 matching lines @@
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(num_bytes));
   memcpy(buffer->data(), header_, sizeof(*header_));
   memcpy(buffer->data() + sizeof(*header_), backup_bitmap_storage_.get(),
          num_words * 4);
   backend_->SaveIndex(buffer.get(), num_bytes);
   modified_ = false;
 }
 
 // -----------------------------------------------------------------------
 
-EntryCell IndexTable::FindEntryCellImpl(uint32 hash, Addr address,
+EntryCell IndexTable::FindEntryCellImpl(uint32_t hash,
+                                        Addr address,
                                         bool allow_deleted) {
   int bucket_num = static_cast<int>(hash & mask_);
   IndexBucket* bucket = &main_table_[bucket_num];
   do {
     for (int i = 0; i < kCellsPerBucket; i++) {
       IndexCell* current_cell = &bucket->cells[i];
       if (!GetLocation(*current_cell))
         continue;
       DCHECK(SanityCheck(*current_cell));
       if (IsHashMatch(*current_cell, hash)) {
@@ skipping 34 matching lines @@
     }
   }
 
   if (current_state == ENTRY_FIXING)
     backend_->FixCell(cell);
 }
 
 void IndexTable::Write(const EntryCell& cell) {
   IndexBucket* bucket = NULL;
   int bucket_num = cell.cell_num() / kCellsPerBucket;
-  if (bucket_num < static_cast<int32>(mask_ + 1)) {
+  if (bucket_num < static_cast<int32_t>(mask_ + 1)) {
     bucket = &main_table_[bucket_num];
   } else {
     DCHECK_LE(bucket_num, header()->max_bucket);
     bucket = &extra_table_[bucket_num - (mask_ + 1)];
   }
 
   int cell_number = cell.cell_num() % kCellsPerBucket;
   if (GetLocation(bucket->cells[cell_number]) && cell.GetLocation()) {
     DCHECK_EQ(cell.GetLocation(),
               GetLocation(bucket->cells[cell_number]));
@@ skipping 20 matching lines @@
 
 void IndexTable::WalkTables(int limit_time,
                             IndexIterator* no_use,
                             IndexIterator* low_use,
                             IndexIterator* high_use) {
   header_->num_no_use_entries = 0;
   header_->num_low_use_entries = 0;
   header_->num_high_use_entries = 0;
   header_->num_evicted_entries = 0;
 
-  for (int i = 0; i < static_cast<int32>(mask_ + 1); i++) {
+  for (int i = 0; i < static_cast<int32_t>(mask_ + 1); i++) {
     int bucket_num = i;
     IndexBucket* bucket = &main_table_[i];
     do {
       UpdateFromBucket(bucket, i, limit_time, no_use, low_use, high_use);
 
       bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
                                  &bucket);
     } while (bucket_num);
   }
   header_->num_entries = header_->num_no_use_entries +
@@ skipping 48 matching lines @@
 void IndexTable::MoveCells(IndexBucket* old_extra_table) {
   int max_hash = (mask_ + 1) / 2;
   int max_bucket = header()->max_bucket;
   header()->max_bucket = mask_;
   int used_cells = header()->used_cells;
 
   // Consider a large cache: a cell stores the upper 18 bits of the hash
   // (h >> 14). If the table is say 8 times the original size (growing from 4x),
   // the bit that we are interested in would be the 3rd bit of the stored value,
   // in other words 'multiplier' >> 1.
-  uint32 new_bit = (1 << extra_bits_) >> 1;
+  uint32_t new_bit = (1 << extra_bits_) >> 1;
 
   scoped_ptr<IndexBucket[]> old_main_table;
   IndexBucket* source_table = main_table_;
   bool upgrade_format = !extra_bits_;
   if (upgrade_format) {
     // This method should deal with migrating a small table to a big one. Given
     // that the first thing to do is read the old table, set small_table_ for
     // the size of the old table. Now, when moving a cell, the result cannot be
     // placed in the old table or we will end up reading it again and attempting
     // to move it, so we have to copy the whole table at once.
@@ skipping 38 matching lines @@
   DCHECK_EQ(header()->used_cells, used_cells);
 
   if (upgrade_format) {
     small_table_ = false;
     header()->flags &= ~SMALL_CACHE;
   }
 }
 
 void IndexTable::MoveSingleCell(IndexCell* current_cell, int cell_num,
                                 int main_table_index, bool growing) {
-  uint32 hash = GetFullHash(*current_cell, main_table_index);
+  uint32_t hash = GetFullHash(*current_cell, main_table_index);
   EntryCell old_cell(cell_num, hash, *current_cell, small_table_);
 
   // This method may be called when moving entries from a small table to a
   // normal table. In that case, the caller (MoveCells) has to read the old
   // table, so it needs small_table_ set to true, but this method needs to
   // write to the new table so small_table_ has to be set to false, and the
   // value restored to true before returning.
   bool upgrade_format = !extra_bits_ && growing;
   if (upgrade_format)
     small_table_ = false;
@@ skipping 33 matching lines @@
     }
   }
   header()->used_cells--;
 }
 
 void IndexTable::HandleMisplacedCell(IndexCell* current_cell, int cell_num,
                                      int main_table_index) {
   NOTREACHED();  // No unit tests yet.
 
   // The cell may be misplaced, or a duplicate cell exists with this data.
-  uint32 hash = GetFullHash(*current_cell, main_table_index);
+  uint32_t hash = GetFullHash(*current_cell, main_table_index);
   MoveSingleCell(current_cell, cell_num, main_table_index, false);
 
   // Now look for a duplicate cell.
   CheckBucketList(hash & mask_);
 }
 
 void IndexTable::CheckBucketList(int bucket_num) {
   typedef std::pair<int, EntryGroup> AddressAndGroup;
   std::set<AddressAndGroup> entries;
   IndexBucket* bucket = &main_table_[bucket_num];
@@ skipping 17 matching lines @@
         continue;
       }
       CheckState(cell);
     }
 
     bucket_num = GetNextBucket(mask_ + 1, header()->max_bucket, extra_table_,
                               &bucket);
   } while (bucket_num);
 }
 
-uint32 IndexTable::GetLocation(const IndexCell& cell) {
+uint32_t IndexTable::GetLocation(const IndexCell& cell) {
   if (small_table_)
     return GetCellSmallTableLocation(cell);
 
   return GetCellLocation(cell);
 }
 
-uint32 IndexTable::GetHashValue(const IndexCell& cell) {
+uint32_t IndexTable::GetHashValue(const IndexCell& cell) {
   if (small_table_)
     return GetCellSmallTableId(cell);
 
   return GetCellId(cell);
 }
 
-uint32 IndexTable::GetFullHash(const IndexCell& cell, uint32 lower_part) {
+uint32_t IndexTable::GetFullHash(const IndexCell& cell, uint32_t lower_part) {
   // It is OK for the high order bits of lower_part to overlap with the stored
   // part of the hash.
   if (small_table_)
     return (GetCellSmallTableId(cell) << kSmallTableHashShift) | lower_part;
 
   return (GetCellId(cell) << kHashShift) | lower_part;
 }
 
 // All the bits stored in the cell should match the provided hash.
-bool IndexTable::IsHashMatch(const IndexCell& cell, uint32 hash) {
+bool IndexTable::IsHashMatch(const IndexCell& cell, uint32_t hash) {
   hash = small_table_ ? hash >> kSmallTableHashShift : hash >> kHashShift;
   return GetHashValue(cell) == hash;
 }
 
-bool IndexTable::MisplacedHash(const IndexCell& cell, uint32 hash) {
+bool IndexTable::MisplacedHash(const IndexCell& cell, uint32_t hash) {
   if (!extra_bits_)
     return false;
 
-  uint32 mask = (1 << extra_bits_) - 1;
+  uint32_t mask = (1 << extra_bits_) - 1;
   hash = small_table_ ? hash >> kSmallTableHashShift : hash >> kHashShift;
   return (GetHashValue(cell) & mask) != (hash & mask);
 }
 
 }  // namespace disk_cache