replace COMPILE_ASSERT with static_assert in core/inspector/

Source/core/inspector/CodeGeneratorInspectorStrings.py

 # Copyright (c) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 212 matching lines @@
 
 const char InspectorBackendDispatcher::commandNames[] = {
 $methodNameDeclarations
 };
 
 const size_t InspectorBackendDispatcher::commandNamesIndex[] = {
 $methodNameDeclarationsIndex
 };
 
 const char* InspectorBackendDispatcher::commandName(MethodNames index) {
-    COMPILE_ASSERT(static_cast<int>(kMethodNamesEnumSize) == WTF_ARRAY_LENGTH(commandNamesIndex), command_name_array_problem);
+    static_assert(static_cast<int>(kMethodNamesEnumSize) == WTF_ARRAY_LENGTH(commandNamesIndex), "MethodNames enum should have the same number of elements as commandNamesIndex");
     return commandNames + commandNamesIndex[index];
 }
 
 class InspectorBackendDispatcherImpl : public InspectorBackendDispatcher {
 public:
     InspectorBackendDispatcherImpl(InspectorFrontendChannel* inspectorFrontendChannel)
         : m_inspectorFrontendChannel(inspectorFrontendChannel)
 $constructorInit
     { }
 
@@ skipping 360 matching lines @@
 struct ArrayItemHelper {
     typedef typename T::ItemTraits Traits;
 };
 
 template<typename T>
 class Array : public JSONArrayBase {
 private:
     Array() { }
 
     JSONArray* openAccessors() {
-        COMPILE_ASSERT(sizeof(JSONArray) == sizeof(Array<T>), cannot_cast);
+        static_assert(sizeof(JSONArray) == sizeof(Array<T>), "JSONArray should be the same size as Array<T>");
         return static_cast<JSONArray*>(static_cast<JSONArrayBase*>(this));
     }
 
 public:
     void addItem(PassRefPtr<T> value)
     {
         ArrayItemHelper<T>::Traits::pushRefPtr(this->openAccessors(), value);
     }
 
     void addItem(T value)
     {
         ArrayItemHelper<T>::Traits::pushRaw(this->openAccessors(), value);
     }
 
     static PassRefPtr<Array<T> > create()
     {
         return adoptRef(new Array<T>());
     }
 
     static PassRefPtr<Array<T> > runtimeCast(PassRefPtr<JSONValue> value)
     {
         RefPtr<JSONArray> array;
         bool castRes = value->asArray(&array);
         ASSERT_UNUSED(castRes, castRes);
 #if $validatorIfdefName
         assertCorrectValue(array.get());
 #endif  // $validatorIfdefName
-        COMPILE_ASSERT(sizeof(Array<T>) == sizeof(JSONArray), type_cast_problem);
+        static_assert(sizeof(Array<T>) == sizeof(JSONArray), "Array<T> should be the same size as JSONArray");
         return static_cast<Array<T>*>(static_cast<JSONArrayBase*>(array.get()));
     }
 
     void concat(PassRefPtr<Array<T> > array)
     {
         return ArrayItemHelper<T>::Traits::concat(this->openAccessors(), array->openAccessors());
     }
 
 #if $validatorIfdefName
     static void assertCorrectValue(JSONValue* value)
@@ skipping 239 matching lines @@
     private:
         RefPtr<JSONObject> m_result;
 
         template<int STEP> Builder<STATE | STEP>& castState()
         {
             return *reinterpret_cast<Builder<STATE | STEP>*>(this);
         }
 
         Builder(PassRefPtr</*%s*/JSONObject> ptr)
         {
-            COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
+            static_assert(STATE == NoFieldsSet, "builder should not be created in non-init state");
             m_result = ptr;
         }
         friend class %s;
     public:
 """)
 
 class_binding_builder_part_2 = ("""
         Builder<STATE | %s>& set%s(%s value)
         {
-            COMPILE_ASSERT(!(STATE & %s), property_%s_already_set);
+            static_assert(!(STATE & %s), "property %s should not be set yet");
             m_result->set%s("%s", %s);
             return castState<%s>();
         }
 """)
 
 class_binding_builder_part_3 = ("""
         operator RefPtr<%s>& ()
         {
-            COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
-            COMPILE_ASSERT(sizeof(%s) == sizeof(JSONObject), cannot_cast);
+            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
+            static_assert(sizeof(%s) == sizeof(JSONObject), "%s should be the same size as JSONObject");
             return *reinterpret_cast<RefPtr<%s>*>(&m_result);
         }
 
         PassRefPtr<%s> release()
         {
             return RefPtr<%s>(*this).release();
         }
     };
 
 """)
 
 class_binding_builder_part_4 = (
 """    static Builder<NoFieldsSet> create()
     {
         return Builder<NoFieldsSet>(JSONObject::create());
     }
 """)