Changeset 249759 in webkit


Ignore:
Timestamp:
Sep 11, 2019 1:28:49 AM (5 years ago)
Author:
Carlos Garcia Campos
Message:

[GTK][WPE] Stop using the session bus in the unit tests
​https://bugs.webkit.org/show_bug.cgi?id=201636

Reviewed by Žan Doberšek.

We are actually using GTestDBus, not the actual session bus of the user session, but it would still be better to
use a private p2p DBus connection. This is also the way we encourage apps to implement the communication with
the web process extension. This patch removes the WebKitTestBus class and starts a DBus server before every
test. The server address is passed to the web extension as initialization parameter to connect directly to
it. We keep a global list of connections to the server and a HashMap to get the current active connection for
a WebKitWebView.

  • TestWebKitAPI/Tests/WebKitGLib/TestLoaderClient.cpp:

(beforeAll):
(afterAll):

  • TestWebKitAPI/Tests/WebKitGLib/TestMultiprocess.cpp:

(testProcessPerWebView):
(beforeAll):
(afterAll):

  • TestWebKitAPI/Tests/WebKitGLib/TestWebExtensions.cpp:

(testWebExtensionGetTitle):
(testWebExtensionInputElementIsUserEdited):
(testDocumentLoadedSignal):
(testWebKitWebViewProcessCrashed):
(testWebExtensionIsolatedWorld):
(testInstallMissingPluginsPermissionRequest):
(testWebExtensionFormControlsAssociated):
(FormSubmissionTest::FormSubmissionTest):
(beforeAll):
(afterAll):

  • TestWebKitAPI/Tests/WebKitGLib/WebExtensionTest.cpp:

(DelayedSignal::DelayedSignal):
(emitPageCreated):
(pageCreatedCallback):
(webkit_web_extension_initialize_with_user_data):

  • TestWebKitAPI/Tests/WebKitGtk/AccessibilityTestServer.cpp:
  • TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp:

(AccessibilityTest::AccessibilityTest):
(AccessibilityTest::ensureProxy):
(beforeAll):
(afterAll):

  • TestWebKitAPI/glib/CMakeLists.txt:
  • TestWebKitAPI/glib/WebKitGLib/TestMain.cpp:

(dbusConnectionClosed):
(dbusServerConnection):
(startDBusServer):
(stopDBusServer):
(main):

  • TestWebKitAPI/glib/WebKitGLib/TestMain.h:

(Test::initializeWebExtensions):

  • TestWebKitAPI/glib/WebKitGLib/WebKitTestBus.cpp: Removed.
  • TestWebKitAPI/glib/WebKitGLib/WebKitTestBus.h: Removed.
  • TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp:

(WebViewTest::~WebViewTest):
(WebViewTest::extensionProxy):

  • TestWebKitAPI/glib/WebKitGLib/WebViewTest.h:
