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(); } }