T BackendDispatcher::getPropertyValue(JSON::Object* object, const String& name, bool* out_optionalValueFound, T defaultValue, std::function<bool(JSON::Value&, T&)> asMethod, const char* typeName)
{
T result(defaultValue);
// out_optionalValueFound signals to the caller whether an optional property was found.
// if out_optionalValueFound == nullptr, then this is a required property.
if (out_optionalValueFound)
*out_optionalValueFound = false;
if (!object) {
if (!out_optionalValueFound)
reportProtocolError(BackendDispatcher::InvalidParams, String::format("'params' object must contain required parameter '%s' with type '%s'.", name.utf8().data(), typeName));
return result;
}
auto findResult = object->find(name);
if (findResult == object->end()) {
if (!out_optionalValueFound)
reportProtocolError(BackendDispatcher::InvalidParams, String::format("Parameter '%s' with type '%s' was not found.", name.utf8().data(), typeName));
return result;
}
if (!asMethod(*findResult->value, result)) {
reportProtocolError(BackendDispatcher::InvalidParams, String::format("Parameter '%s' has wrong type. It must be '%s'.", name.utf8().data(), typeName));
return result;
}
if (out_optionalValueFound)
*out_optionalValueFound = true;
return result;
}
void BackendDispatcher::reportProtocolError(WTF::DeprecatedOptional<long> relatedRequestId, CommonErrorCode errorCode, const String& errorMessage)
{
if (relatedRequestId)
reportProtocolError(relatedRequestId.value(), errorCode, errorMessage);
else
reportProtocolError(std::nullopt, errorCode, errorMessage);
}
void InspectorBackendDispatcher::dispatch(const String& message)
{
Ref<InspectorBackendDispatcher> protect(*this);
RefPtr<InspectorValue> parsedMessage = InspectorValue::parseJSON(message);
if (!parsedMessage) {
reportProtocolError(nullptr, ParseError, ASCIILiteral("Message must be in JSON format"));
return;
}
RefPtr<InspectorObject> messageObject = parsedMessage->asObject();
if (!messageObject) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("Message must be a JSONified object"));
return;
}
RefPtr<InspectorValue> callIdValue = messageObject->get(ASCIILiteral("id"));
if (!callIdValue) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("'id' property was not found"));
return;
}
long callId = 0;
if (!callIdValue->asNumber(&callId)) {
reportProtocolError(nullptr, InvalidRequest, ASCIILiteral("The type of 'id' property must be number"));
return;
}
RefPtr<InspectorValue> methodValue = messageObject->get(ASCIILiteral("method"));
if (!methodValue) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("'method' property wasn't found"));
return;
}
String method;
if (!methodValue->asString(&method)) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("The type of 'method' property must be string"));
return;
}
size_t position = method.find('.');
if (position == WTF::notFound) {
reportProtocolError(&callId, InvalidRequest, ASCIILiteral("The 'method' property was formatted incorrectly. It should be 'Domain.method'"));
return;
}
String domain = method.substring(0, position);
InspectorSupplementalBackendDispatcher* domainDispatcher = m_dispatchers.get(domain);
if (!domainDispatcher) {
reportProtocolError(&callId, MethodNotFound, "'" + domain + "' domain was not found");
return;
}
String domainMethod = method.substring(position + 1);
domainDispatcher->dispatch(callId, domainMethod, messageObject.release());
}
void InspectorBackendDispatcher::sendResponse(long callId, PassRefPtr<InspectorObject> result, const ErrorString& invocationError)
{
if (!m_inspectorFrontendChannel)
return;
if (invocationError.length()) {
reportProtocolError(&callId, ServerError, invocationError);
return;
}
RefPtr<InspectorObject> responseMessage = InspectorObject::create();
responseMessage->setObject(ASCIILiteral("result"), result);
responseMessage->setNumber(ASCIILiteral("id"), callId);
m_inspectorFrontendChannel->sendMessageToFrontend(responseMessage->toJSONString());
}
void InspectorBackendDispatcher::reportProtocolError(const long* const callId, CommonErrorCode errorCode, const String& errorMessage) const
{
reportProtocolError(callId, errorCode, errorMessage, nullptr);
}
void BackendDispatcher::reportProtocolError(CommonErrorCode errorCode, const String& errorMessage)
{
reportProtocolError(m_currentRequestId, errorCode, errorMessage);
}
void BackendDispatcher::dispatch(const String& message)
{
Ref<BackendDispatcher> protect(*this);
ASSERT(!m_protocolErrors.size());
long requestId = 0;
RefPtr<JSON::Object> messageObject;
{
// In case this is a re-entrant call from a nested run loop, we don't want to lose
// the outer request's id just because the inner request is bogus.
SetForScope<std::optional<long>> scopedRequestId(m_currentRequestId, std::nullopt);
RefPtr<JSON::Value> parsedMessage;
if (!JSON::Value::parseJSON(message, parsedMessage)) {
reportProtocolError(ParseError, ASCIILiteral("Message must be in JSON format"));
sendPendingErrors();
return;
}
if (!parsedMessage->asObject(messageObject)) {
reportProtocolError(InvalidRequest, ASCIILiteral("Message must be a JSONified object"));
sendPendingErrors();
return;
}
RefPtr<JSON::Value> requestIdValue;
if (!messageObject->getValue(ASCIILiteral("id"), requestIdValue)) {
reportProtocolError(InvalidRequest, ASCIILiteral("'id' property was not found"));
sendPendingErrors();
return;
}
if (!requestIdValue->asInteger(requestId)) {
reportProtocolError(InvalidRequest, ASCIILiteral("The type of 'id' property must be integer"));
sendPendingErrors();
return;
}
}
{
// We could be called re-entrantly from a nested run loop, so restore the previous id.
SetForScope<std::optional<long>> scopedRequestId(m_currentRequestId, requestId);
RefPtr<JSON::Value> methodValue;
if (!messageObject->getValue(ASCIILiteral("method"), methodValue)) {
reportProtocolError(InvalidRequest, ASCIILiteral("'method' property wasn't found"));
sendPendingErrors();
return;
}
String methodString;
if (!methodValue->asString(methodString)) {
reportProtocolError(InvalidRequest, ASCIILiteral("The type of 'method' property must be string"));
sendPendingErrors();
return;
}
Vector<String> domainAndMethod;
methodString.split('.', true, domainAndMethod);
if (domainAndMethod.size() != 2 || !domainAndMethod[0].length() || !domainAndMethod[1].length()) {
reportProtocolError(InvalidRequest, ASCIILiteral("The 'method' property was formatted incorrectly. It should be 'Domain.method'"));
sendPendingErrors();
return;
}
String domain = domainAndMethod[0];
SupplementalBackendDispatcher* domainDispatcher = m_dispatchers.get(domain);
if (!domainDispatcher) {
reportProtocolError(MethodNotFound, "'" + domain + "' domain was not found");
sendPendingErrors();
return;
}
String method = domainAndMethod[1];
domainDispatcher->dispatch(requestId, method, messageObject.releaseNonNull());
if (m_protocolErrors.size())
sendPendingErrors();
}
}
