Google Git
Sign in
webkit / WebKit / 15e4da4b5ce83fcfe6de6863df44c60571019d5f / . / Tools / TestWebKitAPI / Tests / WebKitGLib / TestWebKitWebView.cpp
blob: 8cdd239a71ae91ca134b592f79c9f01cb9d59481 [file] [log] [blame]
/*
* Copyright (C) 2011 Igalia S.L.
* Copyright (C) 2014 Collabora Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2,1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "WebKitTestServer.h"
#include "WebViewTest.h"
#include <WebCore/SoupVersioning.h>
#include <glib/gstdio.h>
#include <wtf/glib/GRefPtr.h>
#if PLATFORM(WPE) && USE(WPEBACKEND_FDO_AUDIO_EXTENSION)
#include <wpe/extensions/audio.h>
#endif
class IsPlayingAudioWebViewTest : public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(IsPlayingAudioWebViewTest);
static void isPlayingAudioChanged(GObject*, GParamSpec*, IsPlayingAudioWebViewTest* test)
{
g_signal_handlers_disconnect_by_func(test->m_webView, reinterpret_cast<void*>(isPlayingAudioChanged), test);
g_main_loop_quit(test->m_mainLoop);
}
void waitUntilIsPlayingAudioChanged()
{
g_signal_connect(m_webView, "notify::is-playing-audio", G_CALLBACK(isPlayingAudioChanged), this);
g_main_loop_run(m_mainLoop);
}
void periodicallyCheckIsPlayingForAWhile()
{
m_tickCount = 0;
g_timeout_add(50, [](gpointer userData) -> gboolean {
auto* test = static_cast<IsPlayingAudioWebViewTest*>(userData);
g_assert_true(webkit_web_view_is_playing_audio(test->m_webView));
test->m_tickCount++;
if (test->m_tickCount >= 10) {
test->quitMainLoop();
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}, this);
g_main_loop_run(m_mainLoop);
}
private:
uint32_t m_tickCount { 0 };
};
static WebKitTestServer* gServer;
static void testWebViewWebContext(WebViewTest* test, gconstpointer)
{
g_assert_true(webkit_web_view_get_context(test->m_webView) == test->m_webContext.get());
g_assert_true(webkit_web_context_get_default() != test->m_webContext.get());
// Check that a web view created with g_object_new has the default context.
auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
#if PLATFORM(WPE)
"backend", Test::createWebViewBackend(),
#endif
nullptr));
g_assert_true(webkit_web_view_get_context(webView.get()) == webkit_web_context_get_default());
// Check that a web view created with a related view has the related view context.
webView = Test::adoptView(Test::createWebView(test->m_webView));
g_assert_true(webkit_web_view_get_context(webView.get()) == test->m_webContext.get());
// Check that a web context given as construct parameter is ignored if a related view is also provided.
webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
#if PLATFORM(WPE)
"backend", Test::createWebViewBackend(),
#endif
"web-context", webkit_web_context_get_default(),
"related-view", test->m_webView,
nullptr));
g_assert_true(webkit_web_view_get_context(webView.get()) == test->m_webContext.get());
}
static void testWebViewWebContextLifetime(WebViewTest* test, gconstpointer)
{
WebKitWebContext* webContext = webkit_web_context_new();
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webContext));
auto* webView = Test::createWebView(webContext);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView));
#if PLATFORM(GTK)
g_object_ref_sink(webView);
#endif
g_object_unref(webContext);
// Check that the web view still has a valid context.
WebKitWebContext* tmpContext = webkit_web_view_get_context(WEBKIT_WEB_VIEW(webView));
g_assert_true(WEBKIT_IS_WEB_CONTEXT(tmpContext));
g_object_unref(webView);
WebKitWebContext* webContext2 = webkit_web_context_new();
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webContext2));
auto* webView2 = Test::createWebView(webContext2);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView2));
#if PLATFORM(GTK)
g_object_ref_sink(webView2);
#endif
g_object_unref(webView2);
// Check that the context is still valid.
g_assert_true(WEBKIT_IS_WEB_CONTEXT(webContext2));
g_object_unref(webContext2);
}
static void testWebViewCloseQuickly(WebViewTest* test, gconstpointer)
{
auto webView = Test::adoptView(Test::createWebView());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView.get()));
g_idle_add([](gpointer userData) -> gboolean {
static_cast<WebViewTest*>(userData)->quitMainLoop();
return G_SOURCE_REMOVE;
}, test);
g_main_loop_run(test->m_mainLoop);
webView = nullptr;
}
#if PLATFORM(WPE)
static void testWebViewWebBackend(Test* test, gconstpointer)
{
static struct wpe_view_backend_interface s_testingInterface = {
// create
[](void*, struct wpe_view_backend*) -> void* { return nullptr; },
// destroy
[](void*) { },
// initialize
[](void*) { },
// get_renderer_host_fd
[](void*) -> int { return -1; },
// padding
nullptr,
nullptr,
nullptr,
nullptr
};
// User provided backend with default deleter (we don't have a way to check the backend will be actually freed).
GRefPtr<WebKitWebView> webView = adoptGRef(webkit_web_view_new(webkit_web_view_backend_new(wpe_view_backend_create_with_backend_interface(&s_testingInterface, nullptr), nullptr, nullptr)));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView.get()));
auto* viewBackend = webkit_web_view_get_backend(webView.get());
g_assert_nonnull(viewBackend);
auto* wpeBackend = webkit_web_view_backend_get_wpe_backend(viewBackend);
g_assert_nonnull(wpeBackend);
webView = nullptr;
// User provided backend with destroy notify.
wpeBackend = wpe_view_backend_create_with_backend_interface(&s_testingInterface, nullptr);
webView = adoptGRef(webkit_web_view_new(webkit_web_view_backend_new(wpeBackend, [](gpointer userData) {
auto* backend = *static_cast<struct wpe_view_backend**>(userData);
wpe_view_backend_destroy(backend);
*static_cast<struct wpe_view_backend**>(userData) = nullptr;
}, &wpeBackend)));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView.get()));
webView = nullptr;
g_assert_null(wpeBackend);
// User provided backend owned by another object with destroy notify.
static bool hasInstance = false;
struct BackendOwner {
BackendOwner(struct wpe_view_backend* backend)
: backend(backend)
{
hasInstance = true;
}
~BackendOwner()
{
wpe_view_backend_destroy(backend);
hasInstance = false;
}
struct wpe_view_backend* backend;
};
auto* owner = new BackendOwner(wpe_view_backend_create_with_backend_interface(&s_testingInterface, nullptr));
g_assert_true(hasInstance);
webView = adoptGRef(webkit_web_view_new(webkit_web_view_backend_new(owner->backend, [](gpointer userData) {
delete static_cast<BackendOwner*>(userData);
}, owner)));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView.get()));
g_assert_true(hasInstance);
webView = nullptr;
g_assert_false(hasInstance);
}
#endif // PLATFORM(WPE)
static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent, WebViewTest* test)
{
if (loadEvent != WEBKIT_LOAD_FINISHED)
return;
g_signal_handlers_disconnect_by_func(webView, reinterpret_cast<void*>(ephemeralViewloadChanged), test);
test->quitMainLoop();
}
static void testWebViewEphemeral(WebViewTest* test, gconstpointer)
{
g_assert_false(webkit_web_view_is_ephemeral(test->m_webView));
g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(test->m_webView)));
auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
g_assert_true(webkit_web_view_get_website_data_manager(test->m_webView) == manager);
webkit_website_data_manager_clear(manager, WEBKIT_WEBSITE_DATA_DISK_CACHE, 0, nullptr, [](GObject* manager, GAsyncResult* result, gpointer userData) {
webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(manager), result, nullptr);
static_cast<WebViewTest*>(userData)->quitMainLoop();
}, test);
g_main_loop_run(test->m_mainLoop);
// A WebView on a non ephemeral context can be ephemeral.
auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
#if PLATFORM(WPE)
"backend", Test::createWebViewBackend(),
#endif
"web-context", webkit_web_view_get_context(test->m_webView),
"is-ephemeral", TRUE,
nullptr));
g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));
g_assert_true(webkit_web_view_get_website_data_manager(webView.get()) != manager);
g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
webkit_web_view_load_uri(webView.get(), gServer->getURIForPath("/").data());
g_main_loop_run(test->m_mainLoop);
// Disk cache delays the storing of initial resources for 1 second to avoid
// affecting early page load. So, wait 1 second here to make sure resources
// have already been stored.
test->wait(1);
webkit_website_data_manager_fetch(manager, WEBKIT_WEBSITE_DATA_DISK_CACHE, nullptr, [](GObject* manager, GAsyncResult* result, gpointer userData) {
auto* test = static_cast<WebViewTest*>(userData);
g_assert_null(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(manager), result, nullptr));
test->quitMainLoop();
}, test);
g_main_loop_run(test->m_mainLoop);
}
static void testWebViewCustomCharset(WebViewTest* test, gconstpointer)
{
test->loadURI(gServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
g_assert_null(webkit_web_view_get_custom_charset(test->m_webView));
webkit_web_view_set_custom_charset(test->m_webView, "utf8");
// Changing the charset reloads the page, so wait until reloaded.
test->waitUntilLoadFinished();
g_assert_cmpstr(webkit_web_view_get_custom_charset(test->m_webView), ==, "utf8");
// Go back to the default charset and wait until reloaded.
webkit_web_view_set_custom_charset(test->m_webView, nullptr);
test->waitUntilLoadFinished();
g_assert_null(webkit_web_view_get_custom_charset(test->m_webView));
}
static void testWebViewSettings(WebViewTest* test, gconstpointer)
{
WebKitSettings* defaultSettings = webkit_web_view_get_settings(test->m_webView);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(defaultSettings));
g_assert_nonnull(defaultSettings);
g_assert_true(webkit_settings_get_enable_javascript(defaultSettings));
GRefPtr<WebKitSettings> newSettings = adoptGRef(webkit_settings_new());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(newSettings.get()));
g_object_set(G_OBJECT(newSettings.get()), "enable-javascript", FALSE, NULL);
webkit_web_view_set_settings(test->m_webView, newSettings.get());
WebKitSettings* settings = webkit_web_view_get_settings(test->m_webView);
g_assert_true(settings != defaultSettings);
g_assert_false(webkit_settings_get_enable_javascript(settings));
auto webView2 = Test::adoptView(Test::createWebView());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView2.get()));
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView2.get()), settings);
g_assert_true(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView2.get())) == settings);
GRefPtr<WebKitSettings> newSettings2 = adoptGRef(webkit_settings_new());
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(newSettings2.get()));
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView2.get()), newSettings2.get());
settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView2.get()));
g_assert_true(settings == newSettings2.get());
g_assert_true(webkit_settings_get_enable_javascript(settings));
auto webView3 = Test::adoptView(Test::createWebView(newSettings2.get()));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView3.get()));
g_assert_true(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView3.get())) == newSettings2.get());
}
static void testWebViewZoomLevel(WebViewTest* test, gconstpointer)
{
g_assert_cmpfloat(webkit_web_view_get_zoom_level(test->m_webView), ==, 1);
webkit_web_view_set_zoom_level(test->m_webView, 2.5);
g_assert_cmpfloat(webkit_web_view_get_zoom_level(test->m_webView), ==, 2.5);
webkit_settings_set_zoom_text_only(webkit_web_view_get_settings(test->m_webView), TRUE);
// The zoom level shouldn't change when zoom-text-only setting changes.
g_assert_cmpfloat(webkit_web_view_get_zoom_level(test->m_webView), ==, 2.5);
}
static void testWebViewRunJavaScript(WebViewTest* test, gconstpointer)
{
static const char* html = "<html><body><a id='WebKitLink' href='http://www.webkitgtk.org/' title='WebKitGTK Title'>WebKitGTK Website</a></body></html>";
test->loadHtml(html, 0);
test->waitUntilLoadFinished();
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.document.getElementById('WebKitLink').title;", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
GUniquePtr<char> valueString(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "WebKitGTK Title");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.document.getElementById('WebKitLink').href;", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "http://www.webkitgtk.org/");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.document.getElementById('WebKitLink').textContent", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "WebKitGTK Website");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a = 25;", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_cmpfloat(WebViewTest::javascriptResultToNumber(javascriptResult), ==, 25);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a = 2.5;", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_cmpfloat(WebViewTest::javascriptResultToNumber(javascriptResult), ==, 2.5);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a = true", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultToBoolean(javascriptResult));
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a = false", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_false(WebViewTest::javascriptResultToBoolean(javascriptResult));
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a = null", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultIsNull(javascriptResult));
javascriptResult = test->runJavaScriptAndWaitUntilFinished("function Foo() { a = 25; } Foo();", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultIsUndefined(javascriptResult));
javascriptResult = test->runJavaScriptFromGResourceAndWaitUntilFinished("/org/webkit/glib/tests/link-title.js", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "WebKitGTK Title");
javascriptResult = test->runJavaScriptFromGResourceAndWaitUntilFinished("/wrong/path/to/resource.js", &error.outPtr());
g_assert_null(javascriptResult);
g_assert_error(error.get(), G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("foo();", &error.outPtr());
g_assert_null(javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
// Values of the main world are not available in the isolated one.
javascriptResult = test->runJavaScriptInWorldAndWaitUntilFinished("a", "WebExtensionTestScriptWorld", &error.outPtr());
g_assert_null(javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
javascriptResult = test->runJavaScriptInWorldAndWaitUntilFinished("a = 50", "WebExtensionTestScriptWorld", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_cmpfloat(WebViewTest::javascriptResultToNumber(javascriptResult), ==, 50);
// Values of the isolated world are not available in the normal one.
javascriptResult = test->runJavaScriptAndWaitUntilFinished("a", &error.outPtr());
g_assert_nonnull(javascriptResult);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webkit_javascript_result_get_js_value(javascriptResult)));
g_assert_no_error(error.get());
g_assert_cmpfloat(WebViewTest::javascriptResultToNumber(javascriptResult), ==, 25);
// Running a script in a world that doesn't exist should fail.
javascriptResult = test->runJavaScriptInWorldAndWaitUntilFinished("a", "InvalidScriptWorld", &error.outPtr());
g_assert_null(javascriptResult);
g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
}
class FullScreenClientTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(FullScreenClientTest);
enum FullScreenEvent {
None,
Enter,
Leave
};
static gboolean viewEnterFullScreenCallback(WebKitWebView*, FullScreenClientTest* test)
{
test->m_event = Enter;
g_main_loop_quit(test->m_mainLoop);
return FALSE;
}
static gboolean viewLeaveFullScreenCallback(WebKitWebView*, FullScreenClientTest* test)
{
test->m_event = Leave;
g_main_loop_quit(test->m_mainLoop);
return FALSE;
}
FullScreenClientTest()
: m_event(None)
{
webkit_settings_set_enable_fullscreen(webkit_web_view_get_settings(m_webView), TRUE);
g_signal_connect(m_webView, "enter-fullscreen", G_CALLBACK(viewEnterFullScreenCallback), this);
g_signal_connect(m_webView, "leave-fullscreen", G_CALLBACK(viewLeaveFullScreenCallback), this);
}
~FullScreenClientTest()
{
g_signal_handlers_disconnect_matched(m_webView, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
}
void requestFullScreenAndWaitUntilEnteredFullScreen()
{
m_event = None;
webkit_web_view_run_javascript(m_webView, "document.documentElement.webkitRequestFullScreen();", 0, 0, 0);
g_main_loop_run(m_mainLoop);
}
static gboolean leaveFullScreenIdle(FullScreenClientTest* test)
{
#if PLATFORM(GTK)
test->keyStroke(GDK_KEY_Escape);
#else
test->keyStroke(WPE_KEY_Escape);
#endif
return FALSE;
}
void leaveFullScreenAndWaitUntilLeftFullScreen()
{
m_event = None;
g_idle_add(reinterpret_cast<GSourceFunc>(leaveFullScreenIdle), this);
g_main_loop_run(m_mainLoop);
}
FullScreenEvent m_event;
};
#if ENABLE(FULLSCREEN_API)
static void testWebViewFullScreen(FullScreenClientTest* test, gconstpointer)
{
test->showInWindow();
test->loadHtml("<html><body>FullScreen test</body></html>", 0);
test->waitUntilLoadFinished();
test->requestFullScreenAndWaitUntilEnteredFullScreen();
g_assert_cmpint(test->m_event, ==, FullScreenClientTest::Enter);
test->leaveFullScreenAndWaitUntilLeftFullScreen();
g_assert_cmpint(test->m_event, ==, FullScreenClientTest::Leave);
}
#endif
static void testWebViewCanShowMIMEType(WebViewTest* test, gconstpointer)
{
// Supported MIME types.
g_assert_true(webkit_web_view_can_show_mime_type(test->m_webView, "text/html"));
g_assert_true(webkit_web_view_can_show_mime_type(test->m_webView, "text/plain"));
g_assert_true(webkit_web_view_can_show_mime_type(test->m_webView, "image/jpeg"));
// Unsupported MIME types.
g_assert_false(webkit_web_view_can_show_mime_type(test->m_webView, "text/vcard"));
g_assert_false(webkit_web_view_can_show_mime_type(test->m_webView, "application/zip"));
g_assert_false(webkit_web_view_can_show_mime_type(test->m_webView, "application/octet-stream"));
#if ENABLE(NETSCAPE_PLUGIN_API)
// Plugins are only supported when enabled.
webkit_web_context_set_additional_plugins_directory(webkit_web_view_get_context(test->m_webView), WEBKIT_TEST_PLUGIN_DIR);
g_assert_true(webkit_web_view_can_show_mime_type(test->m_webView, "application/x-webkit-test-netscape"));
webkit_settings_set_enable_plugins(webkit_web_view_get_settings(test->m_webView), FALSE);
g_assert_false(webkit_web_view_can_show_mime_type(test->m_webView, "application/x-webkit-test-netscape"));
#endif
}
#if PLATFORM(GTK)
class FormClientTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(FormClientTest);
static void submitFormCallback(WebKitWebView*, WebKitFormSubmissionRequest* request, FormClientTest* test)
{
test->submitForm(request);
}
FormClientTest()
: m_submitPositionX(0)
, m_submitPositionY(0)
{
g_signal_connect(m_webView, "submit-form", G_CALLBACK(submitFormCallback), this);
}
~FormClientTest()
{
g_signal_handlers_disconnect_matched(m_webView, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
}
void submitForm(WebKitFormSubmissionRequest* request)
{
assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
m_request = request;
webkit_form_submission_request_submit(request);
quitMainLoop();
}
GHashTable* getTextFieldsAsHashTable()
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
return webkit_form_submission_request_get_text_fields(m_request.get());
#pragma GCC diagnostic pop
}
GPtrArray* getTextFieldNames()
{
GPtrArray* names;
webkit_form_submission_request_list_text_fields(m_request.get(), &names, nullptr);
return names;
}
GPtrArray* getTextFieldValues()
{
GPtrArray* values;
webkit_form_submission_request_list_text_fields(m_request.get(), nullptr, &values);
return values;
}
static gboolean doClickIdleCallback(FormClientTest* test)
{
test->clickMouseButton(test->m_submitPositionX, test->m_submitPositionY, 1);
return FALSE;
}
void submitFormAtPosition(int x, int y)
{
m_submitPositionX = x;
m_submitPositionY = y;
g_idle_add(reinterpret_cast<GSourceFunc>(doClickIdleCallback), this);
g_main_loop_run(m_mainLoop);
}
int m_submitPositionX;
int m_submitPositionY;
GRefPtr<WebKitFormSubmissionRequest> m_request;
};
static void testWebViewSubmitForm(FormClientTest* test, gconstpointer)
{
test->showInWindow();
const char* formHTML =
"<html><body>"
" <form action='#'>"
" <input type='text' name='text1' value='value1'>"
" <input type='text' name='text2' value='value2'>"
" <input type='text' value='value3'>"
" <input type='text' name='text2'>"
" <input type='password' name='password' value='secret'>"
" <textarea cols='5' rows='5' name='textarea'>Text</textarea>"
" <input type='hidden' name='hidden1' value='hidden1'>"
" <input type='submit' value='Submit' style='position:absolute; left:1; top:1' size='10'>"
" </form>"
"</body></html>";
test->loadHtml(formHTML, "file:///");
test->waitUntilLoadFinished();
test->submitFormAtPosition(5, 5);
GHashTable* tableValues = test->getTextFieldsAsHashTable();
g_assert_nonnull(tableValues);
g_assert_cmpuint(g_hash_table_size(tableValues), ==, 4);
g_assert_cmpstr(static_cast<char*>(g_hash_table_lookup(tableValues, "text1")), ==, "value1");
g_assert_cmpstr(static_cast<char*>(g_hash_table_lookup(tableValues, "")), ==, "value3");
g_assert_cmpstr(static_cast<char*>(g_hash_table_lookup(tableValues, "text2")), ==, "");
g_assert_cmpstr(static_cast<char*>(g_hash_table_lookup(tableValues, "password")), ==, "secret");
GPtrArray* names = test->getTextFieldNames();
g_assert_nonnull(names);
g_assert_cmpuint(names->len, ==, 5);
g_assert_cmpstr(static_cast<char*>(names->pdata[0]), ==, "text1");
g_assert_cmpstr(static_cast<char*>(names->pdata[1]), ==, "text2");
g_assert_cmpstr(static_cast<char*>(names->pdata[2]), ==, "");
g_assert_cmpstr(static_cast<char*>(names->pdata[3]), ==, "text2");
g_assert_cmpstr(static_cast<char*>(names->pdata[4]), ==, "password");
GPtrArray* values = test->getTextFieldValues();
g_assert_nonnull(values);
g_assert_cmpuint(values->len, ==, 5);
g_assert_cmpstr(static_cast<char*>(values->pdata[0]), ==, "value1");
g_assert_cmpstr(static_cast<char*>(values->pdata[1]), ==, "value2");
g_assert_cmpstr(static_cast<char*>(values->pdata[2]), ==, "value3");
g_assert_cmpstr(static_cast<char*>(values->pdata[3]), ==, "");
g_assert_cmpstr(static_cast<char*>(values->pdata[4]), ==, "secret");
}
#endif // PLATFORM(GTK)
class SaveWebViewTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(SaveWebViewTest);
SaveWebViewTest()
: m_tempDirectory(g_dir_make_tmp("WebKit2SaveViewTest-XXXXXX", 0))
{
}
~SaveWebViewTest()
{
if (G_IS_FILE(m_file.get()))
g_file_delete(m_file.get(), 0, 0);
if (G_IS_INPUT_STREAM(m_inputStream.get()))
g_input_stream_close(m_inputStream.get(), 0, 0);
if (m_tempDirectory)
g_rmdir(m_tempDirectory.get());
}
static void webViewSavedToStreamCallback(GObject* object, GAsyncResult* result, SaveWebViewTest* test)
{
GUniqueOutPtr<GError> error;
test->m_inputStream = adoptGRef(webkit_web_view_save_finish(test->m_webView, result, &error.outPtr()));
g_assert_true(G_IS_INPUT_STREAM(test->m_inputStream.get()));
g_assert_no_error(error.get());
test->quitMainLoop();
}
static void webViewSavedToFileCallback(GObject* object, GAsyncResult* result, SaveWebViewTest* test)
{
GUniqueOutPtr<GError> error;
g_assert_true(webkit_web_view_save_to_file_finish(test->m_webView, result, &error.outPtr()));
g_assert_no_error(error.get());
test->quitMainLoop();
}
void saveAndWaitForStream()
{
webkit_web_view_save(m_webView, WEBKIT_SAVE_MODE_MHTML, 0, reinterpret_cast<GAsyncReadyCallback>(webViewSavedToStreamCallback), this);
g_main_loop_run(m_mainLoop);
}
void saveAndWaitForFile()
{
m_saveDestinationFilePath.reset(g_build_filename(m_tempDirectory.get(), "testWebViewSaveResult.mht", NULL));
m_file = adoptGRef(g_file_new_for_path(m_saveDestinationFilePath.get()));
webkit_web_view_save_to_file(m_webView, m_file.get(), WEBKIT_SAVE_MODE_MHTML, 0, reinterpret_cast<GAsyncReadyCallback>(webViewSavedToFileCallback), this);
g_main_loop_run(m_mainLoop);
}
GUniquePtr<char> m_tempDirectory;
GUniquePtr<char> m_saveDestinationFilePath;
GRefPtr<GInputStream> m_inputStream;
GRefPtr<GFile> m_file;
};
static void testWebViewSave(SaveWebViewTest* test, gconstpointer)
{
test->loadHtml("<html>"
"<body>"
" <p>A paragraph with plain text</p>"
" <p>"
" A red box: <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3AYWDTMVwnSZnwAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAAFklEQVQI12P8z8DAwMDAxMDAwMDAAAANHQEDK+mmyAAAAABJRU5ErkJggg=='></br>"
" A blue box: <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3AYWDTMvBHhALQAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAAFklEQVQI12Nk4PnPwMDAxMDAwMDAAAALrwEPPIs1pgAAAABJRU5ErkJggg=='>"
" </p>"
"</body>"
"</html>", 0);
test->waitUntilLoadFinished();
// Write to a file and to an input stream.
test->saveAndWaitForFile();
test->saveAndWaitForStream();
// We should have exactly the same amount of bytes in the file
// than those coming from the GInputStream. We don't compare the
// strings read since the 'Date' field and the boundaries will be
// different on each case. MHTML functionality will be tested by
// Layout tests, so checking the amount of bytes is enough.
GUniqueOutPtr<GError> error;
gchar buffer[512] = { 0 };
gssize readBytes = 0;
gssize totalBytesFromStream = 0;
while ((readBytes = g_input_stream_read(test->m_inputStream.get(), &buffer, 512, 0, &error.outPtr()))) {
g_assert_no_error(error.get());
totalBytesFromStream += readBytes;
}
// Check that the file exists and that it contains the same amount of bytes.
GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_info(test->m_file.get(), G_FILE_ATTRIBUTE_STANDARD_SIZE, static_cast<GFileQueryInfoFlags>(0), 0, 0));
g_assert_cmpint(g_file_info_get_size(fileInfo.get()), ==, totalBytesFromStream);
}
// To test page visibility API. Currently only 'visible', 'hidden' and 'prerender' states are implemented fully in WebCore.
// See also http://www.w3.org/TR/2011/WD-page-visibility-20110602/ and https://developers.google.com/chrome/whitepapers/pagevisibility
static void testWebViewPageVisibility(WebViewTest* test, gconstpointer)
{
test->loadHtml("<html><title></title>"
"<body><p>Test Web Page Visibility</p>"
"<script>"
"document.addEventListener(\"visibilitychange\", onVisibilityChange, false);"
"function onVisibilityChange() {"
" document.title = document.visibilityState;"
"}"
"</script>"
"</body></html>",
0);
// Wait until the page is loaded. Initial visibility should be 'prerender'.
test->waitUntilLoadFinished();
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.visibilityState;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
GUniquePtr<char> valueString(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "hidden");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.hidden;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultToBoolean(javascriptResult));
// Show the page. The visibility should be updated to 'visible'.
test->showInWindow();
test->waitUntilTitleChangedTo("visible");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.visibilityState;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "visible");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.hidden;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
g_assert_false(WebViewTest::javascriptResultToBoolean(javascriptResult));
// Hide the page. The visibility should be updated to 'hidden'.
test->hideView();
test->waitUntilTitleChangedTo("hidden");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.visibilityState;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "hidden");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.hidden;", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultToBoolean(javascriptResult));
}
static void testWebViewDocumentFocus(WebViewTest* test, gconstpointer)
{
if (!g_strcmp0(g_getenv("UNDER_XVFB"), "yes")) {
g_test_skip("This tests doesn't work under Xvfb");
return;
}
test->showInWindow();
test->loadHtml("<html><title></title>"
"<body onload='document.getElementById(\"editable\").focus()'>"
"<input id='editable'></input>"
"<script>"
"document.addEventListener(\"visibilitychange\", onVisibilityChange, false);"
"function onVisibilityChange() {"
" document.title = document.visibilityState;"
"}"
"</script>"
"</body></html>",
nullptr);
test->waitUntilLoadFinished();
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.hasFocus();", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
g_assert_true(WebViewTest::javascriptResultToBoolean(javascriptResult));
// Hide the view to make it lose the focus, the window is still the active one though.
test->hideView();
test->waitUntilTitleChangedTo("hidden");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("document.hasFocus();", &error.outPtr());
g_assert_nonnull(javascriptResult);
g_assert_no_error(error.get());
g_assert_false(WebViewTest::javascriptResultToBoolean(javascriptResult));
}
#if PLATFORM(GTK)
class SnapshotWebViewTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(SnapshotWebViewTest);
static void onSnapshotCancelledReady(WebKitWebView* web_view, GAsyncResult* res, SnapshotWebViewTest* test)
{
GUniqueOutPtr<GError> error;
test->m_surface = webkit_web_view_get_snapshot_finish(web_view, res, &error.outPtr());
g_assert_null(test->m_surface);
g_assert_error(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED);
test->quitMainLoop();
}
gboolean getSnapshotAndCancel()
{
if (m_surface)
cairo_surface_destroy(m_surface);
m_surface = 0;
GRefPtr<GCancellable> cancellable = adoptGRef(g_cancellable_new());
webkit_web_view_get_snapshot(m_webView, WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_NONE, cancellable.get(), reinterpret_cast<GAsyncReadyCallback>(onSnapshotCancelledReady), this);
g_cancellable_cancel(cancellable.get());
g_main_loop_run(m_mainLoop);
return true;
}
};
static void testWebViewSnapshot(SnapshotWebViewTest* test, gconstpointer)
{
test->loadHtml("<html><head><style>html { width: 200px; height: 100px; } ::-webkit-scrollbar { display: none; }</style></head><body><p>Whatever</p></body></html>", nullptr);
test->waitUntilLoadFinished();
// WEBKIT_SNAPSHOT_REGION_VISIBLE returns a null surface when the view is not visible.
cairo_surface_t* surface1 = test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_NONE);
g_assert_null(surface1);
// WEBKIT_SNAPSHOT_REGION_FULL_DOCUMENT works even if the window is not visible.
surface1 = test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_FULL_DOCUMENT, WEBKIT_SNAPSHOT_OPTIONS_NONE);
g_assert_nonnull(surface1);
g_assert_cmpuint(cairo_surface_get_type(surface1), ==, CAIRO_SURFACE_TYPE_IMAGE);
g_assert_cmpint(cairo_image_surface_get_width(surface1), ==, 200);
g_assert_cmpint(cairo_image_surface_get_height(surface1), ==, 100);
// Show the WebView in a popup widow of 50x50 and try again with WEBKIT_SNAPSHOT_REGION_VISIBLE.
test->showInWindow(50, 50);
surface1 = cairo_surface_reference(test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_NONE));
g_assert_nonnull(surface1);
g_assert_cmpuint(cairo_surface_get_type(surface1), ==, CAIRO_SURFACE_TYPE_IMAGE);
g_assert_cmpint(cairo_image_surface_get_width(surface1), ==, 50);
g_assert_cmpint(cairo_image_surface_get_height(surface1), ==, 50);
// Select all text in the WebView, request a snapshot ignoring selection.
test->selectAll();
cairo_surface_t* surface2 = test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_NONE);
g_assert_nonnull(surface2);
g_assert_true(Test::cairoSurfacesEqual(surface1, surface2));
// Request a new snapshot, including the selection this time. The size should be the same but the result
// must be different to the one previously obtained.
surface2 = test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_INCLUDE_SELECTION_HIGHLIGHTING);
g_assert_cmpuint(cairo_surface_get_type(surface2), ==, CAIRO_SURFACE_TYPE_IMAGE);
g_assert_cmpint(cairo_image_surface_get_width(surface1), ==, cairo_image_surface_get_width(surface2));
g_assert_cmpint(cairo_image_surface_get_height(surface1), ==, cairo_image_surface_get_height(surface2));
g_assert_false(Test::cairoSurfacesEqual(surface1, surface2));
// Get a snpashot with a transparent background, the result must be different.
surface2 = test->getSnapshotAndWaitUntilReady(WEBKIT_SNAPSHOT_REGION_VISIBLE, WEBKIT_SNAPSHOT_OPTIONS_TRANSPARENT_BACKGROUND);
g_assert_cmpuint(cairo_surface_get_type(surface2), ==, CAIRO_SURFACE_TYPE_IMAGE);
g_assert_cmpint(cairo_image_surface_get_width(surface1), ==, cairo_image_surface_get_width(surface2));
g_assert_cmpint(cairo_image_surface_get_height(surface1), ==, cairo_image_surface_get_height(surface2));
g_assert_false(Test::cairoSurfacesEqual(surface1, surface2));
cairo_surface_destroy(surface1);
// Test that cancellation works.
g_assert_true(test->getSnapshotAndCancel());
}
#endif // PLATFORM(GTK)
#if ENABLE(NOTIFICATIONS)
class NotificationWebViewTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE_WITH_SETUP_TEARDOWN(NotificationWebViewTest, setup, teardown);
static void setup()
{
WebViewTest::shouldInitializeWebViewInConstructor = false;
}
static void teardown()
{
WebViewTest::shouldInitializeWebViewInConstructor = true;
}
enum NotificationEvent {
None,
Permission,
Shown,
Clicked,
OnClicked,
Closed,
OnClosed,
};
static gboolean permissionRequestCallback(WebKitWebView*, WebKitPermissionRequest *request, NotificationWebViewTest* test)
{
g_assert_true(WEBKIT_IS_NOTIFICATION_PERMISSION_REQUEST(request));
g_assert_true(test->m_isExpectingPermissionRequest);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
test->m_event = Permission;
webkit_permission_request_allow(request);
g_main_loop_quit(test->m_mainLoop);
return TRUE;
}
static gboolean notificationClosedCallback(WebKitNotification* notification, NotificationWebViewTest* test)
{
g_assert_true(test->m_notification == notification);
test->m_notification = nullptr;
test->m_event = Closed;
if (g_main_loop_is_running(test->m_mainLoop))
g_main_loop_quit(test->m_mainLoop);
return TRUE;
}
static gboolean notificationClickedCallback(WebKitNotification* notification, NotificationWebViewTest* test)
{
g_assert_true(test->m_notification == notification);
test->m_event = Clicked;
return TRUE;
}
static gboolean showNotificationCallback(WebKitWebView*, WebKitNotification* notification, NotificationWebViewTest* test)
{
g_assert_null(test->m_notification);
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(notification));
test->m_notification = notification;
g_signal_connect(notification, "closed", G_CALLBACK(notificationClosedCallback), test);
g_signal_connect(notification, "clicked", G_CALLBACK(notificationClickedCallback), test);
test->m_event = Shown;
g_main_loop_quit(test->m_mainLoop);
return TRUE;
}
static void notificationsMessageReceivedCallback(WebKitUserContentManager* userContentManager, WebKitJavascriptResult* javascriptResult, NotificationWebViewTest* test)
{
GUniquePtr<char> valueString(WebViewTest::javascriptResultToCString(javascriptResult));
if (g_str_equal(valueString.get(), "clicked"))
test->m_event = OnClicked;
else if (g_str_equal(valueString.get(), "closed"))
test->m_event = OnClosed;
g_main_loop_quit(test->m_mainLoop);
}
void initialize()
{
initializeWebView();
g_signal_connect(m_webView, "permission-request", G_CALLBACK(permissionRequestCallback), this);
g_signal_connect(m_webView, "show-notification", G_CALLBACK(showNotificationCallback), this);
webkit_user_content_manager_register_script_message_handler(m_userContentManager.get(), "notifications");
g_signal_connect(m_userContentManager.get(), "script-message-received::notifications", G_CALLBACK(notificationsMessageReceivedCallback), this);
}
~NotificationWebViewTest()
{
g_signal_handlers_disconnect_matched(m_webView, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
g_signal_handlers_disconnect_matched(m_userContentManager.get(), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
webkit_user_content_manager_unregister_script_message_handler(m_userContentManager.get(), "notifications");
}
bool hasPermission()
{
auto* result = runJavaScriptAndWaitUntilFinished("Notification.permission;", nullptr);
g_assert_nonnull(result);
GUniquePtr<char> value(javascriptResultToCString(result));
return !g_strcmp0(value.get(), "granted");
}
void requestPermissionAndWaitUntilGiven()
{
m_event = None;
m_isExpectingPermissionRequest = true;
webkit_web_view_run_javascript(m_webView, "Notification.requestPermission();", nullptr, nullptr, nullptr);
g_main_loop_run(m_mainLoop);
}
void requestNotificationAndWaitUntilShown(const char* title, const char* body)
{
m_event = None;
GUniquePtr<char> jscode(g_strdup_printf("n = new Notification('%s', { body: '%s'});", title, body));
webkit_web_view_run_javascript(m_webView, jscode.get(), nullptr, nullptr, nullptr);
g_main_loop_run(m_mainLoop);
}
void requestNotificationAndWaitUntilShown(const char* title, const char* body, const char* tag)
{
m_event = None;
GUniquePtr<char> jscode(g_strdup_printf("n = new Notification('%s', { body: '%s', tag: '%s'});", title, body, tag));
webkit_web_view_run_javascript(m_webView, jscode.get(), nullptr, nullptr, nullptr);
g_main_loop_run(m_mainLoop);
}
void clickNotificationAndWaitUntilClicked()
{
m_event = None;
runJavaScriptAndWaitUntilFinished("n.onclick = function() { window.webkit.messageHandlers.notifications.postMessage('clicked'); }", nullptr);
webkit_notification_clicked(m_notification);
g_assert_cmpint(m_event, ==, Clicked);
g_main_loop_run(m_mainLoop);
}
void closeNotificationAndWaitUntilClosed()
{
m_event = None;
webkit_web_view_run_javascript(m_webView, "n.close()", nullptr, nullptr, nullptr);
g_main_loop_run(m_mainLoop);
}
void closeNotificationAndWaitUntilOnClosed()
{
g_assert_nonnull(m_notification);
m_event = None;
runJavaScriptAndWaitUntilFinished("n.onclose = function() { window.webkit.messageHandlers.notifications.postMessage('closed'); }", nullptr);
webkit_notification_close(m_notification);
g_assert_cmpint(m_event, ==, Closed);
g_main_loop_run(m_mainLoop);
}
NotificationEvent m_event { None };
WebKitNotification* m_notification { nullptr };
bool m_isExpectingPermissionRequest { false };
bool m_hasPermission { false };
};
static void testWebViewNotification(NotificationWebViewTest* test, gconstpointer)
{
test->initialize();
// Notifications don't work with local or special schemes.
test->loadURI(gServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
g_assert_false(test->hasPermission());
test->requestPermissionAndWaitUntilGiven();
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Permission);
g_assert_true(test->hasPermission());
static const char* title = "This is a notification";
static const char* body = "This is the body.";
static const char* tag = "This is the tag.";
test->requestNotificationAndWaitUntilShown(title, body, tag);
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Shown);
g_assert_nonnull(test->m_notification);
g_assert_cmpstr(webkit_notification_get_title(test->m_notification), ==, title);
g_assert_cmpstr(webkit_notification_get_body(test->m_notification), ==, body);
g_assert_cmpstr(webkit_notification_get_tag(test->m_notification), ==, tag);
test->clickNotificationAndWaitUntilClicked();
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::OnClicked);
test->closeNotificationAndWaitUntilClosed();
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Closed);
test->requestNotificationAndWaitUntilShown(title, body);
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Shown);
g_assert_cmpstr(webkit_notification_get_tag(test->m_notification), ==, nullptr);
test->closeNotificationAndWaitUntilOnClosed();
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::OnClosed);
// The first notification should be closed automatically because the tag is
// the same. It will crash in showNotificationCallback on failure.
test->requestNotificationAndWaitUntilShown(title, body, tag);
test->requestNotificationAndWaitUntilShown(title, body, tag);
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Shown);
}
static void setInitialNotificationPermissionsAllowedCallback(WebKitWebContext* context, NotificationWebViewTest* test)
{
GList* allowedOrigins = g_list_prepend(nullptr, webkit_security_origin_new_for_uri(gServer->baseURL().string().utf8().data()));
webkit_web_context_initialize_notification_permissions(test->m_webContext.get(), allowedOrigins, nullptr);
g_list_free_full(allowedOrigins, reinterpret_cast<GDestroyNotify>(webkit_security_origin_unref));
}
static void setInitialNotificationPermissionsDisallowedCallback(WebKitWebContext* context, NotificationWebViewTest* test)
{
GList* disallowedOrigins = g_list_prepend(nullptr, webkit_security_origin_new_for_uri(gServer->baseURL().string().utf8().data()));
webkit_web_context_initialize_notification_permissions(test->m_webContext.get(), nullptr, disallowedOrigins);
g_list_free_full(disallowedOrigins, reinterpret_cast<GDestroyNotify>(webkit_security_origin_unref));
}
static void testWebViewNotificationInitialPermissionAllowed(NotificationWebViewTest* test, gconstpointer)
{
g_signal_connect(test->m_webContext.get(), "initialize-notification-permissions", G_CALLBACK(setInitialNotificationPermissionsAllowedCallback), test);
test->initialize();
test->loadURI(gServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
g_assert_true(test->hasPermission());
test->requestNotificationAndWaitUntilShown("This is a notification", "This is the body.");
g_assert_cmpint(test->m_event, ==, NotificationWebViewTest::Shown);
}
static void testWebViewNotificationInitialPermissionDisallowed(NotificationWebViewTest* test, gconstpointer)
{
g_signal_connect(test->m_webContext.get(), "initialize-notification-permissions", G_CALLBACK(setInitialNotificationPermissionsDisallowedCallback), test);
test->initialize();
test->loadURI(gServer->getURIForPath("/").data());
test->waitUntilLoadFinished();
g_assert_false(test->hasPermission());
}
#endif // ENABLE(NOTIFICATIONS)
static void testWebViewIsPlayingAudio(IsPlayingAudioWebViewTest* test, gconstpointer)
{
// The web view must be realized for the video to start playback and
// trigger changes in WebKitWebView::is-playing-audio.
test->showInWindow();
// Initially, web views should always report no audio being played.
g_assert_false(webkit_web_view_is_playing_audio(test->m_webView));
g_assert_false(webkit_web_view_get_is_muted(test->m_webView));
GUniquePtr<char> resourcePath(g_build_filename(Test::getResourcesDir(Test::WebKit2Resources).data(), "file-with-video.html", nullptr));
GUniquePtr<char> resourceURL(g_filename_to_uri(resourcePath.get(), nullptr, nullptr));
webkit_web_view_load_uri(test->m_webView, resourceURL.get());
test->waitUntilLoadFinished();
g_assert_false(webkit_web_view_is_playing_audio(test->m_webView));
test->runJavaScriptAndWaitUntilFinished("playVideo();", nullptr);
if (!webkit_web_view_is_playing_audio(test->m_webView))
test->waitUntilIsPlayingAudioChanged();
g_assert_true(webkit_web_view_is_playing_audio(test->m_webView));
// Mute the page, webkit_web_view_is_playing_audio() should still return TRUE.
webkit_web_view_set_is_muted(test->m_webView, TRUE);
g_assert_true(webkit_web_view_get_is_muted(test->m_webView));
test->periodicallyCheckIsPlayingForAWhile();
g_assert_true(webkit_web_view_is_playing_audio(test->m_webView));
webkit_web_view_set_is_muted(test->m_webView, FALSE);
g_assert_false(webkit_web_view_get_is_muted(test->m_webView));
g_assert_true(webkit_web_view_is_playing_audio(test->m_webView));
// Pause the video, and check again.
test->runJavaScriptAndWaitUntilFinished("document.getElementById('test-video').pause();", nullptr);
if (webkit_web_view_is_playing_audio(test->m_webView))
test->waitUntilIsPlayingAudioChanged();
g_assert_false(webkit_web_view_is_playing_audio(test->m_webView));
}
static void testWebViewIsAudioMuted(WebViewTest* test, gconstpointer)
{
g_assert_false(webkit_web_view_get_is_muted(test->m_webView));
webkit_web_view_set_is_muted(test->m_webView, TRUE);
g_assert_true(webkit_web_view_get_is_muted(test->m_webView));
webkit_web_view_set_is_muted(test->m_webView, FALSE);
g_assert_false(webkit_web_view_get_is_muted(test->m_webView));
}
static void testWebViewAutoplayPolicy(WebViewTest* test, gconstpointer)
{
WebKitWebsitePolicies* policies = webkit_web_view_get_website_policies(test->m_webView);
g_assert_cmpint(webkit_website_policies_get_autoplay_policy(policies), ==, WEBKIT_AUTOPLAY_ALLOW_WITHOUT_SOUND);
}
static void testWebViewIsWebProcessResponsive(WebViewTest* test, gconstpointer)
{
static const char* hangHTML =
"<html>"
" <body>"
" <script>"
" setTimeout(function() {"
" var start = new Date().getTime();"
" var end = start;"
" while(end < start + 4000) {"
" end = new Date().getTime();"
" }"
" }, 500);"
" </script>"
" </body>"
"</html>";
g_assert_true(webkit_web_view_get_is_web_process_responsive(test->m_webView));
test->loadHtml(hangHTML, nullptr);
test->waitUntilLoadFinished();
// Wait 1 second, so the js while loop kicks in and blocks the web process. Then try to load a new
// page. As the web process is busy this won't work, and after 3 seconds the web process will be marked
// as unresponsive.
test->wait(1);
test->loadHtml("<html></html>", nullptr);
test->waitUntilIsWebProcessResponsiveChanged();
g_assert_false(webkit_web_view_get_is_web_process_responsive(test->m_webView));
// 500ms after the web process is marked as unresponsive, the js while loop will finish and the process
// will be responsive again, finishing the pending load.
test->waitUntilLoadFinished();
g_assert_true(webkit_web_view_get_is_web_process_responsive(test->m_webView));
}
static void testWebViewBackgroundColor(WebViewTest* test, gconstpointer)
{
#if PLATFORM(GTK)
#define ColorType GdkRGBA
#elif PLATFORM(WPE)
#define ColorType WebKitColor
#endif
// White is the default background.
ColorType rgba;
webkit_web_view_get_background_color(test->m_webView, &rgba);
g_assert_cmpfloat(rgba.red, ==, 1);
g_assert_cmpfloat(rgba.green, ==, 1);
g_assert_cmpfloat(rgba.blue, ==, 1);
g_assert_cmpfloat(rgba.alpha, ==, 1);
// Set a different (semi-transparent red).
rgba.red = 1;
rgba.green = 0;
rgba.blue = 0;
rgba.alpha = 0.5;
webkit_web_view_set_background_color(test->m_webView, &rgba);
g_assert_cmpfloat(rgba.red, ==, 1);
g_assert_cmpfloat(rgba.green, ==, 0);
g_assert_cmpfloat(rgba.blue, ==, 0);
g_assert_cmpfloat(rgba.alpha, ==, 0.5);
#if PLATFORM(WPE)
ColorType color;
g_assert(webkit_color_parse(&color, "red"));
g_assert_cmpfloat(color.red, ==, 1);
webkit_web_view_set_background_color(test->m_webView, &color);
webkit_web_view_get_background_color(test->m_webView, &rgba);
g_assert_cmpfloat(rgba.red, ==, 1);
g_assert_cmpfloat(rgba.green, ==, 0);
g_assert_cmpfloat(rgba.blue, ==, 0);
g_assert_cmpfloat(rgba.alpha, ==, 1);
#endif
// The actual rendering can't be tested using unit tests, use
// MiniBrowser --bg-color="<color-value>" for manually testing this API.
}
#if PLATFORM(GTK)
static void testWebViewPreferredSize(WebViewTest* test, gconstpointer)
{
test->loadHtml("<html style='width: 325px; height: 615px'></html>", nullptr);
test->waitUntilLoadFinished();
test->showInWindow();
GtkRequisition minimunSize, naturalSize;
gtk_widget_get_preferred_size(GTK_WIDGET(test->m_webView), &minimunSize, &naturalSize);
g_assert_cmpint(minimunSize.width, ==, 0);
g_assert_cmpint(minimunSize.height, ==, 0);
g_assert_cmpint(naturalSize.width, ==, 325);
g_assert_cmpint(naturalSize.height, ==, 615);
}
#endif
class WebViewTitleTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(WebViewTitleTest);
static void titleChangedCallback(WebKitWebView* view, GParamSpec*, WebViewTitleTest* test)
{
test->m_webViewTitles.append(webkit_web_view_get_title(view));
}
WebViewTitleTest()
{
g_signal_connect(m_webView, "notify::title", G_CALLBACK(titleChangedCallback), this);
}
Vector<CString> m_webViewTitles;
};
static void testWebViewTitleChange(WebViewTitleTest* test, gconstpointer)
{
g_assert_cmpint(test->m_webViewTitles.size(), ==, 0);
test->loadHtml("<head><title>Page Title</title></head>", nullptr);
test->waitUntilTitleChanged();
g_assert_cmpint(test->m_webViewTitles.size(), ==, 1);
g_assert_cmpstr(test->m_webViewTitles[0].data(), ==, "Page Title");
test->loadHtml("<head><title>Another Page Title</title></head>", nullptr);
test->waitUntilTitleChanged();
g_assert_cmpint(test->m_webViewTitles.size(), ==, 2);
g_assert_cmpstr(test->m_webViewTitles[1].data(), ==, "");
test->waitUntilTitleChanged();
g_assert_cmpint(test->m_webViewTitles.size(), ==, 3);
/* Page title should be immediately unset when loading a new page. */
g_assert_cmpstr(test->m_webViewTitles[2].data(), ==, "Another Page Title");
test->loadHtml("<p>This page has no title!</p>", nullptr);
test->waitUntilLoadFinished();
g_assert_cmpint(test->m_webViewTitles.size(), ==, 4);
g_assert_cmpstr(test->m_webViewTitles[3].data(), ==, "");
test->loadHtml("<script>document.title = 'one'; document.title = 'two'; document.title = 'three';</script>", nullptr);
test->waitUntilTitleChanged();
g_assert_cmpint(test->m_webViewTitles.size(), ==, 5);
g_assert_cmpstr(test->m_webViewTitles[4].data(), ==, "three");
}
#if PLATFORM(WPE)
class FrameDisplayedTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(FrameDisplayedTest);
static void titleChangedCallback(WebKitWebView* view, GParamSpec*, WebViewTitleTest* test)
{
test->m_webViewTitles.append(webkit_web_view_get_title(view));
}
FrameDisplayedTest()
: m_id(webkit_web_view_add_frame_displayed_callback(m_webView, [](WebKitWebView*, gpointer userData) {
auto* test = static_cast<FrameDisplayedTest*>(userData);
if (!test->m_maxFrames)
return;
if (++test->m_frameCounter == test->m_maxFrames)
RunLoop::main().dispatch([test] { test->quitMainLoop(); });
}, this, nullptr))
{
g_assert_cmpuint(m_id, >, 0);
}
~FrameDisplayedTest()
{
webkit_web_view_remove_frame_displayed_callback(m_webView, m_id);
}
void waitUntilFramesDisplayed(unsigned framesCount = 1)
{
m_maxFrames = framesCount;
m_frameCounter = 0;
g_main_loop_run(m_mainLoop);
}
unsigned m_id { 0 };
unsigned m_frameCounter { 0 };
unsigned m_maxFrames { 0 };
};
static void testWebViewFrameDisplayed(FrameDisplayedTest* test, gconstpointer)
{
test->showInWindow();
test->loadHtml("<html></html>", nullptr);
test->waitUntilFramesDisplayed();
test->loadHtml("<html><head><style>@keyframes fadeIn { from { opacity: 0; } }</style></head><p style='animation: fadeIn 1s infinite alternate;'>Foo</p></html>", nullptr);
test->waitUntilFramesDisplayed(10);
bool secondCallbackCalled = false;
auto id = webkit_web_view_add_frame_displayed_callback(test->m_webView, [](WebKitWebView*, gpointer userData) {
auto* secondCallbackCalled = static_cast<bool*>(userData);
*secondCallbackCalled = true;
}, &secondCallbackCalled, nullptr);
test->waitUntilFramesDisplayed();
g_assert_true(secondCallbackCalled);
secondCallbackCalled = false;
webkit_web_view_remove_frame_displayed_callback(test->m_webView, id);
test->waitUntilFramesDisplayed();
g_assert_false(secondCallbackCalled);
id = webkit_web_view_add_frame_displayed_callback(test->m_webView, [](WebKitWebView* webView, gpointer userData) {
auto* id = static_cast<unsigned*>(userData);
webkit_web_view_remove_frame_displayed_callback(webView, *id);
}, &id, [](gpointer userData) {
auto* id = static_cast<unsigned*>(userData);
*id = 0;
});
test->waitUntilFramesDisplayed();
g_assert_cmpuint(id, ==, 0);
auto id2 = webkit_web_view_add_frame_displayed_callback(test->m_webView, [](WebKitWebView* webView, gpointer userData) {
auto* id = static_cast<unsigned*>(userData);
if (*id) {
webkit_web_view_remove_frame_displayed_callback(webView, *id);
*id = 0;
}
}, &id, nullptr);
secondCallbackCalled = false;
id = webkit_web_view_add_frame_displayed_callback(test->m_webView, [](WebKitWebView* webView, gpointer userData) {
auto* secondCallbackCalled = static_cast<bool*>(userData);
*secondCallbackCalled = true;
}, &secondCallbackCalled, nullptr);
test->waitUntilFramesDisplayed();
g_assert_cmpuint(id, ==, 0);
g_assert_false(secondCallbackCalled);
webkit_web_view_remove_frame_displayed_callback(test->m_webView, id2);
}
#endif
#if PLATFORM(WPE) && USE(WPEBACKEND_FDO_AUDIO_EXTENSION)
enum class RenderingState {
Unknown,
Started,
Paused,
Stopped
};
class AudioRenderingWebViewTest : public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE_WITH_SETUP_TEARDOWN(AudioRenderingWebViewTest, setup, teardown);
static void setup()
{
}
static void teardown()
{
wpe_audio_register_receiver(nullptr, nullptr);
}
AudioRenderingWebViewTest()
{
wpe_audio_register_receiver(&m_audioReceiver, this);
}
void handleStart(uint32_t id, int32_t channels, const char* layout, int32_t sampleRate)
{
g_assert(m_state == RenderingState::Unknown);
g_assert_false(m_streamId.has_value());
g_assert_cmpuint(id, ==, 0);
m_streamId = id;
m_state = RenderingState::Started;
g_assert_cmpint(channels, ==, 2);
g_assert_cmpstr(layout, ==, "S16LE");
g_assert_cmpint(sampleRate, ==, 44100);
}
void handleStop(uint32_t id)
{
g_assert_cmpuint(*m_streamId, ==, id);
g_assert(m_state != RenderingState::Unknown);
m_state = RenderingState::Stopped;
g_main_loop_quit(m_mainLoop);
m_streamId.reset();
}
void handlePause(uint32_t id)
{
g_assert_cmpuint(*m_streamId, ==, id);
g_assert(m_state != RenderingState::Unknown);
m_state = RenderingState::Paused;
}
void handleResume(uint32_t id)
{
g_assert_cmpuint(*m_streamId, ==, id);
g_assert(m_state == RenderingState::Paused);
m_state = RenderingState::Started;
}
void handlePacket(struct wpe_audio_packet_export* packet_export, uint32_t id, int32_t fd, uint32_t size)
{
g_assert_cmpuint(*m_streamId, ==, id);
g_assert(m_state == RenderingState::Started || m_state == RenderingState::Paused);
g_assert_cmpuint(size, >, 0);
wpe_audio_packet_export_release(packet_export);
}
void waitUntilStarted()
{
g_timeout_add(200, [](gpointer userData) -> gboolean {
auto* test = static_cast<AudioRenderingWebViewTest*>(userData);
if (test->state() == RenderingState::Started) {
test->quitMainLoop();
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}, this);
g_main_loop_run(m_mainLoop);
}
void waitUntilPaused()
{
g_timeout_add(200, [](gpointer userData) -> gboolean {
auto* test = static_cast<AudioRenderingWebViewTest*>(userData);
if (test->state() == RenderingState::Paused) {
test->quitMainLoop();
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}, this);
g_main_loop_run(m_mainLoop);
}
void waitUntilEOS()
{
g_main_loop_run(m_mainLoop);
}
RenderingState state() const { return m_state; }
private:
static const struct wpe_audio_receiver m_audioReceiver;
RenderingState m_state { RenderingState::Unknown };
std::optional<uint32_t> m_streamId;
};
const struct wpe_audio_receiver AudioRenderingWebViewTest::m_audioReceiver = {
[](void* data, uint32_t id, int32_t channels, const char* layout, int32_t sampleRate) { static_cast<AudioRenderingWebViewTest*>(data)->handleStart(id, channels, layout, sampleRate); },
[](void* data, struct wpe_audio_packet_export* packet_export, uint32_t id, int32_t fd, uint32_t size) { static_cast<AudioRenderingWebViewTest*>(data)->handlePacket(packet_export, id, fd, size); },
[](void* data, uint32_t id) { static_cast<AudioRenderingWebViewTest*>(data)->handleStop(id); },
[](void* data, uint32_t id) { static_cast<AudioRenderingWebViewTest*>(data)->handlePause(id); },
[](void* data, uint32_t id) { static_cast<AudioRenderingWebViewTest*>(data)->handleResume(id); }
};
static void testWebViewExternalAudioRendering(AudioRenderingWebViewTest* test, gconstpointer)
{
GUniquePtr<char> resourcePath(g_build_filename(Test::getResourcesDir(Test::WebKit2Resources).data(), "file-with-video.html", nullptr));
GUniquePtr<char> resourceURL(g_filename_to_uri(resourcePath.get(), nullptr, nullptr));
webkit_web_view_load_uri(test->m_webView, resourceURL.get());
test->waitUntilLoadFinished();
test->runJavaScriptAndWaitUntilFinished("playVideo();", nullptr);
test->waitUntilStarted();
g_assert(test->state() == RenderingState::Started);
test->runJavaScriptAndWaitUntilFinished("pauseVideo();", nullptr);
test->waitUntilPaused();
g_assert(test->state() == RenderingState::Paused);
test->runJavaScriptAndWaitUntilFinished("playVideo(); seekNearTheEnd();", nullptr);
test->waitUntilEOS();
g_assert(test->state() == RenderingState::Stopped);
}
#endif
class WebViewTerminateWebProcessTest: public WebViewTest {
public:
MAKE_GLIB_TEST_FIXTURE(WebViewTerminateWebProcessTest);
static void webProcessTerminatedCallback(WebKitWebView* webView, WebKitWebProcessTerminationReason reason, WebViewTerminateWebProcessTest* test)
{
test->m_terminationReason = reason;
}
WebViewTerminateWebProcessTest()
{
g_signal_connect_after(m_webView, "web-process-terminated", G_CALLBACK(WebViewTerminateWebProcessTest::webProcessTerminatedCallback), this);
}
~WebViewTerminateWebProcessTest()
{
g_signal_handlers_disconnect_by_data(m_webView, this);
}
WebKitWebProcessTerminationReason m_terminationReason { WEBKIT_WEB_PROCESS_CRASHED };
};
static void testWebViewTerminateWebProcess(WebViewTerminateWebProcessTest* test, gconstpointer)
{
test->loadHtml("<html></html>", nullptr);
test->waitUntilLoadFinished();
test->m_expectedWebProcessCrash = true;
webkit_web_view_terminate_web_process(test->m_webView);
g_assert_cmpuint(test->m_terminationReason, ==, WEBKIT_WEB_PROCESS_TERMINATED_BY_API);
g_assert_true(webkit_web_view_get_is_web_process_responsive(test->m_webView));
}
static void testWebViewTerminateUnresponsiveWebProcess(WebViewTerminateWebProcessTest* test, gconstpointer)
{
static const char* hangHTML =
"<html>"
" <body>"
" <script>"
" setTimeout(function() {"
" while(true) { }"
" }, 500);"
" </script>"
" </body>"
"</html>";
test->loadHtml(hangHTML, nullptr);
test->waitUntilLoadFinished();
g_assert_true(webkit_web_view_get_is_web_process_responsive(test->m_webView));
// Wait 1 second, so the js while loop kicks in and blocks the web process, and try to load a new page.
// As the web process is busy this won't work, and after 3 seconds the web process will be marked
// as unresponsive.
test->wait(1);
test->loadHtml("<html></html>", nullptr);
test->waitUntilIsWebProcessResponsiveChanged();
g_assert_false(webkit_web_view_get_is_web_process_responsive(test->m_webView));
// Now that the process is unresponsive, terminate it.
test->m_expectedWebProcessCrash = true;
test->m_terminationReason = WEBKIT_WEB_PROCESS_CRASHED;
webkit_web_view_terminate_web_process(test->m_webView);
g_assert_cmpuint(test->m_terminationReason, ==, WEBKIT_WEB_PROCESS_TERMINATED_BY_API);
g_assert_true(webkit_web_view_get_is_web_process_responsive(test->m_webView));
}
static void testWebViewCORSAllowlist(WebViewTest* test, gconstpointer)
{
webkit_web_context_register_uri_scheme(test->m_webContext.get(), "foo",
[](WebKitURISchemeRequest* request, gpointer userData) {
GRefPtr<GInputStream> inputStream = adoptGRef(g_memory_input_stream_new());
const char* data = "<p>foobar!</p>";
g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), data, strlen(data), nullptr);
webkit_uri_scheme_request_finish(request, inputStream.get(), strlen(data), "text/html");
}, nullptr, nullptr);
char html[] = "<html><script>let foo = 0; fetch('foo://bar/baz').then(response => { foo = response.status; }).catch(err => { foo = -1; });</script></html>";
auto waitForFooChanged = [&test]() {
GUniqueOutPtr<GError> error;
WebKitJavascriptResult* result;
JSCValue* jscvalue;
int value;
do {
result = test->runJavaScriptAndWaitUntilFinished("foo;", &error.outPtr());
g_assert_no_error(error.get());
jscvalue = webkit_javascript_result_get_js_value(result);
value = jsc_value_to_int32(jscvalue);
webkit_javascript_result_unref(result);
} while (!value);
return value;
};
// Request is not allowed, foo should be 0.
webkit_web_view_load_html(test->m_webView, html, "http://example.com");
test->waitUntilLoadFinished();
g_assert_cmpint(waitForFooChanged(), ==, -1);
// Allowlisting host alone does not work. Path is also required. foo should remain 0.
GUniquePtr<char*> allowlist(g_new(char*, 2));
allowlist.get()[0] = g_strdup("foo://*");
allowlist.get()[1] = nullptr;
webkit_web_view_set_cors_allowlist(test->m_webView, allowlist.get());
webkit_web_view_load_html(test->m_webView, html, "http://example.com");
test->waitUntilLoadFinished();
g_assert_cmpint(waitForFooChanged(), ==, -1);
// Finally let's properly allow our scheme. foo should now change to 42 when the request succeeds.
allowlist.reset(g_new(char*, 2));
allowlist.get()[0] = g_strdup("foo://*/*");
allowlist.get()[1] = nullptr;
webkit_web_view_set_cors_allowlist(test->m_webView, allowlist.get());
webkit_web_view_load_html(test->m_webView, html, "http://example.com");
test->waitUntilLoadFinished();
g_assert_cmpint(waitForFooChanged(), ==, 200);
}
#if USE(SOUP2)
static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable*, SoupClientContext*, gpointer)
#else
static void serverCallback(SoupServer* server, SoupServerMessage* message, const char* path, GHashTable*, gpointer)
#endif
{
if (soup_server_message_get_method(message) != SOUP_METHOD_GET) {
soup_server_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED, nullptr);
return;
}
if (g_str_equal(path, "/")) {
soup_server_message_set_status(message, SOUP_STATUS_OK, nullptr);
soup_message_body_complete(soup_server_message_get_response_body(message));
} else
soup_server_message_set_status(message, SOUP_STATUS_NOT_FOUND, nullptr);
}
void beforeAll()
{
gServer = new WebKitTestServer();
gServer->run(serverCallback);
WebViewTest::add("WebKitWebView", "web-context", testWebViewWebContext);
WebViewTest::add("WebKitWebView", "web-context-lifetime", testWebViewWebContextLifetime);
WebViewTest::add("WebKitWebView", "close-quickly", testWebViewCloseQuickly);
#if PLATFORM(WPE)
Test::add("WebKitWebView", "backend", testWebViewWebBackend);
#endif
WebViewTest::add("WebKitWebView", "ephemeral", testWebViewEphemeral);
WebViewTest::add("WebKitWebView", "custom-charset", testWebViewCustomCharset);
WebViewTest::add("WebKitWebView", "settings", testWebViewSettings);
WebViewTest::add("WebKitWebView", "zoom-level", testWebViewZoomLevel);
WebViewTest::add("WebKitWebView", "run-javascript", testWebViewRunJavaScript);
#if ENABLE(FULLSCREEN_API)
FullScreenClientTest::add("WebKitWebView", "fullscreen", testWebViewFullScreen);
#endif
WebViewTest::add("WebKitWebView", "can-show-mime-type", testWebViewCanShowMIMEType);
// FIXME: implement mouse clicks in WPE.
#if PLATFORM(GTK)
FormClientTest::add("WebKitWebView", "submit-form", testWebViewSubmitForm);
#endif
SaveWebViewTest::add("WebKitWebView", "save", testWebViewSave);
// FIXME: View is initially visible in WPE and has a fixed hardcoded size.
#if PLATFORM(GTK)
SnapshotWebViewTest::add("WebKitWebView", "snapshot", testWebViewSnapshot);
#endif
WebViewTest::add("WebKitWebView", "page-visibility", testWebViewPageVisibility);
WebViewTest::add("WebKitWebView", "document-focus", testWebViewDocumentFocus);
#if ENABLE(NOTIFICATIONS)
NotificationWebViewTest::add("WebKitWebView", "notification", testWebViewNotification);
NotificationWebViewTest::add("WebKitWebView", "notification-initial-permission-allowed", testWebViewNotificationInitialPermissionAllowed);
NotificationWebViewTest::add("WebKitWebView", "notification-initial-permission-disallowed", testWebViewNotificationInitialPermissionDisallowed);
#endif
IsPlayingAudioWebViewTest::add("WebKitWebView", "is-playing-audio", testWebViewIsPlayingAudio);
WebViewTest::add("WebKitWebView", "background-color", testWebViewBackgroundColor);
#if PLATFORM(GTK)
WebViewTest::add("WebKitWebView", "preferred-size", testWebViewPreferredSize);
#endif
WebViewTitleTest::add("WebKitWebView", "title-change", testWebViewTitleChange);
#if PLATFORM(WPE)
FrameDisplayedTest::add("WebKitWebView", "frame-displayed", testWebViewFrameDisplayed);
#endif
WebViewTest::add("WebKitWebView", "is-audio-muted", testWebViewIsAudioMuted);
WebViewTest::add("WebKitWebView", "autoplay-policy", testWebViewAutoplayPolicy);
#if PLATFORM(WPE) && USE(WPEBACKEND_FDO_AUDIO_EXTENSION)
AudioRenderingWebViewTest::add("WebKitWebView", "external-audio-rendering", testWebViewExternalAudioRendering);
#endif
WebViewTest::add("WebKitWebView", "is-web-process-responsive", testWebViewIsWebProcessResponsive);
WebViewTerminateWebProcessTest::add("WebKitWebView", "terminate-web-process", testWebViewTerminateWebProcess);
WebViewTerminateWebProcessTest::add("WebKitWebView", "terminate-unresponsive-web-process", testWebViewTerminateUnresponsiveWebProcess);
WebViewTest::add("WebKitWebView", "cors-allowlist", testWebViewCORSAllowlist);
}
void afterAll()
{
}