[INSPECTOR] Wait a max of 60s before failing on loading libWPEWebInspectorResources.so

Author: magomez

Source/JavaScriptCore/inspector/remote/glib/RemoteInspectorServer.cpp

@@ -241,7 +241,7 @@ GVariant* RemoteInspectorServer::setupInspectorClient(SocketConnection& clientCo
     m_clientConnection = &clientConnection;
 
     GVariant* backendCommands;
-    if (strcmp(clientBackendCommandsHash, backendCommandsHash().data())) {
+    if (!backendCommandsHash().isNull() && 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

Source/JavaScriptCore/inspector/remote/glib/RemoteInspectorUtils.cpp

@@ -40,25 +40,18 @@ namespace Inspector {
 GRefPtr<GBytes> backendCommands()
 {
 #if PLATFORM(WPE)
-    static std::once_flag flag;
-    std::call_once(flag, [] {
-        const char* libDir = PKGLIBDIR;
-#if ENABLE(DEVELOPER_MODE)
-        // Probably no need for a specific env var here. Assume the inspector resources.so file is
-        // in the same directory as the injected bundle lib, for developer builds.
-        const char* path = g_getenv("WEBKIT_INJECTED_BUNDLE_PATH");
-        if (path && g_file_test(path, G_FILE_TEST_IS_DIR))
-            libDir = path;
-#endif
-        GUniquePtr<char> bundleFilename(g_build_filename(libDir, "libWPEWebInspectorResources.so", nullptr));
-        GModule* resourcesModule = g_module_open(bundleFilename.get(), G_MODULE_BIND_LAZY);
+    static bool moduleLoaded = false;
+
+    if (!moduleLoaded) {
+        GModule* resourcesModule = g_module_open(PKGLIBDIR G_DIR_SEPARATOR_S "libWPEWebInspectorResources.so", G_MODULE_BIND_LAZY);
         if (!resourcesModule) {
             WTFLogAlways("Error loading libWPEWebInspectorResources.so: %s", g_module_error());
-            return;
+            return nullptr;
         }
 
         g_module_make_resident(resourcesModule);
-    });
+        moduleLoaded = true;
+    }
 #endif
     GRefPtr<GBytes> bytes = adoptGRef(g_resources_lookup_data(INSPECTOR_BACKEND_COMMANDS_PATH, G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr));
     ASSERT(bytes);
@@ -70,6 +63,9 @@ const CString& backendCommandsHash()
     static CString hexDigest;
     if (hexDigest.isNull()) {
         auto bytes = backendCommands();
+        if (!bytes)
+            return hexDigest;
+
         size_t dataSize;
         gconstpointer data = g_bytes_get_data(bytes.get(), &dataSize);
         ASSERT(dataSize);

Source/WebKit/UIProcess/Inspector/glib/RemoteInspectorClient.cpp

@@ -172,6 +172,7 @@ RemoteInspectorClient::RemoteInspectorClient(String&& hostAndPort, RemoteInspect
     : m_hostAndPort(WTFMove(hostAndPort))
     , m_observer(observer)
     , m_cancellable(adoptGRef(g_cancellable_new()))
+    , m_setupInspectorClientTimer(*this, &RemoteInspectorClient::setupInspectorClientTimerFired)
 {
     GRefPtr<GSocketClient> socketClient = adoptGRef(g_socket_client_new());
     g_socket_client_connect_to_host_async(socketClient.get(), m_hostAndPort.utf8().data(), 0, m_cancellable.get(),
@@ -200,7 +201,34 @@ RemoteInspectorClient::~RemoteInspectorClient()
 void RemoteInspectorClient::setupConnection(Ref<SocketConnection>&& connection)
 {
     m_socketConnection = WTFMove(connection);
-    m_socketConnection->sendMessage("SetupInspectorClient", g_variant_new("(@ay)", g_variant_new_bytestring(Inspector::backendCommandsHash().data())));
+    setupInspectorClientTimerFired();
+}
+
+void RemoteInspectorClient::setupInspectorClientTimerFired()
+{
+    // There's an scenario where libWPEWebInspectorResources.so will not be available when the browser is
+    // launched, but will be downloaded once the network connection is up. To handle this situation we check
+    // whether the library is present bebore sending the SetupInspectorClient message. We will check for
+    // the library every 10 seconds to configure the proper commands. After 60 seconds we give up and
+    // send an empty string of commands, which causes the inspector not to work.
+    static int numTries = 0;
+
+    if (numTries <= 6 && Inspector::backendCommandsHash().isNull()) {
+        // Retry every 10 seconds for 60 seconds.
+        m_setupInspectorClientTimer.startOneShot(10_s);
+        numTries++;
+        return;
+    }
+
+    GVariant* backendCommandsHashString;
+    if (!Inspector::backendCommandsHash().isNull())
+        backendCommandsHashString = g_variant_new_bytestring(Inspector::backendCommandsHash().data());
+    else {
+        WTFLogAlways("Unable to load libWPEWebInspectorResources.so after 60 seconds: WebInspector won't work properly");
+        backendCommandsHashString = g_variant_new_bytestring("");
+    }
+
+    m_socketConnection->sendMessage("SetupInspectorClient", g_variant_new("(@ay)", backendCommandsHashString));
 }
 
 void RemoteInspectorClient::setBackendCommands(const char* backendCommands)

Source/WebKit/UIProcess/Inspector/glib/RemoteInspectorClient.h

@@ -27,6 +27,7 @@
 
 #if ENABLE(REMOTE_INSPECTOR)
 
+#include <WebCore/Timer.h>
 #include <wtf/HashMap.h>
 #include <wtf/Vector.h>
 #include <wtf/glib/GRefPtr.h>
@@ -80,6 +81,7 @@ class RemoteInspectorClient {
     void setBackendCommands(const char*);
     void setTargetList(uint64_t connectionID, Vector<Target>&&);
     void sendMessageToFrontend(uint64_t connectionID, uint64_t targetID, const char*);
+    void setupInspectorClientTimerFired();
 
     String m_hostAndPort;
     String m_backendCommandsURL;
@@ -88,6 +90,7 @@ class RemoteInspectorClient {
     GRefPtr<GCancellable> m_cancellable;
     HashMap<uint64_t, Vector<Target>> m_targets;
     HashMap<std::pair<uint64_t, uint64_t>, std::unique_ptr<RemoteInspectorProxy>> m_inspectorProxyMap;
+    WebCore::Timer m_setupInspectorClientTimer;
 };
 
 } // namespace WebKit