replace COMPILE_ASSERT with static_assert in chrome/common/

chrome/common/mac/mock_launchd.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 "chrome/common/mac/mock_launchd.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
@@ skipping 111 matching lines @@
     ADD_FAILURE();
     return NULL;
   }
 
   CFStringRef env_var =
       base::mac::NSToCFCast(GetServiceProcessLaunchDSocketEnvVar());
   base::ScopedCFTypeRef<CFStringRef> socket_path(CFStringCreateWithCString(
       kCFAllocatorDefault, pipe_name_.c_str(), kCFStringEncodingUTF8));
   const void *keys[] = { env_var };
   const void *values[] = { socket_path };
-  COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
+  static_assert(arraysize(keys) == arraysize(values),
+                "keys must have the same number of elements as values");
   return CFDictionaryCreate(kCFAllocatorDefault,
                             keys,
                             values,
                             arraysize(keys),
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 CFDictionaryRef MockLaunchd::CopyJobDictionary(CFStringRef label) {
   if (!as_service_) {
     scoped_ptr<MultiProcessLock> running_lock(
         TakeNamedLock(pipe_name_, false));
     if (running_lock.get())
       return NULL;
   }
 
   CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM);
   CFStringRef program_pid = CFSTR(LAUNCH_JOBKEY_PID);
   const void *keys[] = { program, program_pid };
   base::ScopedCFTypeRef<CFStringRef> path(
       base::SysUTF8ToCFStringRef(file_.value()));
   int process_id = base::GetCurrentProcId();
   base::ScopedCFTypeRef<CFNumberRef> pid(
       CFNumberCreate(NULL, kCFNumberIntType, &process_id));
   const void *values[] = { path, pid };
-  COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
+  static_assert(arraysize(keys) == arraysize(values),
+                "keys must have the same number of elements as values");
   return CFDictionaryCreate(kCFAllocatorDefault,
                             keys,
                             values,
                             arraysize(keys),
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 CFDictionaryRef MockLaunchd::CopyDictionaryByCheckingIn(CFErrorRef* error) {
   checkin_called_ = true;
   CFStringRef program = CFSTR(LAUNCH_JOBKEY_PROGRAM);
   CFStringRef program_args = CFSTR(LAUNCH_JOBKEY_PROGRAMARGUMENTS);
   base::ScopedCFTypeRef<CFStringRef> path(
       base::SysUTF8ToCFStringRef(file_.value()));
   const void *array_values[] = { path.get() };
   base::ScopedCFTypeRef<CFArrayRef> args(CFArrayCreate(
       kCFAllocatorDefault, array_values, 1, &kCFTypeArrayCallBacks));
 
   if (!create_socket_) {
     const void *keys[] = { program, program_args };
     const void *values[] = { path, args };
-    COMPILE_ASSERT(arraysize(keys) == arraysize(values),
-                   array_sizes_must_match);
+    static_assert(arraysize(keys) == arraysize(values),
+                  "keys must have the same number of elements as values");
     return CFDictionaryCreate(kCFAllocatorDefault,
                               keys,
                               values,
                               arraysize(keys),
                               &kCFTypeDictionaryKeyCallBacks,
                               &kCFTypeDictionaryValueCallBacks);
   }
 
   CFStringRef socket_key = CFSTR(LAUNCH_JOBKEY_SOCKETS);
   int local_pipe = -1;
@@ skipping 31 matching lines @@
   }
 
   base::ScopedCFTypeRef<CFNumberRef> socket_fd(
       CFNumberCreate(NULL, kCFNumberIntType, &local_pipe));
   const void *socket_array_values[] = { socket_fd };
   base::ScopedCFTypeRef<CFArrayRef> sockets(CFArrayCreate(
       kCFAllocatorDefault, socket_array_values, 1, &kCFTypeArrayCallBacks));
   CFStringRef socket_dict_key = CFSTR("ServiceProcessSocket");
   const void *socket_keys[] = { socket_dict_key };
   const void *socket_values[] = { sockets };
-  COMPILE_ASSERT(arraysize(socket_keys) == arraysize(socket_values),
-                 socket_array_sizes_must_match);
+  static_assert(arraysize(socket_keys) == arraysize(socket_values),
+                "socket_keys must have the same number of elements "
+                "as socket_values");
   base::ScopedCFTypeRef<CFDictionaryRef> socket_dict(
       CFDictionaryCreate(kCFAllocatorDefault,
                          socket_keys,
                          socket_values,
                          arraysize(socket_keys),
                          &kCFTypeDictionaryKeyCallBacks,
                          &kCFTypeDictionaryValueCallBacks));
   const void *keys[] = { program, program_args, socket_key };
   const void *values[] = { path, args, socket_dict };
-  COMPILE_ASSERT(arraysize(keys) == arraysize(values), array_sizes_must_match);
+  static_assert(arraysize(keys) == arraysize(values),
+                "keys must have the same number of elements as values");
   return CFDictionaryCreate(kCFAllocatorDefault,
                             keys,
                             values,
                             arraysize(keys),
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 bool MockLaunchd::RemoveJob(CFStringRef label, CFErrorRef* error) {
   remove_called_ = true;
@@ skipping 30 matching lines @@
                               Type type,
                               CFStringRef name) {
   delete_called_ = true;
   return true;
 }
 
 void MockLaunchd::SignalReady() {
   ASSERT_TRUE(as_service_);
   running_lock_.reset(TakeNamedLock(pipe_name_, true));
 }