Convert COMPILE_ASSERT to static_assert

minidump/minidump_system_info_writer.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 29 matching lines @@
 }
 
 void MinidumpSystemInfoWriter::SetCPUX86Vendor(uint32_t ebx,
                                                uint32_t edx,
                                                uint32_t ecx) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(system_info_.ProcessorArchitecture == kMinidumpCPUArchitectureX86 ||
          system_info_.ProcessorArchitecture ==
              kMinidumpCPUArchitectureX86Win64);
 
-  COMPILE_ASSERT(arraysize(system_info_.Cpu.X86CpuInfo.VendorId) == 3,
-                 vendor_id_must_have_3_elements);
+  static_assert(arraysize(system_info_.Cpu.X86CpuInfo.VendorId) == 3,
+                "vendor id must have 3 elements");

[Mark Mentovai, 2014/10/01 18:57:55]

I’d say to call this one VendorId, and the same on line 66. And on line 109,
call it ProcessorFeatures. These ought to match the things they’re testing.

[scottmg, 2014/10/01 19:27:40]

Done.

 
   system_info_.Cpu.X86CpuInfo.VendorId[0] = ebx;
   system_info_.Cpu.X86CpuInfo.VendorId[1] = edx;
   system_info_.Cpu.X86CpuInfo.VendorId[2] = ecx;
 }
 
 void MinidumpSystemInfoWriter::SetCPUX86VendorString(
     const std::string& vendor) {
   DCHECK_EQ(state(), kStateMutable);
   CHECK_EQ(vendor.size(), sizeof(system_info_.Cpu.X86CpuInfo.VendorId));
 
   uint32_t registers[3];
-  COMPILE_ASSERT(
+  static_assert(
       sizeof(registers) == sizeof(system_info_.Cpu.X86CpuInfo.VendorId),
-      vendor_id_sizes_must_be_equal);
+      "vendor id sizes must be equal");
 
   for (size_t index = 0; index < arraysize(registers); ++index) {
     memcpy(&registers[index],
            &vendor[index * sizeof(*registers)],
            sizeof(*registers));
   }
 
   SetCPUX86Vendor(registers[0], registers[1], registers[2]);
 }
 
@@ skipping 21 matching lines @@
   system_info_.Cpu.X86CpuInfo.AMDExtendedCpuFeatures = extended_features;
 }
 
 void MinidumpSystemInfoWriter::SetCPUOtherFeatures(uint64_t features_0,
                                                    uint64_t features_1) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(system_info_.ProcessorArchitecture != kMinidumpCPUArchitectureX86 &&
          system_info_.ProcessorArchitecture !=
              kMinidumpCPUArchitectureX86Win64);
 
-  COMPILE_ASSERT(
-      arraysize(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2,
-      processor_features_must_have_2_elements);
+  static_assert(arraysize(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2,
+                "processor features must have 2 elements");
 
   system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[0] = features_0;
   system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[1] = features_1;
 }
 
 bool MinidumpSystemInfoWriter::Freeze() {
   DCHECK_EQ(state(), kStateMutable);
   CHECK(csd_version_);
 
   if (!MinidumpStreamWriter::Freeze()) {
@@ skipping 23 matching lines @@
   DCHECK_EQ(state(), kStateWritable);
 
   return file_writer->Write(&system_info_, sizeof(system_info_));
 }
 
 MinidumpStreamType MinidumpSystemInfoWriter::StreamType() const {
   return kMinidumpStreamTypeSystemInfo;
 }
 
 }  // namespace crashpad