replace COMPILE_ASSERT with static_assert in net/

net/disk_cache/blockfile/disk_format_v3.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.
 
 // The cache is stored on disk as a collection of block-files, plus an index
 // plus a collection of external files.
 //
 // Any data blob bigger than kMaxBlockSize (disk_cache/addr.h) will be stored in
 // a separate file named f_xxx where x is a hexadecimal number. Shorter data
 // will be stored as a series of blocks on a block-file. In any case, CacheAddr
@@ skipping 79 matching lines @@
 };
 
 const int kBaseBitmapBytes = 3968;
 // The IndexBitmap is directly saved to a file named index. The file grows in
 // page increments (4096 bytes), but all bits don't have to be in use at any
 // given time. The required file size can be computed from header.table_len.
 struct IndexBitmap {
   IndexHeaderV3   header;
   uint32          bitmap[kBaseBitmapBytes / 4];  // First page of the bitmap.
 };
-COMPILE_ASSERT(sizeof(IndexBitmap) == 4096, bad_IndexHeader);
+static_assert(sizeof(IndexBitmap) == 4096, "bad IndexHeader");
 
 // Possible states for a given entry.
 enum EntryState {
   ENTRY_FREE = 0,   // Available slot.
   ENTRY_NEW,        // The entry is being created.
   ENTRY_OPEN,       // The entry is being accessed.
   ENTRY_MODIFIED,   // The entry is being modified.
   ENTRY_DELETED,    // The entry is being deleted.
   ENTRY_FIXING,     // Inconsistent state. The entry is being verified.
   ENTRY_USED        // The slot is in use (entry is present).
 };
-COMPILE_ASSERT(ENTRY_USED <= 7, state_uses_3_bits);
+static_assert(ENTRY_USED <= 7, "state uses 3 bits");
 
 enum EntryGroup {
   ENTRY_NO_USE = 0,   // The entry has not been reused.
   ENTRY_LOW_USE,      // The entry has low reuse.
   ENTRY_HIGH_USE,     // The entry has high reuse.
   ENTRY_RESERVED,     // Reserved for future use.
   ENTRY_EVICTED       // The entry was deleted.
 };
-COMPILE_ASSERT(ENTRY_USED <= 7, group_uses_3_bits);
+static_assert(ENTRY_USED <= 7, "group uses 3 bits");
 
 #pragma pack(push, 1)
 struct IndexCell {
   void Clear() { memset(this, 0, sizeof(*this)); }
 
   // A cell is a 9 byte bit-field that stores 7 values:
   //   location : 22 bits
   //   id : 18 bits
   //   timestamp : 20 bits
   //   reuse : 4 bits
@@ skipping 44 matching lines @@
   // to a deleted entry, the regular cache address may look something like
   //     BLOCK_EVICTED + 1 block + file number 6 + entry number 0x1234
   //     so Addr = 0xf0061234
   //
   // If that same Addr is stored on a large table, the location field would be
   // 0x61234
 
   uint64      first_part;
   uint8       last_part;
 };
-COMPILE_ASSERT(sizeof(IndexCell) == 9, bad_IndexCell);
+static_assert(sizeof(IndexCell) == 9, "bad IndexCell");
 
 const int kCellsPerBucket = 4;
 struct IndexBucket {
   IndexCell   cells[kCellsPerBucket];
   int32       next;
   uint32      hash;  // The high order byte is reserved (should be zero).
 };
-COMPILE_ASSERT(sizeof(IndexBucket) == 44, bad_IndexBucket);
+static_assert(sizeof(IndexBucket) == 44, "bad IndexBucket");
 const int kBytesPerCell = 44 / kCellsPerBucket;
 
 // The main cache index. Backed by a file named index_tb1.
 // The extra table (index_tb2) has a similar format, but different size.
 struct Index {
   // Default size. Actual size controlled by header.table_len.
   IndexBucket table[kBaseTableLen / kCellsPerBucket];
 };
 #pragma pack(pop)
 
@@ skipping 13 matching lines @@
   int32       key_len;
   int32       data_size[4];       // We can store up to 4 data streams for each
   CacheAddr   data_addr[4];       // entry.
   uint32      data_hash[4];
   uint64      creation_time;
   uint64      last_modified_time;
   uint64      last_access_time;
   int32       pad[3];
   uint32      self_hash;
 };
-COMPILE_ASSERT(sizeof(EntryRecord) == 104, bad_EntryRecord);
+static_assert(sizeof(EntryRecord) == 104, "bad EntryRecord");
 
 struct ShortEntryRecord {
   uint32      hash;
   uint32      pad1;
   uint8       reuse_count;
   uint8       refetch_count;
   int8        state;              // Current EntryState.
   uint8       flags;
   int32       key_len;
   uint64      last_access_time;
   uint32      long_hash[5];
   uint32      self_hash;
 };
-COMPILE_ASSERT(sizeof(ShortEntryRecord) == 48, bad_ShortEntryRecord);
+static_assert(sizeof(ShortEntryRecord) == 48, "bad ShortEntryRecord");
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_DISK_FORMAT_V3_H_