replace COMPILE_ASSERT with static_assert in net/

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
@@ skipping 43 matching lines @@
   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];
   AllocBitmap     allocation_map;
 };
 
-COMPILE_ASSERT(sizeof(BlockFileHeader) == kBlockHeaderSize, bad_header);
+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.
 //
 // Whenever we need to access a particular sparse offset, we first locate the
 // child entry that stores that offset, so we discard the 20 least significant
 // bits of the offset, and end up with the child id. For instance, the child id
 // to store the first megabyte is 0, and the child that should store offset
@@ skipping 42 matching lines @@
   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.
 };
 
 // The number of blocks stored by a child entry.
 const int kNumSparseBits = 1024;
-COMPILE_ASSERT(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
-               Invalid_SparseData_bitmap);
+static_assert(sizeof(SparseData) == sizeof(SparseHeader) + kNumSparseBits / 8,
+              "invalid SparseData bitmap");
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_DISK_FORMAT_BASE_H_