Remove kint16max.

net/disk_cache/blockfile/disk_format_base.h

 // Copyright (c) 2011 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.
 
 // For a general description of the files used by the cache see file_format.h.
 //
 // A block file is a file designed to store blocks of data of a given size. It
 // is able to store data that spans from one to four consecutive "blocks", and
 // it grows as needed to store up to approximately 65000 blocks. It has a fixed
 // size header used for book keeping such as tracking free of blocks on the
 // file. For example, a block-file for 1KB blocks will grow from 8KB when
 // totally empty to about 64MB when completely full. At that point, data blocks
 // of 1KB will be stored on a second block file that will store the next set of
 // 65000 blocks. The first file contains the number of the second file, and the
 // second file contains the number of a third file, created when the second file
 // reaches its limit. It is important to remember that no matter how long the
 // chain of files is, any given block can be located directly by its address,
 // which contains the file number and starting block inside the file.
 
 #ifndef NET_DISK_CACHE_BLOCKFILE_DISK_FORMAT_BASE_H_
 #define NET_DISK_CACHE_BLOCKFILE_DISK_FORMAT_BASE_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "net/base/net_export.h"
 
 namespace disk_cache {
 
-typedef uint32 CacheAddr;
+typedef uint32_t CacheAddr;
 
-const uint32 kBlockVersion2 = 0x20000;  // Version 2.0.
-const uint32 kBlockCurrentVersion = 0x30000;  // Version 3.0.
+const uint32_t kBlockVersion2 = 0x20000;        // Version 2.0.
+const uint32_t kBlockCurrentVersion = 0x30000;  // Version 3.0.
 
-const uint32 kBlockMagic = 0xC104CAC3;
+const uint32_t kBlockMagic = 0xC104CAC3;
 const int kBlockHeaderSize = 8192;  // Two pages: almost 64k entries
 const int kMaxBlocks = (kBlockHeaderSize - 80) * 8;
 const int kNumExtraBlocks = 1024;  // How fast files grow.
 
 // Bitmap to track used blocks on a block-file.
-typedef uint32 AllocBitmap[kMaxBlocks / 32];
+typedef uint32_t AllocBitmap[kMaxBlocks / 32];
 
 // A block-file is the file used to store information in blocks (could be
 // EntryStore blocks, RankingsNode blocks or user-data blocks).
 // We store entries that can expand for up to 4 consecutive blocks, and keep
 // counters of the number of blocks available for each type of entry. For
 // instance, an entry of 3 blocks is an entry of type 3. We also keep track of
 // where did we find the last entry of that type (to avoid searching the bitmap
 // from the beginning every time).
 // This Structure is the header of a block-file:
 struct BlockFileHeader {
-  uint32          magic;
-  uint32          version;
-  int16           this_file;    // Index of this file.
-  int16           next_file;    // Next file when this one is full.
-  int32           entry_size;   // Size of the blocks of this file.
-  int32           num_entries;  // Number of stored entries.
-  int32           max_entries;  // Current maximum number of entries.
-  int32           empty[4];     // Counters of empty entries for each type.
-  int32           hints[4];     // Last used position for each entry type.
-  volatile int32  updating;     // Keep track of updates to the header.
-  int32           user[5];
+  uint32_t magic;
+  uint32_t version;
+  int16_t this_file;          // Index of this file.
+  int16_t next_file;          // Next file when this one is full.
+  int32_t entry_size;         // Size of the blocks of this file.
+  int32_t num_entries;        // Number of stored entries.
+  int32_t max_entries;        // Current maximum number of entries.
+  int32_t empty[4];           // Counters of empty entries for each type.
+  int32_t hints[4];           // Last used position for each entry type.
+  volatile int32_t updating;  // Keep track of updates to the header.
+  int32_t user[5];
   AllocBitmap     allocation_map;
 };
 
 static_assert(sizeof(BlockFileHeader) == kBlockHeaderSize, "bad header");
 
 // Sparse data support:
 // We keep a two level hierarchy to enable sparse data for an entry: the first
 // level consists of using separate "child" entries to store ranges of 1 MB,
 // and the second level stores blocks of 1 KB inside each child entry.
 //
@@ skipping 25 matching lines @@
 // one of the data streams of the child entry (at index 1), while the control
 // information is stored in another stream (at index 2), both by parents and
 // the children.
 
 // This structure contains the control information for parent and child entries.
 // It is stored at offset 0 of the data stream with index 2.
 // It is possible to write to a child entry in a way that causes the last block
 // to be only partialy filled. In that case, last_block and last_block_len will
 // keep track of that block.
 struct SparseHeader {
-  int64 signature;          // The parent and children signature.
-  uint32 magic;             // Structure identifier (equal to kIndexMagic).
-  int32 parent_key_len;     // Key length for the parent entry.
-  int32 last_block;         // Index of the last written block.
-  int32 last_block_len;     // Lenght of the last written block.
-  int32 dummy[10];
+  int64_t signature;       // The parent and children signature.
+  uint32_t magic;          // Structure identifier (equal to kIndexMagic).
+  int32_t parent_key_len;  // Key length for the parent entry.
+  int32_t last_block;      // Index of the last written block.
+  int32_t last_block_len;  // Lenght of the last written block.
+  int32_t dummy[10];
 };
 
 // The SparseHeader will be followed by a bitmap, as described by this
 // structure.
 struct SparseData {
   SparseHeader header;
-  uint32 bitmap[32];        // Bitmap representation of known children (if this
-                            // is a parent entry), or used blocks (for child
-                            // entries. The size is fixed for child entries but
-                            // not for parents; it can be as small as 4 bytes
-                            // and as large as 8 KB.
+  uint32_t bitmap[32];  // Bitmap representation of known children (if this
+                        // is a parent entry), or used blocks (for child
+                        // entries. The size is fixed for child entries but
+                        // not for parents; it can be as small as 4 bytes
+                        // and as large as 8 KB.
 };
 
 // The number of blocks stored by a child entry.
 const int kNumSparseBits = 1024;
 static_assert(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
               "invalid SparseData bitmap");
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_DISK_FORMAT_BASE_H_