Mojo: COMPILE_ASSERT -> static_assert in mojo/system and mojo/embedder.

mojo/system/transport_data.cc

 // Copyright 2014 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 "mojo/system/transport_data.h"
 
 #include <string.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/message_in_transit.h"
 
 namespace mojo {
 namespace system {
 
 // The maximum amount of space needed per platform handle.
 // (|{Channel,RawChannel}::GetSerializedPlatformHandleSize()| should always
 // return a value which is at most this. This is only used to calculate
 // |TransportData::kMaxBufferSize|. This value should be a multiple of the
 // alignment in order to simplify calculations, even though the actual amount of
 // space needed need not be a multiple of the alignment.
 const size_t kMaxSizePerPlatformHandle = 8;
-COMPILE_ASSERT(kMaxSizePerPlatformHandle %
-                       MessageInTransit::kMessageAlignment ==
-                   0,
-               kMaxSizePerPlatformHandle_not_a_multiple_of_alignment);
+static_assert(kMaxSizePerPlatformHandle % MessageInTransit::kMessageAlignment ==
+                  0,
+              "kMaxSizePerPlatformHandle not a multiple of alignment");
 
 STATIC_CONST_MEMBER_DEFINITION const size_t
     TransportData::kMaxSerializedDispatcherSize;
 STATIC_CONST_MEMBER_DEFINITION const size_t
     TransportData::kMaxSerializedDispatcherPlatformHandles;
 
 // static
 const size_t TransportData::kMaxPlatformHandles =
     kMaxMessageNumHandles * kMaxSerializedDispatcherPlatformHandles;
 
 // In additional to the header, for each attached (Mojo) handle there'll be a
 // handle table entry and serialized dispatcher data.
 // Note: This definition must follow the one for |kMaxPlatformHandles|;
 // otherwise, we get a static initializer with gcc (but not clang).
 // static
 const size_t TransportData::kMaxBufferSize =
     sizeof(Header) +
     kMaxMessageNumHandles *
         (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) +
     kMaxPlatformHandles * kMaxSizePerPlatformHandle;
 
 struct TransportData::PrivateStructForCompileAsserts {
-  // The size of |Header| must be a multiple of the alignment.
-  COMPILE_ASSERT(sizeof(Header) % MessageInTransit::kMessageAlignment == 0,
-                 sizeof_MessageInTransit_Header_invalid);
-
-  // The maximum serialized dispatcher size must be a multiple of the alignment.
-  COMPILE_ASSERT(kMaxSerializedDispatcherSize %
-                         MessageInTransit::kMessageAlignment ==
-                     0,
-                 kMaxSerializedDispatcherSize_not_a_multiple_of_alignment);
-
-  // The size of |HandleTableEntry| must be a multiple of the alignment.
-  COMPILE_ASSERT(sizeof(HandleTableEntry) %
-                         MessageInTransit::kMessageAlignment ==
-                     0,
-                 sizeof_MessageInTransit_HandleTableEntry_invalid);
+  static_assert(sizeof(Header) % MessageInTransit::kMessageAlignment == 0,
+                "sizeof(MessageInTransit::Header) not a multiple of alignment");
+  static_assert(kMaxSerializedDispatcherSize %
+                        MessageInTransit::kMessageAlignment ==
+                    0,
+                "kMaxSerializedDispatcherSize not a multiple of alignment");
+  static_assert(sizeof(HandleTableEntry) %
+                        MessageInTransit::kMessageAlignment ==
+                    0,
+                "sizeof(MessageInTransit::HandleTableEntry) not a multiple of "
+                "alignment");
 };
 
 TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers,
                              Channel* channel) {
   DCHECK(dispatchers);
   DCHECK(channel);
 
   const size_t num_handles = dispatchers->size();
   DCHECK_GT(num_handles, 0u);
 
@@ skipping 57 matching lines @@
   header->num_handles = static_cast<uint32_t>(num_handles);
   // (Okay to leave |platform_handle_table_offset|, |num_platform_handles|, and
   // |unused| be zero; we'll set the former two later if necessary.)
 
   HandleTableEntry* handle_table = reinterpret_cast<HandleTableEntry*>(
       buffer_.get() + handle_table_start_offset);
   size_t current_offset = serialized_dispatcher_start_offset;
   for (size_t i = 0; i < num_handles; i++) {
     Dispatcher* dispatcher = (*dispatchers)[i].get();
     if (!dispatcher) {
-      COMPILE_ASSERT(Dispatcher::kTypeUnknown == 0,
-                     value_of_Dispatcher_kTypeUnknown_must_be_zero);
+      static_assert(Dispatcher::kTypeUnknown == 0,
+                    "Value of Dispatcher::kTypeUnknown must be 0");
       continue;
     }
 
 #if DCHECK_IS_ON
     size_t old_platform_handles_size =
         platform_handles_ ? platform_handles_->size() : 0;
 #endif
 
     void* destination = buffer_.get() + current_offset;
     size_t actual_size = 0;
@@ skipping 187 matching lines @@
     const void* source = static_cast<const char*>(buffer) + offset;
     (*dispatchers)[i] = Dispatcher::TransportDataAccess::Deserialize(
         channel, handle_table[i].type, source, size, platform_handles.get());
   }
 
   return dispatchers.Pass();
 }
 
 }  // namespace system
 }  // namespace mojo