Location:
trunk/Tools
Files:
2 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r249752 r249759  
     12019-09-11  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [GTK][WPE] Stop using the session bus in the unit tests
     4        https://bugs.webkit.org/show_bug.cgi?id=201636
     5
     6        Reviewed by Žan Doberšek.
     7
     8        We are actually using GTestDBus, not the actual session bus of the user session, but it would still be better to
     9        use a private p2p DBus connection. This is also the way we encourage apps to implement the communication with
     10        the web process extension. This patch removes the WebKitTestBus class and starts a DBus server before every
     11        test. The server address is passed to the web extension as initialization parameter to connect directly to
     12        it. We keep a global list of connections to the server and a HashMap to get the current active connection for
     13        a WebKitWebView.
     14
     15        * TestWebKitAPI/Tests/WebKitGLib/TestLoaderClient.cpp:
     16        (beforeAll):
     17        (afterAll):
     18        * TestWebKitAPI/Tests/WebKitGLib/TestMultiprocess.cpp:
     19        (testProcessPerWebView):
     20        (beforeAll):
     21        (afterAll):
     22        * TestWebKitAPI/Tests/WebKitGLib/TestWebExtensions.cpp:
     23        (testWebExtensionGetTitle):
     24        (testWebExtensionInputElementIsUserEdited):
     25        (testDocumentLoadedSignal):
     26        (testWebKitWebViewProcessCrashed):
     27        (testWebExtensionIsolatedWorld):
     28        (testInstallMissingPluginsPermissionRequest):
     29        (testWebExtensionFormControlsAssociated):
     30        (FormSubmissionTest::FormSubmissionTest):
     31        (beforeAll):
     32        (afterAll):
     33        * TestWebKitAPI/Tests/WebKitGLib/WebExtensionTest.cpp:
     34        (DelayedSignal::DelayedSignal):
     35        (emitPageCreated):
     36        (pageCreatedCallback):
     37        (webkit_web_extension_initialize_with_user_data):
     38        * TestWebKitAPI/Tests/WebKitGtk/AccessibilityTestServer.cpp:
     39        * TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp:
     40        (AccessibilityTest::AccessibilityTest):
     41        (AccessibilityTest::ensureProxy):
     42        (beforeAll):
     43        (afterAll):
     44        * TestWebKitAPI/glib/CMakeLists.txt:
     45        * TestWebKitAPI/glib/WebKitGLib/TestMain.cpp:
     46        (dbusConnectionClosed):
     47        (dbusServerConnection):
     48        (startDBusServer):
     49        (stopDBusServer):
     50        (main):
     51        * TestWebKitAPI/glib/WebKitGLib/TestMain.h:
     52        (Test::initializeWebExtensions):
     53        * TestWebKitAPI/glib/WebKitGLib/WebKitTestBus.cpp: Removed.
     54        * TestWebKitAPI/glib/WebKitGLib/WebKitTestBus.h: Removed.
     55        * TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp:
     56        (WebViewTest::~WebViewTest):
     57        (WebViewTest::extensionProxy):
     58        * TestWebKitAPI/glib/WebKitGLib/WebViewTest.h:
     59
    1602019-09-10  Dean Jackson  <dino@apple.com>
    261

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestLoaderClient.cpp

    r243534 r249759  
    2323
    2424#include "LoadTrackingTest.h"
    25 #include "WebKitTestBus.h"
    2625#include "WebKitTestServer.h"
    2726#include "WebViewTest.h"
    … …  
    3029#include <wtf/text/CString.h>
    3130
    32 static WebKitTestBus* bus;
    3331static WebKitTestServer* kServer;
    3432
    … …  
    494492    WebPageURITest()
    495493    {
    496         GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    497         GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    498             "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", m_mainLoop));
     494        m_proxy = extensionProxy();
    499495        m_uriChangedSignalID = g_dbus_connection_signal_subscribe(
    500             g_dbus_proxy_get_connection(proxy.get()),
     496            g_dbus_proxy_get_connection(m_proxy.get()),
    501497            0,
    502498            "org.webkit.gtk.WebExtensionTest",
    … …  
    516512    {
    517513        g_signal_handlers_disconnect_matched(m_webView, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
    518         g_dbus_connection_signal_unsubscribe(bus->connection(), m_uriChangedSignalID);
     514        g_dbus_connection_signal_unsubscribe(g_dbus_proxy_get_connection(m_proxy.get()), m_uriChangedSignalID);
    519515    }
    520516
    … …  
    533529    }
    534530
     531    GRefPtr<GDBusProxy> m_proxy;
    535532    unsigned m_uriChangedSignalID;
    536533    Vector<CString> m_webPageURIs;
    … …  
    730727void beforeAll()
    731728{
    732     bus = new WebKitTestBus();
    733     if (!bus->run())
    734         return;
    735 
    736729    kServer = new WebKitTestServer();
    737730    kServer->run(serverCallback);
    … …  
    768761void afterAll()
    769762{
    770     delete bus;
    771763    delete kServer;
    772764}

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestMultiprocess.cpp

    r249419 r249759  
    2121
    2222#include "TestMain.h"
    23 #include "WebKitTestBus.h"
    2423#include "WebViewTest.h"
    2524#include <wtf/Vector.h>
    2625
    2726static const unsigned numViews = 2;
    28 static WebKitTestBus* bus;
    2927
    3028class MultiprocessTest: public Test {
    … …  
    5553    }
    5654
    57     void loadWebViewAndWaitUntilLoaded(unsigned index)
     55    void loadWebViewAndWaitUntilPageCreated(unsigned index)
    5856    {
    5957        g_assert_cmpuint(index, <, numViews);
    … …  
    6361
    6462        webkit_web_view_load_html(m_webViews[index].get(), "<html></html>", nullptr);
    65         g_signal_connect(m_webViews[index].get(), "load-changed", G_CALLBACK(loadChanged), this);
     63        g_idle_add([](gpointer userData) -> gboolean {
     64            auto* test = static_cast<MultiprocessTest*>(userData);
     65            if (!s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(test->m_webViews[test->m_initializeWebExtensionsSignalCount - 1].get())))
     66                return TRUE;
     67
     68            g_main_loop_quit(test->m_mainLoop);
     69            return FALSE;
     70        }, this);
    6671        g_main_loop_run(m_mainLoop);
    67 
    68         m_webViewBusNames[index] = GUniquePtr<char>(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    6972    }
    7073
    … …  
    7376        g_assert_cmpuint(index, <, numViews);
    7477
    75         GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(m_webViewBusNames[index].get(),
    76             "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", m_mainLoop));
    77 
     78        GRefPtr<GDBusProxy> proxy = adoptGRef(g_dbus_proxy_new_sync(s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(m_webViews[index].get())),
     79            static_cast<GDBusProxyFlags>(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS),
     80            nullptr, nullptr, "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", nullptr, nullptr));
    7881        GRefPtr<GVariant> result = adoptGRef(g_dbus_proxy_call_sync(
    7982            proxy.get(),
    … …  
    9093
    9194#if PLATFORM(GTK)
    92     static void nameVanishedCallback(GDBusConnection* connection, const gchar* name, gpointer userData)
    93     {
    94         g_main_loop_quit(static_cast<GMainLoop*>(userData));
    95     }
    96 
    9795    void destroyWebViewAndWaitUntilWebProcessFinishes(unsigned index)
    9896    {
    9997        g_assert_cmpuint(index, <, numViews);
    10098
    101         unsigned watcherID = g_bus_watch_name_on_connection(bus->connection(), m_webViewBusNames[index].get(), G_BUS_NAME_WATCHER_FLAGS_NONE,
    102             nullptr, nameVanishedCallback, m_mainLoop, nullptr);
     99        auto* connection = s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(m_webViews[index].get()));
     100        g_assert_nonnull(connection);
     101        g_signal_connect_swapped(connection, "closed", G_CALLBACK(g_main_loop_quit), m_mainLoop);
    103102        gtk_widget_destroy(GTK_WIDGET(m_webViews[index].get()));
    104103        g_main_loop_run(m_mainLoop);
    105         g_bus_unwatch_name(watcherID);
    106104    }
    107105#endif
    … …  
    122120
    123121    for (unsigned i = 0; i < numViews; i++) {
    124         test->loadWebViewAndWaitUntilLoaded(i);
     122        test->loadWebViewAndWaitUntilPageCreated(i);
    125123        g_assert_true(WEBKIT_IS_WEB_VIEW(test->m_webViews[i].get()));
    126         g_assert_nonnull(test->m_webViewBusNames[i]);
     124        g_assert_nonnull(Test::s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(test->m_webViews[i].get())));
    127125    }
    128126
    129127    g_assert_cmpuint(test->m_initializeWebExtensionsSignalCount, ==, numViews);
    130     g_assert_cmpstr(test->m_webViewBusNames[0].get(), !=, test->m_webViewBusNames[1].get());
     128    g_assert_false(Test::s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(test->m_webViews[0].get())) == Test::s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(test->m_webViews[1].get())));
    131129    g_assert_cmpuint(test->webProcessPid(0), !=, test->webProcessPid(1));
    132130
    … …  
    254252    g_assert_cmpuint(webkit_web_context_get_process_model(webkit_web_context_get_default()), ==, WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES);
    255253
    256     bus = new WebKitTestBus();
    257     if (!bus->run())
    258         return;
    259 
    260254    MultiprocessTest::add("WebKitWebContext", "process-per-web-view", testProcessPerWebView);
    261255    UIClientMultiprocessTest::add("WebKitWebView", "multiprocess-create-ready-close", testMultiprocessWebViewCreateReadyClose);
    … …  
    264258void afterAll()
    265259{
    266     delete bus;
    267 }
     260}

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebExtensions.cpp

    r246790 r249759  
    2020#include "config.h"
    2121
    22 #include "WebKitTestBus.h"
    2322#include "WebViewTest.h"
    2423#include <wtf/glib/GRefPtr.h>
    2524
    26 static WebKitTestBus* bus;
    2725static GUniquePtr<char> scriptDialogResult;
    2826
    … …  
    3533static void testWebExtensionGetTitle(WebViewTest* test, gconstpointer)
    3634{
    37     test->loadHtml("<html><head><title>WebKitGTK Web Extensions Test</title></head><body></body></html>", 0);
    38     test->waitUntilLoadFinished();
    39 
    40     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    41     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    42         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     35    test->loadHtml("<html><head><title>WebKitGTK Web Extensions Test</title></head><body></body></html>", "http://bar.com");
     36    test->waitUntilLoadFinished();
     37
     38    auto proxy = test->extensionProxy();
    4339    GRefPtr<GVariant> result = adoptGRef(g_dbus_proxy_call_sync(
    4440        proxy.get(),
    … …  
    7672    test->waitUntilLoadFinished();
    7773
    78     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    79     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    80         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     74    auto proxy = test->extensionProxy();
    8175
    8276    uint64_t pageID = webkit_web_view_get_page_id(test->m_webView);
    … …  
    115109static void testDocumentLoadedSignal(WebViewTest* test, gconstpointer)
    116110{
    117     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    118     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    119         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     111    auto proxy = test->extensionProxy();
     112
    120113    GDBusConnection* connection = g_dbus_proxy_get_connection(proxy.get());
    121114    guint id = g_dbus_connection_signal_subscribe(connection,
    122         0,
     115        nullptr,
    123116        "org.webkit.gtk.WebExtensionTest",
    124117        "DocumentLoaded",
    125118        "/org/webkit/gtk/WebExtensionTest",
    126         0,
     119        nullptr,
    127120        G_DBUS_SIGNAL_FLAGS_NONE,
    128121        reinterpret_cast<GDBusSignalCallback>(documentLoadedCallback),
    129122        test,
    130         0);
     123        nullptr);
    131124    g_assert_cmpuint(id, !=, 0);
    132125
    133     test->loadHtml("<html><head><title>WebKitGTK Web Extensions Test</title></head><body></body></html>", 0);
     126    test->loadHtml("<html><head><title>WebKitGTK Web Extensions Test</title></head><body></body></html>", nullptr);
    134127    g_main_loop_run(test->m_mainLoop);
    135128    g_dbus_connection_signal_unsubscribe(connection, id);
    … …  
    146139static void testWebKitWebViewProcessCrashed(WebViewTest* test, gconstpointer)
    147140{
    148     test->loadHtml("<html></html>", 0);
     141    test->loadHtml("<html></html>", nullptr);
    149142    test->waitUntilLoadFinished();
    150143
    … …  
    154147    test->m_expectedWebProcessCrash = true;
    155148
    156     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    157     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    158         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
    159 
     149    auto proxy = test->extensionProxy();
    160150    GRefPtr<GVariant> result = adoptGRef(g_dbus_proxy_call_sync(
    161151        proxy.get(),
    … …  
    226216        "window.open = function () { alert('Isolated World'); }\n"
    227217        "window.open();";
    228     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    229     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    230         "/org/webkit/gtk/WebExtensionTest" , "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     218    auto proxy = test->extensionProxy();
    231219    g_dbus_proxy_call(proxy.get(),
    232220        "RunJavaScriptInIsolatedWorld",
    … …  
    265253static void testInstallMissingPluginsPermissionRequest(WebViewTest* test, gconstpointer)
    266254{
    267     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    268     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    269         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     255    auto proxy = test->extensionProxy();
    270256    GRefPtr<GVariant> result = adoptGRef(g_dbus_proxy_call_sync(proxy.get(), "RemoveAVPluginsFromGSTRegistry",
    271257        nullptr, G_DBUS_CALL_FLAGS_NONE, -1, nullptr, nullptr));
    … …  
    293279static void testWebExtensionFormControlsAssociated(WebViewTest* test, gconstpointer)
    294280{
    295     GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", Test::s_webExtensionID));
    296     GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    297         "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", test->m_mainLoop));
     281    auto proxy = test->extensionProxy();
    298282    GDBusConnection* connection = g_dbus_proxy_get_connection(proxy.get());
    299283    guint id = g_dbus_connection_signal_subscribe(connection,
    … …  
    347331    FormSubmissionTest()
    348332    {
    349         GUniquePtr<char> extensionBusName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", s_webExtensionID));
    350         m_proxy = adoptGRef(bus->createProxy(extensionBusName.get(),
    351             "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", m_mainLoop));
     333        m_proxy = extensionProxy();
    352334        GDBusConnection* connection = g_dbus_proxy_get_connection(m_proxy.get());
    353335
    … …  
    463445void beforeAll()
    464446{
    465     bus = new WebKitTestBus();
    466     if (!bus->run())
    467         return;
    468 
    469447    WebViewTest::add("WebKitWebExtension", "dom-document-title", testWebExtensionGetTitle);
    470448#if PLATFORM(GTK)
    … …  
    484462void afterAll()
    485463{
    486     delete bus;
    487 }
     464}

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/WebExtensionTest.cpp

    r245514 r249759  
    6464    "  <method name='RemoveAVPluginsFromGSTRegistry'>"
    6565    "  </method>"
     66    "  <signal name='PageCreated'>"
     67    "   <arg type='t' name='pageID' direction='out'/>"
     68    "  </signal>"
    6669    "  <signal name='DocumentLoaded'/>"
    6770    "  <signal name='FormControlsAssociated'>"
    … …  
    9093
    9194typedef enum {
     95    PageCreatedSignal,
    9296    DocumentLoadedSignal,
    9397    URIChangedSignal,
    … …  
    100104    explicit DelayedSignal(DelayedSignalType type)
    101105        : type(type)
     106    {
     107    }
     108
     109    DelayedSignal(DelayedSignalType type, guint64 n)
     110        : type(type)
     111        , n(n)
    102112    {
    103113    }
    … …  
    125135    gboolean b;
    126136    gboolean b2;
     137    guint64 n;
    127138};
    128139
    … …  
    406417}
    407418
     419static void emitPageCreated(GDBusConnection* connection, guint64 pageID)
     420{
     421    bool ok = g_dbus_connection_emit_signal(
     422        connection,
     423        nullptr,
     424        "/org/webkit/gtk/WebExtensionTest",
     425        "org.webkit.gtk.WebExtensionTest",
     426        "PageCreated",
     427        g_variant_new("(t)", pageID),
     428        nullptr);
     429    g_assert_true(ok);
     430}
     431
    408432static void pageCreatedCallback(WebKitWebExtension* extension, WebKitWebPage* webPage, gpointer)
    409433{
     434    if (auto* data = g_object_get_data(G_OBJECT(extension), "dbus-connection"))
     435        emitPageCreated(G_DBUS_CONNECTION(data), webkit_web_page_get_id(webPage));
     436    else
     437        delayedSignalsQueue.append(DelayedSignal(PageCreatedSignal, webkit_web_page_get_id(webPage)));
     438
    410439    g_signal_connect(webPage, "document-loaded", G_CALLBACK(documentLoadedCallback), extension);
    411440    g_signal_connect(webPage, "notify::uri", G_CALLBACK(uriChangedCallback), extension);
    … …  
    521550};
    522551
    523 static void busAcquiredCallback(GDBusConnection* connection, const char* name, gpointer userData)
    524 {
    525     static GDBusNodeInfo* introspectionData = 0;
     552static void dbusConnectionCreated(GObject*, GAsyncResult* result, gpointer userData)
     553{
     554    GUniqueOutPtr<GError> error;
     555    GDBusConnection* connection = g_dbus_connection_new_for_address_finish(result, &error.outPtr());
     556    g_assert(G_IS_DBUS_CONNECTION(connection));
     557    g_assert_no_error(error.get());
     558
     559    static GDBusNodeInfo* introspectionData = nullptr;
    526560    if (!introspectionData)
    527         introspectionData = g_dbus_node_info_new_for_xml(introspectionXML, 0);
    528 
    529     GUniqueOutPtr<GError> error;
     561        introspectionData = g_dbus_node_info_new_for_xml(introspectionXML, nullptr);
     562
    530563    unsigned registrationID = g_dbus_connection_register_object(
    531564        connection,
    … …  
    537570        &error.outPtr());
    538571    if (!registrationID)
    539         g_warning("Failed to register object: %s\n", error->message);
    540 
    541     g_object_set_data(G_OBJECT(userData), "dbus-connection", connection);
     572        g_error("Failed to register object: %s\n", error->message);
     573
     574    g_object_set_data_full(G_OBJECT(userData), "dbus-connection", connection, g_object_unref);
    542575    while (delayedSignalsQueue.size()) {
    543576        DelayedSignal delayedSignal = delayedSignalsQueue.takeFirst();
    544577        switch (delayedSignal.type) {
     578        case PageCreatedSignal:
     579            emitPageCreated(connection, delayedSignal.n);
     580            break;
    545581        case DocumentLoadedSignal:
    546582            emitDocumentLoaded(connection);
    … …  
    585621
    586622    g_assert_nonnull(userData);
    587     g_assert_true(g_variant_is_of_type(userData, G_VARIANT_TYPE_UINT32));
    588     GUniquePtr<char> busName(g_strdup_printf("org.webkit.gtk.WebExtensionTest%u", g_variant_get_uint32(userData)));
    589     g_bus_own_name(
    590         G_BUS_TYPE_SESSION,
    591         busName.get(),
    592         G_BUS_NAME_OWNER_FLAGS_NONE,
    593         busAcquiredCallback,
    594         0, 0,
    595         g_object_ref(extension),
    596         static_cast<GDestroyNotify>(g_object_unref));
    597 }
     623    const char* guid;
     624    const char* address;
     625    g_variant_get(userData, "(&s&s)", &guid, &address);
     626    g_assert_nonnull(guid);
     627    g_assert_nonnull(address);
     628
     629    g_dbus_connection_new_for_address(address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, nullptr, nullptr,
     630        dbusConnectionCreated, extension);
     631}

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGtk/AccessibilityTestServer.cpp

    r244212 r249759  
    7777    gtk_widget_show_all(window);
    7878
    79     g_bus_own_name(G_BUS_TYPE_SESSION, "org.webkit.gtk.AccessibilityTest", G_BUS_NAME_OWNER_FLAGS_NONE,
    80         [](GDBusConnection* connection, const char* name, gpointer userData) {
     79    g_dbus_connection_new_for_address(argv[1], G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, nullptr, nullptr,
     80        [](GObject*, GAsyncResult* result, gpointer userData) {
     81            GDBusConnection* connection = g_dbus_connection_new_for_address_finish(result, nullptr);
     82
    8183            static GDBusNodeInfo *introspectionData = nullptr;
    8284            if (!introspectionData)
    … …  
    8587            g_dbus_connection_register_object(connection, "/org/webkit/gtk/AccessibilityTest", introspectionData->interfaces[0],
    8688                &interfaceVirtualTable, userData, nullptr, nullptr);
    87         }, nullptr, nullptr, webView, nullptr);
     89        }, webView);
    8890
    8991    gtk_main();

  • trunk/Tools/TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp

    r244212 r249759  
    2121
    2222#include "TestMain.h"
    23 #include "WebKitTestBus.h"
    2423
    2524// The libatspi headers don't use G_BEGIN_DECLS
    … …  
    2827}
    2928
    30 static WebKitTestBus* bus;
    31 
    3229class AccessibilityTest : public Test {
    3330public:
    … …  
    3734    {
    3835        GUniquePtr<char> testServerPath(g_build_filename(WEBKIT_EXEC_PATH, "TestWebKitAPI", "WebKit2Gtk", "AccessibilityTestServer", nullptr));
    39         char* args[2];
     36        char* args[3];
    4037        args[0] = testServerPath.get();
    41         args[1] = nullptr;
     38        args[1] = const_cast<char*>(g_dbus_server_get_client_address(s_dbusServer.get()));
     39        args[2] = nullptr;
    4240
    4341        g_assert_true(g_spawn_async(nullptr, args, nullptr, G_SPAWN_DEFAULT, nullptr, nullptr, &m_childProcessID, nullptr));
    … …  
    124122
    125123        m_mainLoop = adoptGRef(g_main_loop_new(nullptr, FALSE));
    126         m_proxy = adoptGRef(bus->createProxy("org.webkit.gtk.AccessibilityTest", "/org/webkit/gtk/AccessibilityTest", "org.webkit.gtk.AccessibilityTest", m_mainLoop.get()));
     124
     125        if (s_dbusConnections.isEmpty()) {
     126            g_idle_add([](gpointer userData) -> gboolean {
     127                if (s_dbusConnections.isEmpty())
     128                    return TRUE;
     129
     130                g_main_loop_quit(static_cast<GMainLoop*>(userData));
     131                return FALSE;
     132            }, m_mainLoop.get());
     133            g_main_loop_run(m_mainLoop.get());
     134        }
     135
     136        m_proxy = adoptGRef(g_dbus_proxy_new_sync(s_dbusConnections[0].get(), static_cast<GDBusProxyFlags>(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS),
     137            nullptr, nullptr, "/org/webkit/gtk/AccessibilityTest", "org.webkit.gtk.AccessibilityTest", nullptr, nullptr));
     138        g_assert_true(G_IS_DBUS_PROXY(m_proxy.get()));
    127139    }
    128140
    … …  
    217229void beforeAll()
    218230{
    219     bus = new WebKitTestBus();
    220     if (!bus->run())
    221         return;
    222 
    223231    AccessibilityTest::add("WebKitAccessibility", "atspi-basic-hierarchy", testAtspiBasicHierarchy);
    224232}
    … …  
    226234void afterAll()
    227235{
    228     delete bus;
    229 }
     236}

  • trunk/Tools/TestWebKitAPI/glib/CMakeLists.txt

    r249575 r249759  
    11set(WebKitGLibAPITests_SOURCES
    22    ${TOOLS_DIR}/TestWebKitAPI/glib/WebKitGLib/LoadTrackingTest.cpp
    3     ${TOOLS_DIR}/TestWebKitAPI/glib/WebKitGLib/WebKitTestBus.cpp
    43    ${TOOLS_DIR}/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp
    54    ${TOOLS_DIR}/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp

  • trunk/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp

    r241654 r249759  
    2727#endif
    2828
    29 uint32_t Test::s_webExtensionID = 0;
     29GRefPtr<GDBusServer> Test::s_dbusServer;
     30Vector<GRefPtr<GDBusConnection>> Test::s_dbusConnections;
     31HashMap<uint64_t, GDBusConnection*> Test::s_dbusConnectionPageMap;
    3032
    3133void beforeAll();
    … …  
    6567}
    6668
     69static void dbusConnectionClosed(GDBusConnection* connection)
     70{
     71    auto it = Test::s_dbusConnections.find(connection);
     72    g_assert(it != notFound);
     73
     74    for (auto it : Test::s_dbusConnectionPageMap) {
     75        if (it.value == connection)
     76            it.value = nullptr;
     77    }
     78    Test::s_dbusConnections.remove(it);
     79}
     80
     81static gboolean dbusServerConnection(GDBusServer* server, GDBusConnection* connection)
     82{
     83    g_signal_connect(connection, "closed", G_CALLBACK(dbusConnectionClosed), nullptr);
     84    g_assert(!Test::s_dbusConnections.contains(connection));
     85    Test::s_dbusConnections.append(connection);
     86
     87    g_dbus_connection_signal_subscribe(connection, nullptr, "org.webkit.gtk.WebExtensionTest", "PageCreated", "/org/webkit/gtk/WebExtensionTest",
     88        nullptr, G_DBUS_SIGNAL_FLAGS_NONE, [](GDBusConnection* connection, const char*, const char*, const char*, const char*, GVariant* parameters, gpointer) {
     89            guint64 pageID;
     90            g_variant_get(parameters, "(t)", &pageID);
     91            g_assert(Test::s_dbusConnections.contains(connection));
     92            Test::s_dbusConnectionPageMap.set(pageID, connection);
     93        }, nullptr, nullptr);
     94
     95    return TRUE;
     96}
     97
     98static void startDBusServer()
     99{
     100    GUniqueOutPtr<GError> error;
     101    GUniquePtr<char> address(g_strdup_printf("unix:tmpdir=%s", testDataDirectory.get()));
     102    GUniquePtr<char> guid(g_dbus_generate_guid());
     103    Test::s_dbusServer = adoptGRef(g_dbus_server_new_sync(address.get(), G_DBUS_SERVER_FLAGS_NONE, guid.get(), nullptr, nullptr, &error.outPtr()));
     104    if (!Test::s_dbusServer)
     105        g_error("Failed to start DBus server: %s", error->message);
     106
     107    g_signal_connect(Test::s_dbusServer.get(), "new-connection", G_CALLBACK(dbusServerConnection), nullptr);
     108    g_dbus_server_start(Test::s_dbusServer.get());
     109}
     110
     111static void stopDBusServer()
     112{
     113    g_dbus_server_stop(Test::s_dbusServer.get());
     114    Test::s_dbusServer = nullptr;
     115}
     116
    67117int main(int argc, char** argv)
    68118{
    … …  
    83133
    84134    registerGResource();
     135    startDBusServer();
    85136
    86137    beforeAll();
    … …  
    88139    afterAll();
    89140
     141    stopDBusServer();
    90142    removeNonEmptyDirectory(testDataDirectory.get());
    91143

  • trunk/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h

    r249192 r249759  
    2222#include <cairo.h>
    2323#include <glib-object.h>
     24#include <wtf/HashMap.h>
    2425#include <wtf/HashSet.h>
     26#include <wtf/Vector.h>
    2527#include <wtf/glib/GRefPtr.h>
    2628#include <wtf/glib/GUniquePtr.h>
    … …  
    151153    {
    152154        webkit_web_context_set_web_extensions_directory(m_webContext.get(), WEBKIT_TEST_WEB_EXTENSIONS_DIR);
    153         webkit_web_context_set_web_extensions_initialization_user_data(m_webContext.get(), g_variant_new_uint32(++s_webExtensionID));
     155        webkit_web_context_set_web_extensions_initialization_user_data(m_webContext.get(),
     156            g_variant_new("(ss)", g_dbus_server_get_guid(s_dbusServer.get()), g_dbus_server_get_client_address(s_dbusServer.get())));
    154157    }
    155158
    … …  
    273276    HashSet<GObject*> m_watchedObjects;
    274277    GRefPtr<WebKitWebContext> m_webContext;
    275     static uint32_t s_webExtensionID;
     278    static GRefPtr<GDBusServer> s_dbusServer;
     279    static Vector<GRefPtr<GDBusConnection>> s_dbusConnections;
     280    static HashMap<uint64_t, GDBusConnection*> s_dbusConnectionPageMap;
    276281};

  • trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp

    r239772 r249759  
    4242    if (m_surface)
    4343        cairo_surface_destroy(m_surface);
     44    s_dbusConnectionPageMap.remove(webkit_web_view_get_page_id(m_webView));
    4445    g_object_unref(m_webView);
    4546    g_main_loop_unref(m_mainLoop);
    … …  
    394395    return javascriptResultToBoolean(javascriptResult);
    395396}
     397
     398GRefPtr<GDBusProxy> WebViewTest::extensionProxy()
     399{
     400    GDBusConnection* connection = nullptr;
     401
     402    // If nothing has been loaded yet, load about:blank to force the web process to be spawned.
     403    if (!webkit_web_view_get_uri(m_webView)) {
     404        loadURI("about:blank");
     405        waitUntilLoadFinished();
     406
     407        connection = s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(m_webView));
     408        if (!connection) {
     409            // Wait for page created signal.
     410            g_idle_add([](gpointer userData) -> gboolean {
     411                auto* test = static_cast<WebViewTest*>(userData);
     412                if (!s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(test->m_webView)))
     413                    return TRUE;
     414
     415                test->quitMainLoop();
     416                return FALSE;
     417            }, this);
     418            g_main_loop_run(m_mainLoop);
     419            // FIXME: we can cache this once we can monitor the page id on the web view.
     420            connection = s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(m_webView));
     421        }
     422    } else
     423        connection = s_dbusConnectionPageMap.get(webkit_web_view_get_page_id(m_webView));
     424
     425    return adoptGRef(g_dbus_proxy_new_sync(connection, static_cast<GDBusProxyFlags>(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS),
     426        nullptr, nullptr, "/org/webkit/gtk/WebExtensionTest", "org.webkit.gtk.WebExtensionTest", nullptr, nullptr));
     427}

  • trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.h

    r239203 r249759  
    9797    static gboolean webProcessTerminated(WebKitWebView*, WebKitWebProcessTerminationReason, WebViewTest*);
    9898
     99    GRefPtr<GDBusProxy> extensionProxy();
     100
    99101    GRefPtr<WebKitUserContentManager> m_userContentManager;
    100102    WebKitWebView* m_webView { nullptr };
Note: See TracChangeset for help on using the changeset viewer.