Switch to static_assert in base/.

base/strings/safe_sprintf.cc

 // Copyright 2013 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 "base/strings/safe_sprintf.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include <limits>
@@ skipping 54 matching lines @@
 namespace {
 const size_t kSSizeMaxConst = ((size_t)(ssize_t)-1) >> 1;
 
 const char kUpCaseHexDigits[]   = "0123456789ABCDEF";
 const char kDownCaseHexDigits[] = "0123456789abcdef";
 }
 
 #if defined(NDEBUG)
 // We would like to define kSSizeMax as std::numeric_limits<ssize_t>::max(),
 // but C++ doesn't allow us to do that for constants. Instead, we have to
-// use careful casting and shifting. We later use a COMPILE_ASSERT to
+// use careful casting and shifting. We later use a static_assert to
 // verify that this worked correctly.
 namespace {
 const size_t kSSizeMax = kSSizeMaxConst;
 }
 #else  // defined(NDEBUG)
 // For efficiency, we really need kSSizeMax to be a constant. But for unit
 // tests, it should be adjustable. This allows us to verify edge cases without
 // having to fill the entire available address space. As a compromise, we make
 // kSSizeMax adjustable in debug builds, and then only compile that particular
 // part of the unit test in debug builds.
@@ skipping 19 matching lines @@
   // has |size| bytes of writable storage. It is the caller's responsibility
   // to ensure that the buffer is at least one byte in size, so that it fits
   // the trailing NUL that will be added by the destructor. The buffer also
   // must be smaller or equal to kSSizeMax in size.
   Buffer(char* buffer, size_t size)
       : buffer_(buffer),
         size_(size - 1),  // Account for trailing NUL byte
         count_(0) {
 // The following assertion does not build on Mac and Android. This is because
 // static_assert only works with compile-time constants, but mac uses
 // libstdc++4.2 and android uses stlport, which both don't mark

[Mostyn Bramley-Moore, 2015/11/23 06:44:14]

IIRC we use libc++ on OSX and Android now (not sure about IOS), we can probably
enable this check on those platforms.

[Avi (use Gerrit), 2015/11/24 04:49:43]

Done.

 // numeric_limits::max() as constexp.  Likewise, MSVS2013's standard library
 // also doesn't mark max() as constexpr yet. cl.exe supports static_cast but
 // doesn't really implement constexpr yet so it doesn't complain, but clang
 // does.
 #if __cplusplus >= 201103 && !defined(OS_ANDROID) && !defined(OS_MACOSX) && \
     !defined(OS_IOS) && !(defined(__clang__) && defined(OS_WIN))
-    COMPILE_ASSERT(kSSizeMaxConst == \
-                   static_cast<size_t>(std::numeric_limits<ssize_t>::max()),
-                   kSSizeMax_is_the_max_value_of_an_ssize_t);
+    static_assert(kSSizeMaxConst ==
+                      static_cast<size_t>(std::numeric_limits<ssize_t>::max()),
+                  "kSSizeMax_is_the_max_value_of_an_ssize_t");
 #endif
     DEBUG_CHECK(size > 0);
     DEBUG_CHECK(size <= kSSizeMax);
   }
 
   ~Buffer() {
     // The code calling the constructor guaranteed that there was enough space
     // to store a trailing NUL -- and in debug builds, we are actually
     // verifying this with DEBUG_CHECK()s in the constructor. So, we can
     // always unconditionally write the NUL byte in the destructor.  We do not
@@ skipping 544 matching lines @@
     DEBUG_CHECK(src[0] != '%' || src[1] == '%');
     if (src[0] == '%' && src[1] == '%') {
       ++src;
     }
   }
   return buffer.GetCount();
 }
 
 }  // namespace strings
 }  // namespace base