Remove kint16max.

net/disk_cache/blockfile/block_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.
 
 #include "net/disk_cache/blockfile/block_files.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/atomicops.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/disk_cache/blockfile/file_lock.h"
 #include "net/disk_cache/blockfile/stress_support.h"
 #include "net/disk_cache/blockfile/trace.h"
 #include "net/disk_cache/cache_util.h"
 
 using base::TimeTicks;
 
 namespace {
 
 const char kBlockName[] = "data_";
 
 // This array is used to perform a fast lookup of the nibble bit pattern to the
 // type of entry that can be stored there (number of consecutive blocks).
 const char s_types[16] = {4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 
 // Returns the type of block (number of consecutive blocks that can be stored)
 // for a given nibble of the bitmap.
-inline int GetMapBlockType(uint32 value) {
+inline int GetMapBlockType(uint32_t value) {
   value &= 0xf;
   return s_types[value];
 }
 
 }  // namespace
 
 namespace disk_cache {
 
 BlockHeader::BlockHeader() : header_(NULL) {
 }
@@ skipping 26 matching lines @@
     return false;
   }
 
   TimeTicks start = TimeTicks::Now();
   // We are going to process the map on 32-block chunks (32 bits), and on every
   // chunk, iterate through the 8 nibbles where the new block can be located.
   int current = header_->hints[target - 1];
   for (int i = 0; i < header_->max_entries / 32; i++, current++) {
     if (current == header_->max_entries / 32)
       current = 0;
-    uint32 map_block = header_->allocation_map[current];
+    uint32_t map_block = header_->allocation_map[current];
 
     for (int j = 0; j < 8; j++, map_block >>= 4) {
       if (GetMapBlockType(map_block) != target)
         continue;
 
       disk_cache::FileLock lock(header_);
       int index_offset = j * 4 + 4 - target;
       *index = current * 32 + index_offset;
       STRESS_DCHECK(*index / 4 == (*index + size - 1) / 4);
-      uint32 to_add = ((1 << size) - 1) << index_offset;
+      uint32_t to_add = ((1 << size) - 1) << index_offset;
       header_->num_entries++;
 
       // Note that there is no race in the normal sense here, but if we enforce
       // the order of memory accesses between num_entries and allocation_map, we
       // can assert that even if we crash here, num_entries will never be less
       // than the actual number of used blocks.
       base::subtle::MemoryBarrier();
       header_->allocation_map[current] |= to_add;
 
       header_->hints[target - 1] = current;
@@ skipping 14 matching lines @@
   return false;
 }
 
 void BlockHeader::DeleteMapBlock(int index, int size) {
   if (size < 0 || size > kMaxNumBlocks) {
     NOTREACHED();
     return;
   }
   TimeTicks start = TimeTicks::Now();
   int byte_index = index / 8;
-  uint8* byte_map = reinterpret_cast<uint8*>(header_->allocation_map);
-  uint8 map_block = byte_map[byte_index];
+  uint8_t* byte_map = reinterpret_cast<uint8_t*>(header_->allocation_map);
+  uint8_t map_block = byte_map[byte_index];
 
   if (index % 8 >= 4)
     map_block >>= 4;
 
   // See what type of block will be available after we delete this one.
   int bits_at_end = 4 - size - index % 4;
-  uint8 end_mask = (0xf << (4 - bits_at_end)) & 0xf;
+  uint8_t end_mask = (0xf << (4 - bits_at_end)) & 0xf;
   bool update_counters = (map_block & end_mask) == 0;
-  uint8 new_value = map_block & ~(((1 << size) - 1) << (index % 4));
+  uint8_t new_value = map_block & ~(((1 << size) - 1) << (index % 4));
   int new_type = GetMapBlockType(new_value);
 
   disk_cache::FileLock lock(header_);
   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
-  uint8  to_clear = ((1 << size) - 1) << (index % 8);
+  uint8_t to_clear = ((1 << size) - 1) << (index % 8);
   STRESS_DCHECK((byte_map[byte_index] & to_clear) == to_clear);
   byte_map[byte_index] &= ~to_clear;
 
   if (update_counters) {
     if (bits_at_end)
       header_->empty[bits_at_end - 1]--;
     header_->empty[new_type - 1]++;
     STRESS_DCHECK(header_->empty[bits_at_end - 1] >= 0);
   }
   base::subtle::MemoryBarrier();
   header_->num_entries--;
   STRESS_DCHECK(header_->num_entries >= 0);
   LOCAL_HISTOGRAM_TIMES("DiskCache.DeleteBlock", TimeTicks::Now() - start);
 }
 
 // Note that this is a simplified version of DeleteMapBlock().
 bool BlockHeader::UsedMapBlock(int index, int size) {
   if (size < 0 || size > kMaxNumBlocks)
     return false;
 
   int byte_index = index / 8;
-  uint8* byte_map = reinterpret_cast<uint8*>(header_->allocation_map);
-  uint8 map_block = byte_map[byte_index];
+  uint8_t* byte_map = reinterpret_cast<uint8_t*>(header_->allocation_map);
+  uint8_t map_block = byte_map[byte_index];
 
   if (index % 8 >= 4)
     map_block >>= 4;
 
   STRESS_DCHECK((((1 << size) - 1) << (index % 8)) < 0x100);
-  uint8  to_clear = ((1 << size) - 1) << (index % 8);
+  uint8_t to_clear = ((1 << size) - 1) << (index % 8);
   return ((byte_map[byte_index] & to_clear) == to_clear);
 }
 
 void BlockHeader::FixAllocationCounters() {
   for (int i = 0; i < kMaxNumBlocks; i++) {
     header_->hints[i] = 0;
     header_->empty[i] = 0;
   }
 
   for (int i = 0; i < header_->max_entries / 32; i++) {
-    uint32 map_block = header_->allocation_map[i];
+    uint32_t map_block = header_->allocation_map[i];
 
     for (int j = 0; j < 8; j++, map_block >>= 4) {
       int type = GetMapBlockType(map_block);
       if (type)
         header_->empty[type -1]++;
     }
   }
 }
 
 bool BlockHeader::NeedToGrowBlockFile(int block_count) const {
@@ skipping 83 matching lines @@
 }
 
 bool BlockFiles::Init(bool create_files) {
   DCHECK(!init_);
   if (init_)
     return false;
 
   thread_checker_.reset(new base::ThreadChecker);
 
   block_files_.resize(kFirstAdditionalBlockFile);
-  for (int16 i = 0; i < kFirstAdditionalBlockFile; i++) {
+  for (int16_t i = 0; i < kFirstAdditionalBlockFile; i++) {
     if (create_files)
       if (!CreateBlockFile(i, static_cast<FileType>(i + 1), true))
         return false;
 
     if (!OpenBlockFile(i))
       return false;
 
     // Walk this chain of files removing empty ones.
     if (!RemoveEmptyFile(static_cast<FileType>(i + 1)))
       return false;
@@ skipping 157 matching lines @@
 
   scoped_refptr<File> file(new File(base::File(name, flags)));
   if (!file->IsValid())
     return false;
 
   BlockFileHeader header;
   memset(&header, 0, sizeof(header));
   header.magic = kBlockMagic;
   header.version = kBlockVersion2;
   header.entry_size = Addr::BlockSizeForFileType(file_type);
-  header.this_file = static_cast<int16>(index);
-  DCHECK(index <= kint16max && index >= 0);
+  header.this_file = static_cast<int16_t>(index);
+  DCHECK(index <= std::numeric_limits<int16_t>::max() && index >= 0);
 
   return file->Write(&header, sizeof(header), 0);
 }
 
 bool BlockFiles::OpenBlockFile(int index) {
   if (block_files_.size() - 1 < static_cast<unsigned int>(index)) {
     DCHECK(index > 0);
     int to_add = index - static_cast<int>(block_files_.size()) + 1;
     block_files_.resize(block_files_.size() + to_add);
   }
@@ skipping 95 matching lines @@
     break;
   }
   LOCAL_HISTOGRAM_TIMES("DiskCache.GetFileForNewBlock",
                         TimeTicks::Now() - start);
   return file;
 }
 
 MappedFile* BlockFiles::NextFile(MappedFile* file) {
   ScopedFlush flush(file);
   BlockFileHeader* header = reinterpret_cast<BlockFileHeader*>(file->buffer());
-  int16 new_file = header->next_file;
+  int16_t new_file = header->next_file;
   if (!new_file) {
     // RANKINGS is not reported as a type for small entries, but we may be
     // extending the rankings block file.
     FileType type = Addr::RequiredFileType(header->entry_size);
     if (header->entry_size == Addr::BlockSizeForFileType(RANKINGS))
       type = RANKINGS;
 
     new_file = CreateNextBlockFile(type);
     if (!new_file)
       return NULL;
 
     FileLock lock(header);
     header->next_file = new_file;
   }
 
   // Only the block_file argument is relevant for what we want.
   Addr address(BLOCK_256, 1, new_file, 0);
   return GetFile(address);
 }
 
-int16 BlockFiles::CreateNextBlockFile(FileType block_type) {
-  for (int16 i = kFirstAdditionalBlockFile; i <= kMaxBlockFile; i++) {
+int16_t BlockFiles::CreateNextBlockFile(FileType block_type) {
+  for (int16_t i = kFirstAdditionalBlockFile; i <= kMaxBlockFile; i++) {
     if (CreateBlockFile(i, block_type, false))
       return i;
   }
   return 0;
 }
 
 // We walk the list of files for this particular block type, deleting the ones
 // that are empty.
 bool BlockFiles::RemoveEmptyFile(FileType block_type) {
   MappedFile* file = block_files_[block_type - 1];
@@ skipping 112 matching lines @@
 }
 
 base::FilePath BlockFiles::Name(int index) {
   // The file format allows for 256 files.
   DCHECK(index < 256 && index >= 0);
   std::string tmp = base::StringPrintf("%s%d", kBlockName, index);
   return path_.AppendASCII(tmp);
 }
 
 }  // namespace disk_cache