DevTools: expose raw pointers in protocol collections, s/ASSERT/DCHECK/.

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_cpp.template

 // This file is generated
 
 // Copyright (c) 2016 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 "platform/inspector_protocol/{{class_name}}.h"
 
 #include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
@@ skipping 59 matching lines @@
         return weak;
     }
 
     virtual void dispatch(int sessionId, const String16& message);
     virtual void reportProtocolError(int sessionId, int callId, CommonErrorCode, const String16& errorMessage, ErrorSupport* errors) const;
     using Dispatcher::reportProtocolError;
 
     void sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result);
 
 {% for domain in api.domains %}
-    virtual void registerAgent(blink::protocol::Backend::{{domain.domain}}* agent) { ASSERT(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
+    virtual void registerAgent(blink::protocol::Backend::{{domain.domain}}* agent) { DCHECK(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
 {% endfor %}
 
 private:
     friend class DispatcherCallbackBase;
     friend class DispatcherImplWeakPtr;
     using CallHandler = void (DispatcherImpl::*)(int sessionId, int callId, PassOwnPtr<DictionaryValue> messageObject, ErrorSupport* errors);
     using DispatchMap = protocol::HashMap<String16, CallHandler>;
 
 {% for domain in api.domains %}
   {% for command in domain.commands %}
@@ skipping 85 matching lines @@
             resultObject->setValue("{{parameter.name}}", toValue({{parameter.name}}.fromJust()));
            {% else %}
         resultObject->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % parameter.name}}));
             {% endif %}
           {% endfor %}
         sendIfActive(std::move(resultObject), ErrorString());
     }
 
     void sendFailure(const ErrorString& error) override
     {
-        ASSERT(error.length());
+        DCHECK(error.length());
         sendIfActive(nullptr, error);
     }
 };
     {% endif %}
 
 void DispatcherImpl::{{domain.domain}}_{{command.name}}(int sessionId, int callId, PassOwnPtr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
 {
     if (!m_{{domain.domain | lower}}Agent)
         errors->addError("{{domain.domain}} handler is not available.");
 
@@ skipping 80 matching lines @@
 
 PassOwnPtr<Dispatcher> Dispatcher::create(FrontendChannel* frontendChannel)
 {
     return adoptPtr(new DispatcherImpl(frontendChannel));
 }
 
 void DispatcherImpl::dispatch(int sessionId, const String16& message)
 {
     int callId = 0;
     OwnPtr<protocol::Value> parsedMessage = parseJSON(message);
-    ASSERT(parsedMessage);
+    DCHECK(parsedMessage);
     OwnPtr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
-    ASSERT(messageObject);
+    DCHECK(messageObject);
 
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue->asNumber(&callId);
-    ASSERT_UNUSED(success, success);
+    DCHECK(success);
 
     protocol::Value* methodValue = messageObject->get("method");
     String16 method;
     success = methodValue && methodValue->asString(&method);
-    ASSERT_UNUSED(success, success);
+    DCHECK(success);
 
     protocol::HashMap<String16, CallHandler>::iterator it = m_dispatchMap.find(method);
     if (it == m_dispatchMap.end()) {
         reportProtocolError(sessionId, callId, MethodNotFound, "'" + method + "' wasn't found");
         return;
     }
 
     protocol::ErrorSupport errors;
     ((*this).*(*it->second))(sessionId, callId, std::move(messageObject), &errors);
 }
@@ skipping 13 matching lines @@
 }
 
 void Dispatcher::reportProtocolError(int sessionId, int callId, CommonErrorCode code, const String16& errorMessage) const
 {
     ErrorSupport errors;
     reportProtocolError(sessionId, callId, code, errorMessage, &errors);
 }
 
 void DispatcherImpl::reportProtocolError(int sessionId, int callId, CommonErrorCode code, const String16& errorMessage, ErrorSupport* errors) const
 {
-    ASSERT(code >=0);
-    ASSERT((unsigned)code < m_commonErrors.size());
-    ASSERT(m_commonErrors[code]);
+    DCHECK(code >=0);
+    DCHECK((unsigned)code < m_commonErrors.size());
+    DCHECK(m_commonErrors[code]);
     OwnPtr<protocol::DictionaryValue> error = DictionaryValue::create();
     error->setNumber("code", m_commonErrors[code]);
     error->setString("message", errorMessage);
-    ASSERT(error);
+    DCHECK(error);
     if (errors && errors->hasErrors())
         error->setString("data", errors->errors());
     OwnPtr<protocol::DictionaryValue> message = DictionaryValue::create();
     message->setObject("error", std::move(error));
     message->setNumber("id", callId);
     if (m_frontendChannel)
         m_frontendChannel->sendProtocolResponse(sessionId, callId, std::move(message));
 }
 
 bool Dispatcher::getCommandName(const String16& message, String16* result)
 {
     OwnPtr<protocol::Value> value = parseJSON(message);
     if (!value)
         return false;
 
     protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
 } // namespace protocol
 } // namespace blink