replace COMPILE_ASSERT with static_assert in net/

net/disk_cache/blockfile/stats.cc

 // 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.
 
 #include "net/disk_cache/blockfile/stats.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/bucket_ranges.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sample_vector.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace {
 
 const int32 kDiskSignature = 0xF01427E0;
 
 struct OnDiskStats {
   int32 signature;
   int size;
   int data_sizes[disk_cache::Stats::kDataSizesLength];
   int64 counters[disk_cache::Stats::MAX_COUNTER];
 };
-COMPILE_ASSERT(sizeof(OnDiskStats) < 512, needs_more_than_2_blocks);
+static_assert(sizeof(OnDiskStats) < 512, "needs more than 2 blocks");
 
 // Returns the "floor" (as opposed to "ceiling") of log base 2 of number.
 int LogBase2(int32 number) {
   unsigned int value = static_cast<unsigned int>(number);
   const unsigned int mask[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
   const unsigned int s[] = {1, 2, 4, 8, 16};
 
   unsigned int result = 0;
   for (int i = 4; i >= 0; i--) {
     if (value & mask[i]) {
@@ skipping 22 matching lines @@
   "Read data",
   "Write data",
   "Open rankings",
   "Get rankings",
   "Fatal error",
   "Last report",
   "Last report timer",
   "Doom recent entries",
   "unused"
 };
-COMPILE_ASSERT(arraysize(kCounterNames) == disk_cache::Stats::MAX_COUNTER,
-               update_the_names);
+static_assert(arraysize(kCounterNames) == disk_cache::Stats::MAX_COUNTER,
+              "update the names");
 
 }  // namespace
 
 namespace disk_cache {
 
 bool VerifyStats(OnDiskStats* stats) {
   if (stats->signature != kDiskSignature)
     return false;
 
   // We don't want to discard the whole cache every time we have one extra
@@ skipping 66 matching lines @@
       data_sizes_[i] = 0;
 
     samples.Accumulate(GetBucketRange(i) / 1024, data_sizes_[i]);
   }
   stats_histogram->AddSamples(samples);
 }
 
 int Stats::StorageSize() {
   // If we have more than 512 bytes of counters, change kDiskSignature so we
   // don't overwrite something else (LoadStats must fail).
-  COMPILE_ASSERT(sizeof(OnDiskStats) <= 256 * 2, use_more_blocks);
+  static_assert(sizeof(OnDiskStats) <= 256 * 2, "use more blocks");
   return 256 * 2;
 }
 
 void Stats::ModifyStorageStats(int32 old_size, int32 new_size) {
   // We keep a counter of the data block size on an array where each entry is
   // the adjusted log base 2 of the size. The first entry counts blocks of 256
   // bytes, the second blocks up to 512 bytes, etc. With 20 entries, the last
   // one stores entries of more than 64 MB
   int new_index = GetStatsBucket(new_size);
   int old_index = GetStatsBucket(old_size);
@@ skipping 124 matching lines @@
   if (size < 20 * 1024)
     return size / 2048 + 1;
 
   // 5 slots more, from 20K to 40K.
   if (size < 40 * 1024)
     return (size - 20 * 1024) / 4096 + 11;
 
   // From this point on, use a logarithmic scale.
   int result =  LogBase2(size) + 1;
 
-  COMPILE_ASSERT(kDataSizesLength > 16, update_the_scale);
+  static_assert(kDataSizesLength > 16, "update the scale");
   if (result >= kDataSizesLength)
     result = kDataSizesLength - 1;
 
   return result;
 }
 
 int Stats::GetRatio(Counters hit, Counters miss) const {
   int64 ratio = GetCounter(hit) * 100;
   if (!ratio)
     return 0;
 
   ratio /= (GetCounter(hit) + GetCounter(miss));
   return static_cast<int>(ratio);
 }
 
 }  // namespace disk_cache