// Test to get inspector server page list from the test server.
// Should contain only one entry pointing to http://127.0.0.1:2999/webinspector/Main.html?page=1
static void testInspectorServerPageList(InspectorServerTest* test, gconstpointer)
{
GUniqueOutPtr<GError> error;
test->showInWindowAndWaitUntilMapped(GTK_WINDOW_TOPLEVEL);
g_assert(test->getPageList());
WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("pages.length;", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error.get());
g_assert_cmpint(WebViewTest::javascriptResultToNumber(javascriptResult), ==, 1);
javascriptResult = test->runJavaScriptAndWaitUntilFinished("pages[0].id;", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error.get());
int pageId = WebViewTest::javascriptResultToNumber(javascriptResult);
GUniquePtr<char> valueString;
javascriptResult = test->runJavaScriptAndWaitUntilFinished("pages[0].url;", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
g_assert_cmpstr(valueString.get(), ==, "http://127.0.0.1:2999/");
javascriptResult = test->runJavaScriptAndWaitUntilFinished("pages[0].inspectorUrl;", &error.outPtr());
g_assert(javascriptResult);
g_assert(!error.get());
valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));
String validInspectorURL = String("/Main.html?page=") + String::number(pageId);
ASSERT_CMP_CSTRING(valueString.get(), ==, validInspectorURL.utf8());
}
void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
{
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return;
GUniquePtr<SoupURI> origin = url.createSoupURI();
GUniquePtr<SoupURI> firstPartyURI = firstParty.createSoupURI();
// Get existing cookies for this origin.
GSList* existingCookies = soup_cookie_jar_get_cookie_list(jar, origin.get(), TRUE);
Vector<String> cookies;
value.split('\n', cookies);
const size_t cookiesCount = cookies.size();
for (size_t i = 0; i < cookiesCount; ++i) {
GUniquePtr<SoupCookie> cookie(soup_cookie_parse(cookies[i].utf8().data(), origin.get()));
if (!cookie)
continue;
// Make sure the cookie is not httpOnly since such cookies should not be set from JavaScript.
if (soup_cookie_get_http_only(cookie.get()))
continue;
// Make sure we do not overwrite httpOnly cookies from JavaScript.
if (httpOnlyCookieExists(existingCookies, soup_cookie_get_name(cookie.get()), soup_cookie_get_path(cookie.get())))
continue;
soup_cookie_jar_add_cookie_with_first_party(jar, firstPartyURI.get(), cookie.release());
}
soup_cookies_free(existingCookies);
}
void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
if (wasEventHandled)
return;
#if HAVE(GTK_GESTURES)
GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget));
if (gestureController.handleEvent(event.nativeEvent()))
return;
#endif
// Emulate pointer events if unhandled.
const GdkEvent* touchEvent = event.nativeEvent();
if (!touchEvent->touch.emulating_pointer)
return;
GUniquePtr<GdkEvent> pointerEvent;
if (touchEvent->type == GDK_TOUCH_UPDATE) {
pointerEvent.reset(gdk_event_new(GDK_MOTION_NOTIFY));
pointerEvent->motion.time = touchEvent->touch.time;
pointerEvent->motion.x = touchEvent->touch.x;
pointerEvent->motion.y = touchEvent->touch.y;
pointerEvent->motion.x_root = touchEvent->touch.x_root;
pointerEvent->motion.y_root = touchEvent->touch.y_root;
pointerEvent->motion.state = touchEvent->touch.state | GDK_BUTTON1_MASK;
} else {
switch (touchEvent->type) {
case GDK_TOUCH_END:
pointerEvent.reset(gdk_event_new(GDK_BUTTON_RELEASE));
pointerEvent->button.state = touchEvent->touch.state | GDK_BUTTON1_MASK;
break;
case GDK_TOUCH_BEGIN:
pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS));
break;
default:
ASSERT_NOT_REACHED();
}
pointerEvent->button.button = 1;
pointerEvent->button.time = touchEvent->touch.time;
pointerEvent->button.x = touchEvent->touch.x;
pointerEvent->button.y = touchEvent->touch.y;
pointerEvent->button.x_root = touchEvent->touch.x_root;
pointerEvent->button.y_root = touchEvent->touch.y_root;
}
gdk_event_set_device(pointerEvent.get(), gdk_event_get_device(touchEvent));
gdk_event_set_source_device(pointerEvent.get(), gdk_event_get_source_device(touchEvent));
pointerEvent->any.window = GDK_WINDOW(g_object_ref(touchEvent->any.window));
pointerEvent->any.send_event = TRUE;
gtk_widget_event(m_viewWidget, pointerEvent.get());
}
static bool getFileStat(const String& path, GStatBuf* statBuffer)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
if (!filename)
return false;
return g_stat(filename.get(), statBuffer) != -1;
}
String directoryName(const String& path)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
if (!filename)
return String();
GUniquePtr<char> dirname(g_path_get_dirname(filename.get()));
return String::fromUTF8(dirname.get());
}
String pathGetFileName(const String& pathName)
{
GUniquePtr<gchar> tmpFilename = unescapedFilename(pathName);
if (!tmpFilename)
return pathName;
GUniquePtr<gchar> baseName(g_path_get_basename(tmpFilename.get()));
return String::fromUTF8(baseName.get());
}
CString fileSystemRepresentation(const String& path)
{
#if OS(WINDOWS)
return path.utf8();
#else
GUniquePtr<gchar> filename = unescapedFilename(path);
return filename.get();
#endif
}
PlatformFileHandle openFile(const String& path, FileOpenMode mode)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
if (!filename)
return invalidPlatformFileHandle;
GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(filename.get()));
GFileIOStream* ioStream = 0;
if (mode == OpenForRead)
ioStream = g_file_open_readwrite(file.get(), 0, 0);
else if (mode == OpenForWrite) {
if (g_file_test(filename.get(), static_cast<GFileTest>(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)))
ioStream = g_file_open_readwrite(file.get(), 0, 0);
else
ioStream = g_file_create_readwrite(file.get(), G_FILE_CREATE_NONE, 0, 0);
}
return ioStream;
}
WebKitTestServer::WebKitTestServer(ServerType type)
{
GUniquePtr<char> sslCertificateFile;
GUniquePtr<char> sslKeyFile;
if (type == ServerHTTPS) {
CString resourcesDir = Test::getResourcesDir();
sslCertificateFile.reset(g_build_filename(resourcesDir.data(), "test-cert.pem", NULL));
sslKeyFile.reset(g_build_filename(resourcesDir.data(), "test-key.pem", NULL));
}
GRefPtr<SoupAddress> address = adoptGRef(soup_address_new("127.0.0.1", SOUP_ADDRESS_ANY_PORT));
soup_address_resolve_sync(address.get(), 0);
m_soupServer = adoptGRef(soup_server_new(SOUP_SERVER_INTERFACE, address.get(),
SOUP_SERVER_SSL_CERT_FILE, sslCertificateFile.get(),
SOUP_SERVER_SSL_KEY_FILE, sslKeyFile.get(), nullptr));
m_baseURI = type == ServerHTTPS ? soup_uri_new("https://127.0.0.1/") : soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(m_baseURI, soup_server_get_port(m_soupServer.get()));
}
static String cookiesForSession(const NetworkStorageSession& session, const URL& url, bool forHTTPHeader)
{
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return String();
GUniquePtr<SoupURI> uri = url.createSoupURI();
GUniquePtr<char> cookies(soup_cookie_jar_get_cookies(jar, uri.get(), forHTTPHeader));
return String::fromUTF8(cookies.get());
}
bool hardLinkOrCopyFile(const String& source, const String& destination)
{
#if OS(WINDOWS)
return !!::CopyFile(source.charactersWithNullTermination().data(), destination.charactersWithNullTermination().data(), TRUE);
#else
GUniquePtr<gchar> sourceFilename = unescapedFilename(source);
if (!sourceFilename)
return false;
GUniquePtr<gchar> destinationFilename = unescapedFilename(destination);
if (!destinationFilename)
return false;
if (!link(sourceFilename.get(), destinationFilename.get()))
return true;
// Hard link failed. Perform a copy instead.
GRefPtr<GFile> sourceFile = adoptGRef(g_file_new_for_path(sourceFilename.get()));
GRefPtr<GFile> destinationFile = adoptGRef(g_file_new_for_path(destinationFilename.get()));
return g_file_copy(sourceFile.get(), destinationFile.get(), G_FILE_COPY_NONE, nullptr, nullptr, nullptr, nullptr);
#endif
}
Vector<String> listDirectory(const String& path, const String& filter)
{
Vector<String> entries;
GUniquePtr<gchar> filename = unescapedFilename(path);
if (!filename)
return entries;
GUniquePtr<GDir> dir(g_dir_open(filename.get(), 0, nullptr));
if (!dir)
return entries;
GUniquePtr<GPatternSpec> pspec(g_pattern_spec_new((filter.utf8()).data()));
while (const char* name = g_dir_read_name(dir.get())) {
if (!g_pattern_match_string(pspec.get(), name))
continue;
GUniquePtr<gchar> entry(g_build_filename(filename.get(), name, nullptr));
entries.append(filenameToString(entry.get()));
}
return entries;
}
bool decode(ArgumentDecoder& decoder, GRefPtr<GtkPrintSettings>& printSettings)
{
GUniquePtr<GKeyFile> keyFile;
if (!decodeGKeyFile(decoder, keyFile))
return false;
printSettings = adoptGRef(gtk_print_settings_new());
if (!keyFile)
return true;
if (!gtk_print_settings_load_key_file(printSettings.get(), keyFile.get(), "Print Settings", 0))
printSettings = 0;
return printSettings;
}
bool decode(ArgumentDecoder& decoder, GRefPtr<GtkPageSetup>& pageSetup)
{
GUniquePtr<GKeyFile> keyFile;
if (!decodeGKeyFile(decoder, keyFile))
return false;
pageSetup = adoptGRef(gtk_page_setup_new());
if (!keyFile)
return true;
if (!gtk_page_setup_load_key_file(pageSetup.get(), keyFile.get(), "Page Setup", 0))
pageSetup = 0;
return pageSetup;
}
// Converts a string to something suitable to be displayed to the user.
String filenameForDisplay(const String& string)
{
#if OS(WINDOWS)
return string;
#else
GUniquePtr<gchar> filename = unescapedFilename(string);
if (!filename)
return string;
GUniquePtr<gchar> display(g_filename_to_utf8(filename.get(), -1, nullptr, nullptr, nullptr));
if (!display)
return string;
return String::fromUTF8(display.get());
#endif
}
static bool decodeGKeyFile(ArgumentDecoder& decoder, GUniquePtr<GKeyFile>& keyFile)
{
DataReference dataReference;
if (!decoder.decode(dataReference))
return false;
if (!dataReference.size())
return true;
keyFile.reset(g_key_file_new());
if (!g_key_file_load_from_data(keyFile.get(), reinterpret_cast<const gchar*>(dataReference.data()), dataReference.size(), G_KEY_FILE_NONE, 0)) {
keyFile.reset();
return false;
}
return true;
}
void WebPageProxy::requestInstallMissingMediaPlugins(const String& details)
{
CString detail = details.utf8();
const char* detailArray[2] = { detail.data(), nullptr };
ref();
GUniquePtr<GstInstallPluginsContext> context = m_pageClient.createGstInstallPluginsContext();
GstInstallPluginsReturn result = gst_install_plugins_async(detailArray, context.get(), [](GstInstallPluginsReturn result, gpointer userData) {
RefPtr<WebPageProxy> page = adoptRef(static_cast<WebPageProxy*>(userData));
if (page->isValid())
page->send(Messages::WebPage::DidEndRequestInstallMissingMediaPlugins(static_cast<uint32_t>(result)));
}, this);
if (result != GST_INSTALL_PLUGINS_STARTED_OK) {
// If the installer didn't start, the callback will not be called, so remove the ref manually.
deref();
send(Messages::WebPage::DidEndRequestInstallMissingMediaPlugins(static_cast<uint32_t>(result)));
WTFLogAlways("Missing GStreamer Plugin: %s\n", detail.data());
}
}
void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& name)
{
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return;
GUniquePtr<SoupURI> uri = url.createSoupURI();
GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
if (!cookies)
return;
CString cookieName = name.utf8();
bool wasDeleted = false;
for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
if (!wasDeleted && cookieName == cookie->name) {
soup_cookie_jar_delete_cookie(jar, cookie);
wasDeleted = true;
}
soup_cookie_free(cookie);
}
}
bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
{
rawCookies.clear();
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return false;
GUniquePtr<SoupURI> uri = url.createSoupURI();
GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
if (!cookies)
return false;
for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
rawCookies.append(Cookie(String::fromUTF8(cookie->name), String::fromUTF8(cookie->value), String::fromUTF8(cookie->domain),
String::fromUTF8(cookie->path), cookie->expires ? static_cast<double>(soup_date_to_time_t(cookie->expires)) * 1000 : 0,
cookie->http_only, cookie->secure, !cookie->expires));
soup_cookie_free(cookie);
}
return true;
}
static gboolean axObjectEventListener(GSignalInvocationHint *signalHint, guint numParamValues, const GValue *paramValues, gpointer data)
{
// At least we should receive the instance emitting the signal.
if (numParamValues < 1)
return true;
AtkObject* accessible = ATK_OBJECT(g_value_get_object(¶mValues[0]));
if (!accessible || !ATK_IS_OBJECT(accessible))
return true;
GSignalQuery signalQuery;
GUniquePtr<gchar> signalName;
GUniquePtr<gchar> signalValue;
String notificationName;
g_signal_query(signalHint->signal_id, &signalQuery);
if (!g_strcmp0(signalQuery.signal_name, "state-change")) {
signalName.reset(g_strdup_printf("state-change:%s", g_value_get_string(¶mValues[1])));
signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[2])));
if (!g_strcmp0(g_value_get_string(¶mValues[1]), "checked"))
notificationName = "CheckedStateChanged";
else if (!g_strcmp0(g_value_get_string(¶mValues[1]), "invalid-entry"))
notificationName = "AXInvalidStatusChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "focus-event")) {
signalName.reset(g_strdup("focus-event"));
signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[1])));
if (g_value_get_boolean(¶mValues[1]))
notificationName = "AXFocusedUIElementChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "children-changed")) {
const gchar* childrenChangedDetail = g_quark_to_string(signalHint->detail);
signalName.reset(g_strdup_printf("children-changed:%s", childrenChangedDetail));
signalValue.reset(g_strdup_printf("%d", g_value_get_uint(¶mValues[1])));
notificationName = !g_strcmp0(childrenChangedDetail, "add") ? "AXChildrenAdded" : "AXChildrenRemoved";
} else if (!g_strcmp0(signalQuery.signal_name, "property-change")) {
signalName.reset(g_strdup_printf("property-change:%s", g_quark_to_string(signalHint->detail)));
if (!g_strcmp0(g_quark_to_string(signalHint->detail), "accessible-value"))
notificationName = "AXValueChanged";
} else if (!g_strcmp0(signalQuery.signal_name, "load-complete"))
notificationName = "AXLoadComplete";
else
signalName.reset(g_strdup(signalQuery.signal_name));
if (loggingAccessibilityEvents)
printAccessibilityEvent(accessible, signalName.get(), signalValue.get());
#if PLATFORM(GTK)
JSGlobalContextRef jsContext = webkit_web_frame_get_global_context(mainFrame);
#elif PLATFORM(EFL)
JSGlobalContextRef jsContext = DumpRenderTreeSupportEfl::globalContextRefForFrame(browser->mainFrame());
#else
JSContextRef jsContext = 0;
#endif
if (!jsContext)
return true;
if (notificationName.length()) {
JSRetainPtr<JSStringRef> jsNotificationEventName(Adopt, JSStringCreateWithUTF8CString(notificationName.utf8().data()));
JSValueRef notificationNameArgument = JSValueMakeString(jsContext, jsNotificationEventName.get());
NotificationHandlersMap::iterator elementNotificationHandler = notificationHandlers.find(accessible);
if (elementNotificationHandler != notificationHandlers.end()) {
// Listener for one element just gets one argument, the notification name.
JSObjectCallAsFunction(jsContext, elementNotificationHandler->value->notificationFunctionCallback(), 0, 1, ¬ificationNameArgument, 0);
}
if (globalNotificationHandler) {
// A global listener gets the element and the notification name as arguments.
JSValueRef arguments[2];
arguments[0] = AccessibilityUIElement::makeJSAccessibilityUIElement(jsContext, AccessibilityUIElement(accessible));
arguments[1] = notificationNameArgument;
JSObjectCallAsFunction(jsContext, globalNotificationHandler->notificationFunctionCallback(), 0, 2, arguments, 0);
}
}
return true;
}
bool deleteFile(const String& path)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
return filename ? g_remove(filename.get()) != -1 : false;
}
bool fileExists(const String& path)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
return filename ? g_file_test(filename.get(), G_FILE_TEST_EXISTS) : false;
}
bool deleteEmptyDirectory(const String& path)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
return filename ? g_rmdir(filename.get()) != -1 : false;
}
bool makeAllDirectories(const String& path)
{
GUniquePtr<gchar> filename = unescapedFilename(path);
return filename ? g_mkdir_with_parents(filename.get(), S_IRWXU) != -1 : false;
}
