Updated to Chrome 45 (2454) moved from SVN to git.

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 12 matching lines @@
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 # THis file contains string resources for CodeGeneratorInspector.
 # Its syntax is a Python syntax subset, suitable for manual parsing.
 
 frontend_domain_class = (
-"""    class $domainClassName {
+"""    class CORE_EXPORT $domainClassName {
     public:
+        static $domainClassName* from(InspectorFrontend* frontend) { return &(frontend->m_$domainFieldName) ;}
         $domainClassName(InspectorFrontendChannel* inspectorFrontendChannel) : m_inspectorFrontendChannel(inspectorFrontendChannel) { }
 ${frontendDomainMethodDeclarations}
         void flush() { m_inspectorFrontendChannel->flush(); }
     private:
         InspectorFrontendChannel* m_inspectorFrontendChannel;
     };
 
-    $domainClassName* $domainFieldName() { return &m_$domainFieldName; }
-
 """)
 
 backend_method = (
-"""void InspectorBackendDispatcherImpl::${domainName}_$methodName(long callId, JSONObject*$requestMessageObject, JSONArray* protocolErrors)
+"""void InspectorBackendDispatcherImpl::${domainName}_$methodName(int callId, JSONObject*$requestMessageObject, JSONArray* protocolErrors)
 {
     if (!$agentField)
         protocolErrors->pushString("${domainName} handler is not available.");
 $methodCode
     if (protocolErrors->length()) {
-        reportProtocolError(&callId, InvalidParams, String::format(InvalidParamsFormatString, commandName($commandNameIndex)), protocolErrors);
+        reportProtocolError(callId, InvalidParams, String::format(InvalidParamsFormatString, commandName($commandNameIndex)), protocolErrors);
         return;
     }
 $agentCallParamsDeclaration
     $agentField->$methodName($agentCallParams);
 $responseCook
     sendResponse(callId, $sendResponseCallParams);
 }
 """)
 
 frontend_method = ("""void InspectorFrontend::$domainName::$eventName($parameters)
 {
     RefPtr<JSONObject> jsonMessage = JSONObject::create();
     jsonMessage->setString("method", "$domainName.$eventName");
 $code    if (m_inspectorFrontendChannel)
-        m_inspectorFrontendChannel->sendMessageToFrontend(jsonMessage.release());
+        m_inspectorFrontendChannel->sendProtocolNotification(jsonMessage.release());
 }
 """)
 
 callback_main_methods = (
 """InspectorBackendDispatcher::$agentName::$callbackName::$callbackName(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id) : CallbackBase(backendImpl, id) {}
 
 void InspectorBackendDispatcher::$agentName::$callbackName::sendSuccess($parameters)
 {
     RefPtr<JSONObject> jsonMessage = JSONObject::create();
 $code    sendIfActive(jsonMessage, ErrorString(), PassRefPtr<JSONValue>());
@@ skipping 11 matching lines @@
     sendIfActive(nullptr, error, errorDataValue.release());
 }
 """)
 
 
 frontend_h = (
 """#ifndef InspectorFrontend_h
 #define InspectorFrontend_h
 
 #include "InspectorTypeBuilder.h"
+#include "core/CoreExport.h"
 #include "core/inspector/InspectorFrontendChannel.h"
 #include "platform/JSONValues.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 typedef String ErrorString;
 
-class InspectorFrontend {
+class CORE_EXPORT InspectorFrontend {
 public:
     InspectorFrontend(InspectorFrontendChannel*);
     InspectorFrontendChannel* channel() { return m_inspectorFrontendChannel; }
 
 $domainClassList
 private:
     InspectorFrontendChannel* m_inspectorFrontendChannel;
 ${fieldDeclarations}};
 
 } // namespace blink
 #endif // !defined(InspectorFrontend_h)
 """)
 
 backend_h = (
 """#ifndef InspectorBackendDispatcher_h
 #define InspectorBackendDispatcher_h
 
 #include "InspectorTypeBuilder.h"
 
+#include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class JSONObject;
 class JSONArray;
 class InspectorFrontendChannel;
 
 typedef String ErrorString;
 
 class InspectorBackendDispatcherImpl;
 
-class InspectorBackendDispatcher: public RefCountedWillBeGarbageCollectedFinalized<InspectorBackendDispatcher> {
+class CORE_EXPORT InspectorBackendDispatcher: public RefCountedWillBeGarbageCollectedFinalized<InspectorBackendDispatcher> {
 public:
     static PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> create(InspectorFrontendChannel* inspectorFrontendChannel);
     virtual ~InspectorBackendDispatcher() { }
-    virtual void trace(Visitor*) { }
+    DEFINE_INLINE_VIRTUAL_TRACE() { }
 
-    class CallbackBase: public RefCountedWillBeGarbageCollectedFinalized<CallbackBase> {
+    class CORE_EXPORT CallbackBase: public RefCountedWillBeGarbageCollectedFinalized<CallbackBase> {
     public:
         CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id);
         virtual ~CallbackBase();
-        virtual void trace(Visitor*);
+        DECLARE_VIRTUAL_TRACE();
         void sendFailure(const ErrorString&);
         bool isActive();
 
     protected:
         void sendIfActive(PassRefPtr<JSONObject> partialMessage, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData);
 
     private:
         void disable() { m_alreadySent = true; }
 
         RefPtrWillBeMember<InspectorBackendDispatcherImpl> m_backendImpl;
@@ skipping 11 matching lines @@
     enum CommonErrorCode {
         ParseError = 0,
         InvalidRequest,
         MethodNotFound,
         InvalidParams,
         InternalError,
         ServerError,
         LastEntry,
     };
 
-    void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage) const;
-    virtual void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const = 0;
+    void reportProtocolError(int callId, CommonErrorCode, const String& errorMessage) const;
+    virtual void reportProtocolError(int callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const = 0;
     virtual void dispatch(const String& message) = 0;
     static bool getCommandName(const String& message, String* result);
 
     enum MethodNames {
 $methodNamesEnumContent
 
         kMethodNamesEnumSize
     };
 
     static const char* commandName(MethodNames);
 
 private:
     static const char commandNames[];
-    static const size_t commandNamesIndex[];
+    static const unsigned short commandNamesIndex[];
 };
 
 } // namespace blink
 #endif // !defined(InspectorBackendDispatcher_h)
 
 
 """)
 
 backend_cpp = (
 """
 
 #include "config.h"
 #include "InspectorBackendDispatcher.h"
 
 #include "core/inspector/InspectorFrontendChannel.h"
 #include "core/inspector/JSONParser.h"
 #include "platform/JSONValues.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 const char InspectorBackendDispatcher::commandNames[] = {
 $methodNameDeclarations
 };
 
-const size_t InspectorBackendDispatcher::commandNamesIndex[] = {
+const unsigned short 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
-    { }
+    {
+        // Initialize dispatch map.
+        const CallHandler handlers[] = {
+  $messageHandlers
+        };
+        for (size_t i = 0; i < kMethodNamesEnumSize; ++i)
+            m_dispatchMap.add(commandName(static_cast<MethodNames>(i)), handlers[i]);
+
+        // Initialize common errors.
+        m_commonErrors.insert(ParseError, -32700);
+        m_commonErrors.insert(InvalidRequest, -32600);
+        m_commonErrors.insert(MethodNotFound, -32601);
+        m_commonErrors.insert(InvalidParams, -32602);
+        m_commonErrors.insert(InternalError, -32603);
+        m_commonErrors.insert(ServerError, -32000);
+    }
 
     virtual void clearFrontend() { m_inspectorFrontendChannel = 0; }
     virtual void dispatch(const String& message);
-    virtual void reportProtocolError(const long* const callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const;
+    virtual void reportProtocolError(int callId, CommonErrorCode, const String& errorMessage, PassRefPtr<JSONValue> data) const;
     using InspectorBackendDispatcher::reportProtocolError;
 
-    void sendResponse(long callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result);
+    void sendResponse(int callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result);
     bool isActive() { return m_inspectorFrontendChannel; }
 
 $setters
 private:
+    using CallHandler = void (InspectorBackendDispatcherImpl::*)(int callId, JSONObject* messageObject, JSONArray* protocolErrors);
+    using DispatchMap = HashMap<String, CallHandler>;
+
 $methodDeclarations
 
     InspectorFrontendChannel* m_inspectorFrontendChannel;
 $fieldDeclarations
 
     template<typename R, typename V, typename V0>
     static R getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name);
 
     static int getInt(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
     static double getDouble(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
     static String getString(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
     static bool getBoolean(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
     static PassRefPtr<JSONObject> getObject(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
     static PassRefPtr<JSONArray> getArray(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors);
 
-    void sendResponse(long callId, ErrorString invocationError, PassRefPtr<JSONObject> result)
+    void sendResponse(int callId, ErrorString invocationError, PassRefPtr<JSONObject> result)
     {
         sendResponse(callId, invocationError, RefPtr<JSONValue>(), result);
     }
-    void sendResponse(long callId, ErrorString invocationError)
+    void sendResponse(int callId, ErrorString invocationError)
     {
         sendResponse(callId, invocationError, RefPtr<JSONValue>(), JSONObject::create());
     }
     static const char InvalidParamsFormatString[];
+
+    DispatchMap m_dispatchMap;
+    Vector<int> m_commonErrors;
 };
 
 const char InspectorBackendDispatcherImpl::InvalidParamsFormatString[] = "Some arguments of method '%s' can't be processed";
 
 $methods
 
 PassRefPtrWillBeRawPtr<InspectorBackendDispatcher> InspectorBackendDispatcher::create(InspectorFrontendChannel* inspectorFrontendChannel)
 {
     return adoptRefWillBeNoop(new InspectorBackendDispatcherImpl(inspectorFrontendChannel));
 }
 
 
 void InspectorBackendDispatcherImpl::dispatch(const String& message)
 {
     RefPtrWillBeRawPtr<InspectorBackendDispatcher> protect(this);
-    typedef void (InspectorBackendDispatcherImpl::*CallHandler)(long callId, JSONObject* messageObject, JSONArray* protocolErrors);
-    typedef HashMap<String, CallHandler> DispatchMap;
-    DEFINE_STATIC_LOCAL(DispatchMap, dispatchMap, );
-    long callId = 0;
+    int callId = 0;
+    RefPtr<JSONValue> parsedMessage = parseJSON(message);
+    ASSERT(parsedMessage);
+    RefPtr<JSONObject> messageObject = parsedMessage->asObject();
+    ASSERT(messageObject);
 
-    if (dispatchMap.isEmpty()) {
-        static const CallHandler handlers[] = {
-$messageHandlers
-        };
-        for (size_t i = 0; i < kMethodNamesEnumSize; ++i)
-            dispatchMap.add(commandName(static_cast<MethodNames>(i)), handlers[i]);
-    }
+    RefPtr<JSONValue> callIdValue = messageObject->get("id");
+    bool success = callIdValue->asNumber(&callId);
+    ASSERT_UNUSED(success, success);
 
-    RefPtr<JSONValue> parsedMessage = parseJSON(message);
-    if (!parsedMessage) {
-        reportProtocolError(0, ParseError, "Message must be in JSON format");
+    RefPtr<JSONValue> methodValue = messageObject->get("method");
+    String method;
+    success = methodValue && methodValue->asString(&method);
+    ASSERT_UNUSED(success, success);
+
+    HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    if (it == m_dispatchMap.end()) {
+        reportProtocolError(callId, MethodNotFound, "'" + method + "' wasn't found");
         return;
     }
 
-    RefPtr<JSONObject> messageObject = parsedMessage->asObject();
-    if (!messageObject) {
-        reportProtocolError(0, InvalidRequest, "Message must be a JSONified object");
-        return;
-    }
-
-    RefPtr<JSONValue> callIdValue = messageObject->get("id");
-    if (!callIdValue) {
-        reportProtocolError(0, InvalidRequest, "'id' property was not found");
-        return;
-    }
-
-    if (!callIdValue->asNumber(&callId)) {
-        reportProtocolError(0, InvalidRequest, "The type of 'id' property must be number");
-        return;
-    }
-
-    RefPtr<JSONValue> methodValue = messageObject->get("method");
-    if (!methodValue) {
-        reportProtocolError(&callId, InvalidRequest, "'method' property wasn't found");
-        return;
-    }
-
-    String method;
-    if (!methodValue->asString(&method)) {
-        reportProtocolError(&callId, InvalidRequest, "The type of 'method' property must be string");
-        return;
-    }
-
-    HashMap<String, CallHandler>::iterator it = dispatchMap.find(method);
-    if (it == dispatchMap.end()) {
-        reportProtocolError(&callId, MethodNotFound, "'" + method + "' wasn't found");
-        return;
-    }
-
     RefPtr<JSONArray> protocolErrors = JSONArray::create();
     ((*this).*it->value)(callId, messageObject.get(), protocolErrors.get());
 }
 
-void InspectorBackendDispatcherImpl::sendResponse(long callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result)
+void InspectorBackendDispatcherImpl::sendResponse(int callId, const ErrorString& invocationError, PassRefPtr<JSONValue> errorData, PassRefPtr<JSONObject> result)
 {
     if (invocationError.length()) {
-        reportProtocolError(&callId, ServerError, invocationError, errorData);
+        reportProtocolError(callId, ServerError, invocationError, errorData);
         return;
     }
 
     RefPtr<JSONObject> responseMessage = JSONObject::create();
     responseMessage->setNumber("id", callId);
     responseMessage->setObject("result", result);
     if (m_inspectorFrontendChannel)
-        m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage.release());
+        m_inspectorFrontendChannel->sendProtocolResponse(callId, responseMessage.release());
 }
 
-void InspectorBackendDispatcher::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage) const
+void InspectorBackendDispatcher::reportProtocolError(int callId, CommonErrorCode code, const String& errorMessage) const
 {
     reportProtocolError(callId, code, errorMessage, PassRefPtr<JSONValue>());
 }
 
-void InspectorBackendDispatcherImpl::reportProtocolError(const long* const callId, CommonErrorCode code, const String& errorMessage, PassRefPtr<JSONValue> data) const
+void InspectorBackendDispatcherImpl::reportProtocolError(int callId, CommonErrorCode code, const String& errorMessage, PassRefPtr<JSONValue> data) const
 {
-    DEFINE_STATIC_LOCAL(Vector<int>,s_commonErrors,);
-    if (!s_commonErrors.size()) {
-        s_commonErrors.insert(ParseError, -32700);
-        s_commonErrors.insert(InvalidRequest, -32600);
-        s_commonErrors.insert(MethodNotFound, -32601);
-        s_commonErrors.insert(InvalidParams, -32602);
-        s_commonErrors.insert(InternalError, -32603);
-        s_commonErrors.insert(ServerError, -32000);
-    }
     ASSERT(code >=0);
-    ASSERT((unsigned)code < s_commonErrors.size());
-    ASSERT(s_commonErrors[code]);
+    ASSERT((unsigned)code < m_commonErrors.size());
+    ASSERT(m_commonErrors[code]);
     RefPtr<JSONObject> error = JSONObject::create();
-    error->setNumber("code", s_commonErrors[code]);
+    error->setNumber("code", m_commonErrors[code]);
     error->setString("message", errorMessage);
     ASSERT(error);
     if (data)
         error->setValue("data", data);
     RefPtr<JSONObject> message = JSONObject::create();
     message->setObject("error", error);
-    if (callId)
-        message->setNumber("id", *callId);
-    else
-        message->setValue("id", JSONValue::null());
+    message->setNumber("id", callId);
     if (m_inspectorFrontendChannel)
-        m_inspectorFrontendChannel->sendMessageToFrontend(message.release());
+        m_inspectorFrontendChannel->sendProtocolResponse(callId, message.release());
 }
 
 template<typename R, typename V, typename V0>
 R InspectorBackendDispatcherImpl::getPropertyValueImpl(JSONObject* object, const char* name, bool* valueFound, JSONArray* protocolErrors, V0 initial_value, bool (*as_method)(JSONValue*, V*), const char* type_name)
 {
     ASSERT(protocolErrors);
 
     if (valueFound)
         *valueFound = false;
 
@@ skipping 77 matching lines @@
         return false;
 
     return true;
 }
 
 InspectorBackendDispatcher::CallbackBase::CallbackBase(PassRefPtrWillBeRawPtr<InspectorBackendDispatcherImpl> backendImpl, int id)
     : m_backendImpl(backendImpl), m_id(id), m_alreadySent(false) {}
 
 InspectorBackendDispatcher::CallbackBase::~CallbackBase() {}
 
-void InspectorBackendDispatcher::CallbackBase::trace(Visitor* visitor)
+DEFINE_TRACE(InspectorBackendDispatcher::CallbackBase)
 {
     visitor->trace(m_backendImpl);
 }
 
 void InspectorBackendDispatcher::CallbackBase::sendFailure(const ErrorString& error)
 {
     ASSERT(error.length());
     sendIfActive(nullptr, error, PassRefPtr<JSONValue>());
 }
 
@@ skipping 37 matching lines @@
 
 } // namespace blink
 
 """)
 
 typebuilder_h = (
 """
 #ifndef InspectorTypeBuilder_h
 #define InspectorTypeBuilder_h
 
+#include "core/CoreExport.h"
 #include "platform/JSONValues.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassRefPtr.h"
 
 namespace blink {
 
 namespace TypeBuilder {
 
 template<typename T>
 class OptOutput {
@@ skipping 41 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 159 matching lines @@
         template<typename S>
         static void assertCorrectValue(JSONValue* value) {
             S::assertCorrectValue(value);
         }
 #endif  // $validatorIfdefName
     };
 };
 
 ${forwards}
 
-String getEnumConstantValue(int code);
+CORE_EXPORT String getEnumConstantValue(int code);
 
 ${typeBuilders}
 } // namespace TypeBuilder
 
 
 } // namespace blink
 
 #endif // !defined(InspectorTypeBuilder_h)
 
 """)
@@ skipping 59 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());
     }
 """)