Switch to static_assert in base/.

base/android/jni_android.cc

 // Copyright (c) 2012 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/android/jni_android.h"
 
 #include <map>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_string.h"
@@ skipping 125 matching lines @@
     clazz = env->FindClass(class_name);
   }
   CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
   return ScopedJavaLocalRef<jclass>(env, clazz);
 }
 
 jclass LazyGetClass(
     JNIEnv* env,
     const char* class_name,
     base::subtle::AtomicWord* atomic_class_id) {
-  COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jclass),
-                 AtomicWord_SmallerThan_jMethodID);
+  static_assert(sizeof(subtle::AtomicWord) >= sizeof(jclass),
+                "AtomicWord_SmallerThan_jMethodID");

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

s/jMethodID/jclass/ ?

[Mark Mentovai, 2015/11/23 14:21:37]

Can you get rid of the underscores now that we’re doing this transformation too?
This can be a mechanical transformation: it’s probably pretty easy to sed the
diff you’ve already produced to make a new diff that uses spaces instead of
underscores.

   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_class_id);
   if (value)
     return reinterpret_cast<jclass>(value);
   ScopedJavaGlobalRef<jclass> clazz;
   clazz.Reset(GetClass(env, class_name));
   subtle::AtomicWord null_aw = reinterpret_cast<subtle::AtomicWord>(NULL);
   subtle::AtomicWord cas_result = base::subtle::Release_CompareAndSwap(
       atomic_class_id,
       null_aw,
       reinterpret_cast<subtle::AtomicWord>(clazz.obj()));
@@ skipping 23 matching lines @@
 
 // If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call
 // into ::Get() above. If there's a race, it's ok since the values are the same
 // (and the duplicated effort will happen only once).
 template<MethodID::Type type>
 jmethodID MethodID::LazyGet(JNIEnv* env,
                             jclass clazz,
                             const char* method_name,
                             const char* jni_signature,
                             base::subtle::AtomicWord* atomic_method_id) {
-  COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jmethodID),
-                 AtomicWord_SmallerThan_jMethodID);
+  static_assert(sizeof(subtle::AtomicWord) >= sizeof(jmethodID),
+                "AtomicWord_SmallerThan_jMethodID");
   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_method_id);
   if (value)
     return reinterpret_cast<jmethodID>(value);
   jmethodID id = MethodID::Get<type>(env, clazz, method_name, jni_signature);
   base::subtle::Release_Store(
       atomic_method_id, reinterpret_cast<subtle::AtomicWord>(id));
   return id;
 }
 
 // Various template instantiations.
@@ skipping 88 matching lines @@
       env, static_cast<jstring>(
           env->CallObjectMethod(bytearray_output_stream.obj(),
                                 bytearray_output_stream_tostring)));
 
   return ConvertJavaStringToUTF8(exception_string);
 }
 
 
 }  // namespace android
 }  // namespace base