Source/JavaScriptCore/inspector/remote/glib/RemoteInspectorServer.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2017 Igalia S.L.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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.
  */

 #include "config.h"
 #include "RemoteInspectorServer.h"

 #if ENABLE(REMOTE_INSPECTOR)

 #include "RemoteInspectorUtils.h"
 #include <gio/gio.h>
 #include <wtf/Vector.h>
 #include <wtf/glib/GUniquePtr.h>

 #define INSPECTOR_DBUS_INTERFACE "org.webkit.Inspector"
 #define INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/Inspector"
 #define REMOTE_INSPECTOR_DBUS_INTERFACE "org.webkit.RemoteInspector"
 #define REMOTE_INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/RemoteInspector"
 #define REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE "org.webkit.RemoteInspectorClient"
 #define REMOTE_INSPECTOR_CLIENT_OBJECT_PATH "/org/webkit/RemoteInspectorClient"

 namespace Inspector {

 static uint64_t generateConnectionID()
 {
     static uint64_t connectionID = 0;
     return ++connectionID;
 }

 namespace RemoteInspectorServerInternal {
 static const char introspectionXML[] =
     "<node>"
     "  <interface name='" INSPECTOR_DBUS_INTERFACE "'>"
     "    <method name='SetTargetList'>"
     "      <arg type='a(tsssb)' name='list' direction='in'/>"
     "      <arg type='b' name='remoteAutomationEnabled' direction='in'/>"
     "    </method>"
     "    <method name='SetupInspectorClient'>"
     "      <arg type='ay' name='backendCommandsHash' direction='in'/>"
     "      <arg type='ay' name='backendCommands' direction='out'/>"
     "    </method>"
     "    <method name='Setup'>"
     "      <arg type='t' name='connection' direction='in'/>"
     "      <arg type='t' name='target' direction='in'/>"
     "    </method>"
     "    <method name='FrontendDidClose'>"
     "      <arg type='t' name='connection' direction='in'/>"
     "      <arg type='t' name='target' direction='in'/>"
     "    </method>"
     "    <method name='SendMessageToFrontend'>"
     "      <arg type='t' name='target' direction='in'/>"
     "      <arg type='s' name='message' direction='in'/>"
     "    </method>"
     "    <method name='SendMessageToBackend'>"
     "      <arg type='t' name='connection' direction='in'/>"
     "      <arg type='t' name='target' direction='in'/>"
     "      <arg type='s' name='message' direction='in'/>"
     "    </method>"
     "    <method name='StartAutomationSession'>"
     "      <arg type='s' name='sessionID' direction='in'/>"
     "      <arg type='a{sv}' name='capabilities' direction='in'/>"
     "      <arg type='s' name='browserName' direction='out'/>"
     "      <arg type='s' name='browserVersion' direction='out'/>"
     "    </method>"
     "  </interface>"
     "</node>";
 }

 static RemoteInspector::Client::SessionCapabilities processSessionCapabilities(GVariant* sessionCapabilities)
 {
     RemoteInspector::Client::SessionCapabilities capabilities;

     gboolean acceptInsecureCerts;
     if (g_variant_lookup(sessionCapabilities, "acceptInsecureCerts", "b", &acceptInsecureCerts))
         capabilities.acceptInsecureCertificates = acceptInsecureCerts;

     if (GRefPtr<GVariant> certificates = g_variant_lookup_value(sessionCapabilities, "certificates",  G_VARIANT_TYPE("a(ss)"))) {
         GVariantIter iter;
         auto childCount = g_variant_iter_init(&iter, certificates.get());
         capabilities.certificates.reserveCapacity(childCount);
         const char* host;
         const char* certificateFile;
         while (g_variant_iter_loop(&iter, "(&s&s)", &host, &certificateFile))
             capabilities.certificates.uncheckedAppend({ String::fromUTF8(host), String::fromUTF8(certificateFile) });
     }

     return capabilities;
 }
 const GDBusInterfaceVTable RemoteInspectorServer::s_interfaceVTable = {
     // method_call
     [] (GDBusConnection* connection, const gchar* /*sender*/, const gchar* /*objectPath*/, const gchar* /*interfaceName*/, const gchar* methodName, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer userData) {
         auto* inspectorServer = static_cast<RemoteInspectorServer*>(userData);
         if (!g_strcmp0(methodName, "SetTargetList")) {
             inspectorServer->setTargetList(connection, parameters);
             g_dbus_method_invocation_return_value(invocation, nullptr);
         } else if (!g_strcmp0(methodName, "SetupInspectorClient")) {
             GRefPtr<GVariant> backendCommandsHash;
             g_variant_get(parameters, "(@ay)", &backendCommandsHash.outPtr());
             auto* backendCommands = inspectorServer->setupInspectorClient(connection, g_variant_get_bytestring(backendCommandsHash.get()));
             g_dbus_method_invocation_return_value(invocation, g_variant_new("(@ay)", backendCommands));
         } else if (!g_strcmp0(methodName, "Setup")) {
             guint64 connectionID, targetID;
             g_variant_get(parameters, "(tt)", &connectionID, &targetID);
             inspectorServer->setup(connection, connectionID, targetID);
             g_dbus_method_invocation_return_value(invocation, nullptr);
         } else if (!g_strcmp0(methodName, "FrontendDidClose")) {
             guint64 connectionID, targetID;
             g_variant_get(parameters, "(tt)", &connectionID, &targetID);
             inspectorServer->close(connection, connectionID, targetID);
             g_dbus_method_invocation_return_value(invocation, nullptr);
         } else if (!g_strcmp0(methodName, "SendMessageToFrontend")) {
             guint64 targetID;
             const char* message;
             g_variant_get(parameters, "(t&s)", &targetID, &message);
             inspectorServer->sendMessageToFrontend(connection, targetID, message);
             g_dbus_method_invocation_return_value(invocation, nullptr);
         } else if (!g_strcmp0(methodName, "SendMessageToBackend")) {
             guint64 connectionID, targetID;
             const char* message;
             g_variant_get(parameters, "(tt&s)", &connectionID, &targetID, &message);
             inspectorServer->sendMessageToBackend(connection, connectionID, targetID, message);
             g_dbus_method_invocation_return_value(invocation, nullptr);
         } else if (!g_strcmp0(methodName, "StartAutomationSession")) {
             const char* sessionID;
             GRefPtr<GVariant> sessionCapabilities;
             g_variant_get(parameters, "(&s@a{sv})", &sessionID, &sessionCapabilities.outPtr());
             auto capabilities = processSessionCapabilities(sessionCapabilities.get());
             inspectorServer->startAutomationSession(connection, sessionID, capabilities);
             auto clientCapabilities = RemoteInspector::singleton().clientCapabilities();
             g_dbus_method_invocation_return_value(invocation, g_variant_new("(ss)",
                 clientCapabilities ? clientCapabilities->browserName.utf8().data() : "",
                 clientCapabilities ? clientCapabilities->browserVersion.utf8().data() : ""));
         } else
             g_dbus_method_invocation_return_value(invocation, nullptr);
     },
     // get_property
     nullptr,
     // set_property
     nullptr,
     // padding
     { 0 }
 };

 RemoteInspectorServer& RemoteInspectorServer::singleton()
 {
     static RemoteInspectorServer server;
     return server;
 }

 RemoteInspectorServer::~RemoteInspectorServer()
 {
     g_cancellable_cancel(m_cancellable.get());
     if (m_dbusServer)
         g_dbus_server_stop(m_dbusServer.get());
     if (m_introspectionData)
         g_dbus_node_info_unref(m_introspectionData);
 }

 GDBusInterfaceInfo* RemoteInspectorServer::interfaceInfo()
 {
     if (!m_introspectionData) {
         m_introspectionData = g_dbus_node_info_new_for_xml(RemoteInspectorServerInternal::introspectionXML, nullptr);
         ASSERT(m_introspectionData);
     }
     return m_introspectionData->interfaces[0];
 }

 bool RemoteInspectorServer::start(const char* address, unsigned port)
 {
     GUniquePtr<char> dbusAddress(g_strdup_printf("tcp:host=%s,port=%u", address, port));
     GUniquePtr<char> uid(g_dbus_generate_guid());

     m_cancellable = adoptGRef(g_cancellable_new());

     GUniqueOutPtr<GError> error;
     m_dbusServer = adoptGRef(g_dbus_server_new_sync(dbusAddress.get(), G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, uid.get(), nullptr, m_cancellable.get(), &error.outPtr()));
     if (!m_dbusServer) {
         if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
             g_warning("Failed to start remote inspector server on %s: %s\n", dbusAddress.get(), error->message);
         return false;
     }

     g_signal_connect(m_dbusServer.get(), "new-connection", G_CALLBACK(newConnectionCallback), this);
     g_dbus_server_start(m_dbusServer.get());

     return true;
 }

 gboolean RemoteInspectorServer::newConnectionCallback(GDBusServer*, GDBusConnection* connection, RemoteInspectorServer* inspectorServer)
 {
     inspectorServer->newConnection(connection);
     return TRUE;
 }

 void RemoteInspectorServer::connectionClosedCallback(GDBusConnection* connection, gboolean /*remotePeerVanished*/, GError*, RemoteInspectorServer* server)
 {
     server->connectionClosed(connection);
 }

 void RemoteInspectorServer::newConnection(GDBusConnection* connection)
 {
     ASSERT(!m_connections.contains(connection));
     m_connections.add(connection);
     g_signal_connect(connection, "closed", G_CALLBACK(connectionClosedCallback), this);

     g_dbus_connection_register_object(connection, INSPECTOR_DBUS_OBJECT_PATH, interfaceInfo(), &s_interfaceVTable, this, nullptr, nullptr);
 }

 namespace RemoteInspectorServerInternal {
 static void dbusConnectionCallAsyncReadyCallback(GObject* source, GAsyncResult* result, gpointer)
 {
     GUniqueOutPtr<GError> error;
     GRefPtr<GVariant> resultVariant = adoptGRef(g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error.outPtr()));
     if (!resultVariant && !g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
         WTFLogAlways("RemoteInspectorServer failed to send DBus message: %s", error->message);
 }
 }

 void RemoteInspectorServer::setTargetList(GDBusConnection* remoteInspectorConnection, GVariant* parameters)
 {
     ASSERT(m_connections.contains(remoteInspectorConnection));
     auto addResult = m_remoteInspectorConnectionToIDMap.add(remoteInspectorConnection, 0);
     if (addResult.isNewEntry) {
         addResult.iterator->value = generateConnectionID();
         m_idToRemoteInspectorConnectionMap.add(addResult.iterator->value, remoteInspectorConnection);
     }

     gboolean remoteAutomationEnabled;
     GRefPtr<GVariant> targetList;
     g_variant_get(parameters, "(@a(tsssb)b)", &targetList.outPtr(), &remoteAutomationEnabled);
     GDBusConnection* clientConnection = remoteAutomationEnabled && m_automationConnection ? m_automationConnection.get() : m_clientConnection.get();
     if (!clientConnection)
         return;

     g_dbus_connection_call(clientConnection, nullptr,
         REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
         REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
         "SetTargetList",
         g_variant_new("(t@a(tsssb))", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetList.get()),
         nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
         -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
 }

 void RemoteInspectorServer::clientConnectionClosedCallback(GDBusConnection* connection, gboolean /*remotePeerVanished*/, GError*, RemoteInspectorServer* server)
 {
     server->clientConnectionClosed(connection);
 }

 GVariant* RemoteInspectorServer::setupInspectorClient(GDBusConnection* clientConnection, const char* clientBackendCommandsHash)
 {
     ASSERT(!m_clientConnection);
     m_clientConnection = clientConnection;
     g_signal_connect(m_clientConnection.get(), "closed", G_CALLBACK(clientConnectionClosedCallback), this);

     GVariant* backendCommands;
     if (strcmp(clientBackendCommandsHash, backendCommandsHash().data())) {
         auto bytes = Inspector::backendCommands();
         backendCommands = g_variant_new_bytestring(static_cast<const char*>(g_bytes_get_data(bytes.get(), nullptr)));
     } else
         backendCommands = g_variant_new_bytestring("");

     // Ask all remote inspectors to push their target lists to notify the new client.
     for (auto* remoteInspectorConnection : m_remoteInspectorConnectionToIDMap.keys()) {
         g_dbus_connection_call(remoteInspectorConnection, nullptr,
             REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
             REMOTE_INSPECTOR_DBUS_INTERFACE,
             "GetTargetList",
             nullptr,
             nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
             -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
     }

     return backendCommands;
 }

 void RemoteInspectorServer::setup(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
 {
     ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
     ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
     if (clientConnection == m_automationConnection.get()) {
         m_automationTargets.add(std::make_pair(connectionID, targetID));
         RemoteInspector::singleton().setup(targetID);
         return;
     }

     m_inspectionTargets.add(std::make_pair(connectionID, targetID));
     auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
     g_dbus_connection_call(remoteInspectorConnection, nullptr,
         REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
         REMOTE_INSPECTOR_DBUS_INTERFACE,
         "Setup",
         g_variant_new("(t)", targetID),
         nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
         -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
 }

 void RemoteInspectorServer::close(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
 {
     ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
     ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
     if (clientConnection == m_automationConnection.get()) {
         // FIXME: automation.
         return;
     }

     ASSERT(m_inspectionTargets.contains(std::make_pair(connectionID, targetID)));
     auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
     g_dbus_connection_call(remoteInspectorConnection, nullptr,
         REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
         REMOTE_INSPECTOR_DBUS_INTERFACE,
         "FrontendDidClose",
         g_variant_new("(t)", targetID),
         nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
         -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
     m_inspectionTargets.remove(std::make_pair(connectionID, targetID));
 }

 void RemoteInspectorServer::clientConnectionClosed(GDBusConnection* clientConnection)
 {
     ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
     if (clientConnection == m_automationConnection.get()) {
         for (auto connectionTargetPair : m_automationTargets)
             close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
         m_automationConnection = nullptr;
         return;
     }

     for (auto connectionTargetPair : m_inspectionTargets)
         close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
     m_clientConnection = nullptr;
 }

 void RemoteInspectorServer::connectionClosed(GDBusConnection* remoteInspectorConnection)
 {
     ASSERT(m_connections.contains(remoteInspectorConnection));
     if (m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection)) {
         uint64_t connectionID = m_remoteInspectorConnectionToIDMap.take(remoteInspectorConnection);
         m_idToRemoteInspectorConnectionMap.remove(connectionID);
         // Send an empty target list to the clients.
         Vector<GRefPtr<GDBusConnection>> clientConnections = { m_automationConnection, m_clientConnection };
         for (auto& clientConnection : clientConnections) {
             if (!clientConnection)
                 continue;
             g_dbus_connection_call(clientConnection.get(), nullptr,
                 REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
                 REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
                 "SetTargetList",
                 g_variant_new("(t@a(tsssb))", connectionID, g_variant_new_array(G_VARIANT_TYPE("(tsssb)"), nullptr, 0)),
                 nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
                 -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
         }
     }
     m_connections.remove(remoteInspectorConnection);
 }

 void RemoteInspectorServer::sendMessageToBackend(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID, const char* message)
 {
     ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
     ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
     if (clientConnection == m_automationConnection.get()) {
         RemoteInspector::singleton().sendMessageToTarget(targetID, message);
         return;
     }

     auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
     g_dbus_connection_call(remoteInspectorConnection, nullptr,
         REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
         REMOTE_INSPECTOR_DBUS_INTERFACE,
         "SendMessageToTarget",
         g_variant_new("(t&s)", targetID, message),
         nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
         -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
 }

 void RemoteInspectorServer::sendMessageToFrontend(GDBusConnection* remoteInspectorConnection, uint64_t targetID, const char* message)
 {
     ASSERT(m_connections.contains(remoteInspectorConnection));
     ASSERT(m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection));

     uint64_t connectionID = m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection);
     auto connectionTargetPair = std::make_pair(connectionID, targetID);
     ASSERT(m_automationTargets.contains(connectionTargetPair) || m_inspectionTargets.contains(connectionTargetPair));
     GDBusConnection* clientConnection = m_inspectionTargets.contains(connectionTargetPair) ? m_clientConnection.get() : m_automationConnection.get();
     ASSERT(clientConnection);

     g_dbus_connection_call(clientConnection, nullptr,
         REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
         REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
         "SendMessageToFrontend",
         g_variant_new("(tt&s)", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetID, message),
         nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
         -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
 }

 void RemoteInspectorServer::startAutomationSession(GDBusConnection* automationConnection, const char* sessionID, const RemoteInspector::Client::SessionCapabilities& capabilities)
 {
     if (!m_automationConnection)
         m_automationConnection = automationConnection;
     ASSERT(m_automationConnection.get() == automationConnection);

     RemoteInspector::singleton().requestAutomationSession(sessionID, capabilities);
 }

 } // namespace Inspector

 #endif // ENABLE(REMOTE_INSPECTOR)
	/*
	* Copyright (C) 2017 Igalia S.L.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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.
	*/

	#include "config.h"
	#include "RemoteInspectorServer.h"

	#if ENABLE(REMOTE_INSPECTOR)

	#include "RemoteInspectorUtils.h"
	#include <gio/gio.h>
	#include <wtf/Vector.h>
	#include <wtf/glib/GUniquePtr.h>

	#define INSPECTOR_DBUS_INTERFACE "org.webkit.Inspector"
	#define INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/Inspector"
	#define REMOTE_INSPECTOR_DBUS_INTERFACE "org.webkit.RemoteInspector"
	#define REMOTE_INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/RemoteInspector"
	#define REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE "org.webkit.RemoteInspectorClient"
	#define REMOTE_INSPECTOR_CLIENT_OBJECT_PATH "/org/webkit/RemoteInspectorClient"

	namespace Inspector {

	static uint64_t generateConnectionID()
	{
	static uint64_t connectionID = 0;
	return ++connectionID;
	}

	namespace RemoteInspectorServerInternal {
	static const char introspectionXML[] =
	"<node>"
	" <interface name='" INSPECTOR_DBUS_INTERFACE "'>"
	" <method name='SetTargetList'>"
	" <arg type='a(tsssb)' name='list' direction='in'/>"
	" <arg type='b' name='remoteAutomationEnabled' direction='in'/>"
	" </method>"
	" <method name='SetupInspectorClient'>"
	" <arg type='ay' name='backendCommandsHash' direction='in'/>"
	" <arg type='ay' name='backendCommands' direction='out'/>"
	" </method>"
	" <method name='Setup'>"
	" <arg type='t' name='connection' direction='in'/>"
	" <arg type='t' name='target' direction='in'/>"
	" </method>"
	" <method name='FrontendDidClose'>"
	" <arg type='t' name='connection' direction='in'/>"
	" <arg type='t' name='target' direction='in'/>"
	" </method>"
	" <method name='SendMessageToFrontend'>"
	" <arg type='t' name='target' direction='in'/>"
	" <arg type='s' name='message' direction='in'/>"
	" </method>"
	" <method name='SendMessageToBackend'>"
	" <arg type='t' name='connection' direction='in'/>"
	" <arg type='t' name='target' direction='in'/>"
	" <arg type='s' name='message' direction='in'/>"
	" </method>"
	" <method name='StartAutomationSession'>"
	" <arg type='s' name='sessionID' direction='in'/>"
	" <arg type='a{sv}' name='capabilities' direction='in'/>"
	" <arg type='s' name='browserName' direction='out'/>"
	" <arg type='s' name='browserVersion' direction='out'/>"
	" </method>"
	" </interface>"
	"</node>";
	}

	static RemoteInspector::Client::SessionCapabilities processSessionCapabilities(GVariant* sessionCapabilities)
	{
	RemoteInspector::Client::SessionCapabilities capabilities;

	gboolean acceptInsecureCerts;
	if (g_variant_lookup(sessionCapabilities, "acceptInsecureCerts", "b", &acceptInsecureCerts))
	capabilities.acceptInsecureCertificates = acceptInsecureCerts;

	if (GRefPtr<GVariant> certificates = g_variant_lookup_value(sessionCapabilities, "certificates", G_VARIANT_TYPE("a(ss)"))) {
	GVariantIter iter;
	auto childCount = g_variant_iter_init(&iter, certificates.get());
	capabilities.certificates.reserveCapacity(childCount);
	const char* host;
	const char* certificateFile;
	while (g_variant_iter_loop(&iter, "(&s&s)", &host, &certificateFile))
	capabilities.certificates.uncheckedAppend({ String::fromUTF8(host), String::fromUTF8(certificateFile) });
	}

	return capabilities;
	}
	const GDBusInterfaceVTable RemoteInspectorServer::s_interfaceVTable = {
	// method_call
	[] (GDBusConnection* connection, const gchar* /sender/, const gchar* /objectPath/, const gchar* /interfaceName/, const gchar* methodName, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer userData) {
	auto* inspectorServer = static_cast<RemoteInspectorServer*>(userData);
	if (!g_strcmp0(methodName, "SetTargetList")) {
	inspectorServer->setTargetList(connection, parameters);
	g_dbus_method_invocation_return_value(invocation, nullptr);
	} else if (!g_strcmp0(methodName, "SetupInspectorClient")) {
	GRefPtr<GVariant> backendCommandsHash;
	g_variant_get(parameters, "(@ay)", &backendCommandsHash.outPtr());
	auto* backendCommands = inspectorServer->setupInspectorClient(connection, g_variant_get_bytestring(backendCommandsHash.get()));
	g_dbus_method_invocation_return_value(invocation, g_variant_new("(@ay)", backendCommands));
	} else if (!g_strcmp0(methodName, "Setup")) {
	guint64 connectionID, targetID;
	g_variant_get(parameters, "(tt)", &connectionID, &targetID);
	inspectorServer->setup(connection, connectionID, targetID);
	g_dbus_method_invocation_return_value(invocation, nullptr);
	} else if (!g_strcmp0(methodName, "FrontendDidClose")) {
	guint64 connectionID, targetID;
	g_variant_get(parameters, "(tt)", &connectionID, &targetID);
	inspectorServer->close(connection, connectionID, targetID);
	g_dbus_method_invocation_return_value(invocation, nullptr);
	} else if (!g_strcmp0(methodName, "SendMessageToFrontend")) {
	guint64 targetID;
	const char* message;
	g_variant_get(parameters, "(t&s)", &targetID, &message);
	inspectorServer->sendMessageToFrontend(connection, targetID, message);
	g_dbus_method_invocation_return_value(invocation, nullptr);
	} else if (!g_strcmp0(methodName, "SendMessageToBackend")) {
	guint64 connectionID, targetID;
	const char* message;
	g_variant_get(parameters, "(tt&s)", &connectionID, &targetID, &message);
	inspectorServer->sendMessageToBackend(connection, connectionID, targetID, message);
	g_dbus_method_invocation_return_value(invocation, nullptr);
	} else if (!g_strcmp0(methodName, "StartAutomationSession")) {
	const char* sessionID;
	GRefPtr<GVariant> sessionCapabilities;
	g_variant_get(parameters, "(&s@a{sv})", &sessionID, &sessionCapabilities.outPtr());
	auto capabilities = processSessionCapabilities(sessionCapabilities.get());
	inspectorServer->startAutomationSession(connection, sessionID, capabilities);
	auto clientCapabilities = RemoteInspector::singleton().clientCapabilities();
	g_dbus_method_invocation_return_value(invocation, g_variant_new("(ss)",
	clientCapabilities ? clientCapabilities->browserName.utf8().data() : "",
	clientCapabilities ? clientCapabilities->browserVersion.utf8().data() : ""));
	} else
	g_dbus_method_invocation_return_value(invocation, nullptr);
	},
	// get_property
	nullptr,
	// set_property
	nullptr,
	// padding
	{ 0 }
	};

	RemoteInspectorServer& RemoteInspectorServer::singleton()
	{
	static RemoteInspectorServer server;
	return server;
	}

	RemoteInspectorServer::~RemoteInspectorServer()
	{
	g_cancellable_cancel(m_cancellable.get());
	if (m_dbusServer)
	g_dbus_server_stop(m_dbusServer.get());
	if (m_introspectionData)
	g_dbus_node_info_unref(m_introspectionData);
	}

	GDBusInterfaceInfo* RemoteInspectorServer::interfaceInfo()
	{
	if (!m_introspectionData) {
	m_introspectionData = g_dbus_node_info_new_for_xml(RemoteInspectorServerInternal::introspectionXML, nullptr);
	ASSERT(m_introspectionData);
	}
	return m_introspectionData->interfaces[0];
	}

	bool RemoteInspectorServer::start(const char* address, unsigned port)
	{
	GUniquePtr<char> dbusAddress(g_strdup_printf("tcp:host=%s,port=%u", address, port));
	GUniquePtr<char> uid(g_dbus_generate_guid());

	m_cancellable = adoptGRef(g_cancellable_new());

	GUniqueOutPtr<GError> error;
	m_dbusServer = adoptGRef(g_dbus_server_new_sync(dbusAddress.get(), G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, uid.get(), nullptr, m_cancellable.get(), &error.outPtr()));
	if (!m_dbusServer) {
	if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
	g_warning("Failed to start remote inspector server on %s: %s\n", dbusAddress.get(), error->message);
	return false;
	}

	g_signal_connect(m_dbusServer.get(), "new-connection", G_CALLBACK(newConnectionCallback), this);
	g_dbus_server_start(m_dbusServer.get());

	return true;
	}

	gboolean RemoteInspectorServer::newConnectionCallback(GDBusServer, GDBusConnection connection, RemoteInspectorServer* inspectorServer)
	{
	inspectorServer->newConnection(connection);
	return TRUE;
	}

	void RemoteInspectorServer::connectionClosedCallback(GDBusConnection* connection, gboolean /remotePeerVanished/, GError, RemoteInspectorServer server)
	{
	server->connectionClosed(connection);
	}

	void RemoteInspectorServer::newConnection(GDBusConnection* connection)
	{
	ASSERT(!m_connections.contains(connection));
	m_connections.add(connection);
	g_signal_connect(connection, "closed", G_CALLBACK(connectionClosedCallback), this);

	g_dbus_connection_register_object(connection, INSPECTOR_DBUS_OBJECT_PATH, interfaceInfo(), &s_interfaceVTable, this, nullptr, nullptr);
	}

	namespace RemoteInspectorServerInternal {
	static void dbusConnectionCallAsyncReadyCallback(GObject* source, GAsyncResult* result, gpointer)
	{
	GUniqueOutPtr<GError> error;
	GRefPtr<GVariant> resultVariant = adoptGRef(g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error.outPtr()));
	if (!resultVariant && !g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
	WTFLogAlways("RemoteInspectorServer failed to send DBus message: %s", error->message);
	}
	}

	void RemoteInspectorServer::setTargetList(GDBusConnection* remoteInspectorConnection, GVariant* parameters)
	{
	ASSERT(m_connections.contains(remoteInspectorConnection));
	auto addResult = m_remoteInspectorConnectionToIDMap.add(remoteInspectorConnection, 0);
	if (addResult.isNewEntry) {
	addResult.iterator->value = generateConnectionID();
	m_idToRemoteInspectorConnectionMap.add(addResult.iterator->value, remoteInspectorConnection);
	}

	gboolean remoteAutomationEnabled;
	GRefPtr<GVariant> targetList;
	g_variant_get(parameters, "(@a(tsssb)b)", &targetList.outPtr(), &remoteAutomationEnabled);
	GDBusConnection* clientConnection = remoteAutomationEnabled && m_automationConnection ? m_automationConnection.get() : m_clientConnection.get();
	if (!clientConnection)
	return;

	g_dbus_connection_call(clientConnection, nullptr,
	REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
	REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
	"SetTargetList",
	g_variant_new("(t@a(tsssb))", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetList.get()),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}

	void RemoteInspectorServer::clientConnectionClosedCallback(GDBusConnection* connection, gboolean /remotePeerVanished/, GError, RemoteInspectorServer server)
	{
	server->clientConnectionClosed(connection);
	}

	GVariant* RemoteInspectorServer::setupInspectorClient(GDBusConnection* clientConnection, const char* clientBackendCommandsHash)
	{
	ASSERT(!m_clientConnection);
	m_clientConnection = clientConnection;
	g_signal_connect(m_clientConnection.get(), "closed", G_CALLBACK(clientConnectionClosedCallback), this);

	GVariant* backendCommands;
	if (strcmp(clientBackendCommandsHash, backendCommandsHash().data())) {
	auto bytes = Inspector::backendCommands();
	backendCommands = g_variant_new_bytestring(static_cast<const char*>(g_bytes_get_data(bytes.get(), nullptr)));
	} else
	backendCommands = g_variant_new_bytestring("");

	// Ask all remote inspectors to push their target lists to notify the new client.
	for (auto* remoteInspectorConnection : m_remoteInspectorConnectionToIDMap.keys()) {
	g_dbus_connection_call(remoteInspectorConnection, nullptr,
	REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
	REMOTE_INSPECTOR_DBUS_INTERFACE,
	"GetTargetList",
	nullptr,
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}

	return backendCommands;
	}

	void RemoteInspectorServer::setup(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
	{
	ASSERT(m_clientConnection.get() == clientConnection \|\| m_automationConnection.get() == clientConnection);
	ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
	if (clientConnection == m_automationConnection.get()) {
	m_automationTargets.add(std::make_pair(connectionID, targetID));
	RemoteInspector::singleton().setup(targetID);
	return;
	}

	m_inspectionTargets.add(std::make_pair(connectionID, targetID));
	auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
	g_dbus_connection_call(remoteInspectorConnection, nullptr,
	REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
	REMOTE_INSPECTOR_DBUS_INTERFACE,
	"Setup",
	g_variant_new("(t)", targetID),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}

	void RemoteInspectorServer::close(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
	{
	ASSERT(m_clientConnection.get() == clientConnection \|\| m_automationConnection.get() == clientConnection);
	ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
	if (clientConnection == m_automationConnection.get()) {
	// FIXME: automation.
	return;
	}

	ASSERT(m_inspectionTargets.contains(std::make_pair(connectionID, targetID)));
	auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
	g_dbus_connection_call(remoteInspectorConnection, nullptr,
	REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
	REMOTE_INSPECTOR_DBUS_INTERFACE,
	"FrontendDidClose",
	g_variant_new("(t)", targetID),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	m_inspectionTargets.remove(std::make_pair(connectionID, targetID));
	}

	void RemoteInspectorServer::clientConnectionClosed(GDBusConnection* clientConnection)
	{
	ASSERT(m_clientConnection.get() == clientConnection \|\| m_automationConnection.get() == clientConnection);
	if (clientConnection == m_automationConnection.get()) {
	for (auto connectionTargetPair : m_automationTargets)
	close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
	m_automationConnection = nullptr;
	return;
	}

	for (auto connectionTargetPair : m_inspectionTargets)
	close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
	m_clientConnection = nullptr;
	}

	void RemoteInspectorServer::connectionClosed(GDBusConnection* remoteInspectorConnection)
	{
	ASSERT(m_connections.contains(remoteInspectorConnection));
	if (m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection)) {
	uint64_t connectionID = m_remoteInspectorConnectionToIDMap.take(remoteInspectorConnection);
	m_idToRemoteInspectorConnectionMap.remove(connectionID);
	// Send an empty target list to the clients.
	Vector<GRefPtr<GDBusConnection>> clientConnections = { m_automationConnection, m_clientConnection };
	for (auto& clientConnection : clientConnections) {
	if (!clientConnection)
	continue;
	g_dbus_connection_call(clientConnection.get(), nullptr,
	REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
	REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
	"SetTargetList",
	g_variant_new("(t@a(tsssb))", connectionID, g_variant_new_array(G_VARIANT_TYPE("(tsssb)"), nullptr, 0)),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}
	}
	m_connections.remove(remoteInspectorConnection);
	}

	void RemoteInspectorServer::sendMessageToBackend(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID, const char* message)
	{
	ASSERT(m_clientConnection.get() == clientConnection \|\| m_automationConnection.get() == clientConnection);
	ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
	if (clientConnection == m_automationConnection.get()) {
	RemoteInspector::singleton().sendMessageToTarget(targetID, message);
	return;
	}

	auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
	g_dbus_connection_call(remoteInspectorConnection, nullptr,
	REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
	REMOTE_INSPECTOR_DBUS_INTERFACE,
	"SendMessageToTarget",
	g_variant_new("(t&s)", targetID, message),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}

	void RemoteInspectorServer::sendMessageToFrontend(GDBusConnection* remoteInspectorConnection, uint64_t targetID, const char* message)
	{
	ASSERT(m_connections.contains(remoteInspectorConnection));
	ASSERT(m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection));

	uint64_t connectionID = m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection);
	auto connectionTargetPair = std::make_pair(connectionID, targetID);
	ASSERT(m_automationTargets.contains(connectionTargetPair) \|\| m_inspectionTargets.contains(connectionTargetPair));
	GDBusConnection* clientConnection = m_inspectionTargets.contains(connectionTargetPair) ? m_clientConnection.get() : m_automationConnection.get();
	ASSERT(clientConnection);

	g_dbus_connection_call(clientConnection, nullptr,
	REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
	REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
	"SendMessageToFrontend",
	g_variant_new("(tt&s)", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetID, message),
	nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
	-1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
	}

	void RemoteInspectorServer::startAutomationSession(GDBusConnection* automationConnection, const char* sessionID, const RemoteInspector::Client::SessionCapabilities& capabilities)
	{
	if (!m_automationConnection)
	m_automationConnection = automationConnection;
	ASSERT(m_automationConnection.get() == automationConnection);

	RemoteInspector::singleton().requestAutomationSession(sessionID, capabilities);
	}

	} // namespace Inspector

	#endif // ENABLE(REMOTE_INSPECTOR)