RemoteInspectorConnectionClient.cpp [plain text]
#include "config.h"
#include "RemoteInspectorConnectionClient.h"
#if ENABLE(REMOTE_INSPECTOR)
#include "RemoteInspectorSocketEndpoint.h"
#include <wtf/JSONValues.h>
#include <wtf/RunLoop.h>
namespace Inspector {
RemoteInspectorConnectionClient::~RemoteInspectorConnectionClient()
{
auto& endpoint = Inspector::RemoteInspectorSocketEndpoint::singleton();
endpoint.invalidateClient(*this);
}
Optional<ConnectionID> RemoteInspectorConnectionClient::connectInet(const char* serverAddr, uint16_t serverPort)
{
auto& endpoint = Inspector::RemoteInspectorSocketEndpoint::singleton();
return endpoint.connectInet(serverAddr, serverPort, *this);
}
Optional<ConnectionID> RemoteInspectorConnectionClient::createClient(PlatformSocketType socket)
{
auto& endpoint = Inspector::RemoteInspectorSocketEndpoint::singleton();
return endpoint.createClient(socket, *this);
}
void RemoteInspectorConnectionClient::send(ConnectionID id, const uint8_t* data, size_t size)
{
auto message = MessageParser::createMessage(data, size);
if (message.isEmpty())
return;
auto& endpoint = RemoteInspectorSocketEndpoint::singleton();
endpoint.send(id, message.data(), message.size());
}
void RemoteInspectorConnectionClient::didReceive(RemoteInspectorSocketEndpoint&, ConnectionID clientID, Vector<uint8_t>&& data)
{
ASSERT(!isMainThread());
LockHolder lock(m_parsersLock);
auto result = m_parsers.ensure(clientID, [this, clientID] {
return MessageParser([this, clientID](Vector<uint8_t>&& data) {
if (auto event = RemoteInspectorConnectionClient::extractEvent(clientID, WTFMove(data))) {
RunLoop::main().dispatch([this, event = WTFMove(*event)] {
const auto& methodName = event.methodName;
auto& methods = dispatchMap();
if (methods.contains(methodName)) {
auto call = methods.get(methodName);
(this->*call)(event);
} else
LOG_ERROR("Unknown event: %s", methodName.utf8().data());
});
}
});
});
result.iterator->value.pushReceivedData(data.data(), data.size());
}
Optional<RemoteInspectorConnectionClient::Event> RemoteInspectorConnectionClient::extractEvent(ConnectionID clientID, Vector<uint8_t>&& data)
{
if (data.isEmpty())
return WTF::nullopt;
String jsonData = String::fromUTF8(data);
auto messageValue = JSON::Value::parseJSON(jsonData);
if (!messageValue)
return WTF::nullopt;
auto messageObject = messageValue->asObject();
if (!messageObject)
return WTF::nullopt;
Event event;
event.methodName = messageObject->getString("event"_s);
if (!event.methodName)
return WTF::nullopt;
event.clientID = clientID;
if (auto connectionID = messageObject->getInteger("connectionID"_s))
event.connectionID = *connectionID;
if (auto targetID = messageObject->getInteger("targetID"_s))
event.targetID = *targetID;
event.message = messageObject->getString("message"_s);
return event;
}
Optional<Vector<Ref<JSON::Object>>> RemoteInspectorConnectionClient::parseTargetListJSON(const String& message)
{
auto messageValue = JSON::Value::parseJSON(message);
if (!messageValue)
return WTF::nullopt;
auto messageArray = messageValue->asArray();
if (!messageArray)
return WTF::nullopt;
Vector<Ref<JSON::Object>> targetList;
for (auto& itemValue : *messageArray) {
if (auto itemObject = itemValue->asObject())
targetList.append(itemObject.releaseNonNull());
else
LOG_ERROR("Invalid type of value in targetList. It must be object.");
}
return targetList;
}
}
#endif // ENABLE(REMOTE_INSPECTOR)