From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Tue, 27 Jun 2017 06:07:23 +0000 Subject: webkitgtk-2.16.5 --- Tools/WebKitTestRunner/gtk/EventSenderProxyGtk.cpp | 43 +- Tools/WebKitTestRunner/gtk/PlatformWebViewGtk.cpp | 95 +++-- Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp | 83 ++-- Tools/WebKitTestRunner/gtk/fonts/AHEM____.TTF | Bin 0 -> 12480 bytes .../gtk/fonts/FontWithNoValidEncoding.fon | Bin 0 -> 8368 bytes Tools/WebKitTestRunner/gtk/fonts/fonts.conf | 435 +++++++++++++++++++++ Tools/WebKitTestRunner/gtk/main.cpp | 9 + 7 files changed, 615 insertions(+), 50 deletions(-) create mode 100644 Tools/WebKitTestRunner/gtk/fonts/AHEM____.TTF create mode 100644 Tools/WebKitTestRunner/gtk/fonts/FontWithNoValidEncoding.fon create mode 100644 Tools/WebKitTestRunner/gtk/fonts/fonts.conf (limited to 'Tools/WebKitTestRunner/gtk') diff --git a/Tools/WebKitTestRunner/gtk/EventSenderProxyGtk.cpp b/Tools/WebKitTestRunner/gtk/EventSenderProxyGtk.cpp index d25320125..e93caf5aa 100644 --- a/Tools/WebKitTestRunner/gtk/EventSenderProxyGtk.cpp +++ b/Tools/WebKitTestRunner/gtk/EventSenderProxyGtk.cpp @@ -14,7 +14,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -39,7 +39,7 @@ #include #include #include -#include +#include #include namespace WTR { @@ -122,6 +122,8 @@ static guint webkitModifiersToGDKModifiers(WKEventModifiers wkModifiers) modifiers |= GDK_MOD1_MASK; if (wkModifiers & kWKEventModifiersMetaKey) modifiers |= GDK_META_MASK; + if (wkModifiers & kWKEventModifiersCapsLockKey) + modifiers |= GDK_LOCK_MASK; return modifiers; } @@ -162,8 +164,9 @@ void EventSenderProxy::updateClickCountForButton(int button) m_clickButton = button; } -static void dispatchEvent(GdkEvent* event) +void EventSenderProxy::dispatchEvent(GdkEvent* event) { + ASSERT(m_testController->mainWebView()); gtk_main_do_event(event); gdk_event_free(event); } @@ -217,6 +220,18 @@ int getGDKKeySymForKeyRef(WKStringRef keyRef, unsigned location, guint* modifier return GDK_KEY_VoidSymbol; } + if (WKStringIsEqualToUTF8CString(keyRef, "leftControl")) + return GDK_KEY_Control_L; + if (WKStringIsEqualToUTF8CString(keyRef, "rightControl")) + return GDK_KEY_Control_R; + if (WKStringIsEqualToUTF8CString(keyRef, "leftShift")) + return GDK_KEY_Shift_L; + if (WKStringIsEqualToUTF8CString(keyRef, "rightShift")) + return GDK_KEY_Shift_R; + if (WKStringIsEqualToUTF8CString(keyRef, "leftAlt")) + return GDK_KEY_Alt_L; + if (WKStringIsEqualToUTF8CString(keyRef, "rightAlt")) + return GDK_KEY_Alt_R; if (WKStringIsEqualToUTF8CString(keyRef, "leftArrow")) return GDK_KEY_Left; if (WKStringIsEqualToUTF8CString(keyRef, "rightArrow")) @@ -277,6 +292,8 @@ int getGDKKeySymForKeyRef(WKStringRef keyRef, unsigned location, guint* modifier return GDK_KEY_Tab; if (charCode == '\x8') return GDK_KEY_BackSpace; + if (charCode == 0x001B) + return GDK_KEY_Escape; if (WTF::isASCIIUpper(charCode)) *modifiers |= GDK_SHIFT_MASK; @@ -416,7 +433,10 @@ void EventSenderProxy::mouseScrollBy(int horizontal, int vertical) void EventSenderProxy::continuousMouseScrollBy(int horizontal, int vertical, bool paged) { // Gtk+ does not support paged scroll events. - g_return_if_fail(!paged); + if (paged) { + WTFLogAlways("EventSenderProxy::continuousMouseScrollBy not implemented for paged scroll events"); + return; + } GdkEvent* event = gdk_event_new(GDK_SCROLL); event->scroll.x = m_position.x; @@ -433,6 +453,18 @@ void EventSenderProxy::continuousMouseScrollBy(int horizontal, int vertical, boo sendOrQueueEvent(event); } +void EventSenderProxy::mouseScrollByWithWheelAndMomentumPhases(int x, int y, int /*phase*/, int /*momentum*/) +{ + // Gtk+ does not have the concept of wheel gesture phases or momentum. Just relay to + // the mouse wheel handler. + mouseScrollBy(x, y); +} + +void EventSenderProxy::swipeGestureWithWheelAndMomentumPhases(int, int, int, int) +{ + notImplemented(); +} + void EventSenderProxy::leapForward(int milliseconds) { if (m_eventQueue.isEmpty()) @@ -466,6 +498,7 @@ GUniquePtr EventSenderProxy::createTouchEvent(GdkEventType eventType, return touchEvent; } +#if ENABLE(TOUCH_EVENTS) void EventSenderProxy::addTouchPoint(int x, int y) { // Touch ID is array index plus one, so 0 is skipped. @@ -556,6 +589,6 @@ void EventSenderProxy::setTouchModifier(WKEventModifiers modifier, bool enable) m_updatedTouchEvents.add(GPOINTER_TO_INT(event->touch.sequence)); } } - +#endif // ENABLE(TOUCH_EVENTS) } // namespace WTR diff --git a/Tools/WebKitTestRunner/gtk/PlatformWebViewGtk.cpp b/Tools/WebKitTestRunner/gtk/PlatformWebViewGtk.cpp index fd6f8466b..eb0a08d74 100644 --- a/Tools/WebKitTestRunner/gtk/PlatformWebViewGtk.cpp +++ b/Tools/WebKitTestRunner/gtk/PlatformWebViewGtk.cpp @@ -28,13 +28,17 @@ #include "config.h" #include "PlatformWebView.h" -#include +#include +#include +#include +#include #include +#include namespace WTR { -PlatformWebView::PlatformWebView(WKContextRef context, WKPageGroupRef pageGroup, WKPageRef /* relatedPage */, WKDictionaryRef options) - : m_view(WKViewCreate(context, pageGroup)) +PlatformWebView::PlatformWebView(WKPageConfigurationRef configuration, const TestOptions& options) + : m_view(WKViewCreate(configuration)) , m_window(gtk_window_new(GTK_WINDOW_POPUP)) , m_windowIsKey(true) , m_options(options) @@ -42,7 +46,7 @@ PlatformWebView::PlatformWebView(WKContextRef context, WKPageGroupRef pageGroup, gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(m_view)); GtkAllocation size = { 0, 0, 800, 600 }; - gtk_widget_size_allocate(m_window, &size); + gtk_widget_size_allocate(GTK_WIDGET(m_view), &size); gtk_window_resize(GTK_WINDOW(m_window), 800, 600); gtk_widget_show_all(m_window); @@ -55,14 +59,17 @@ PlatformWebView::~PlatformWebView() gtk_widget_destroy(m_window); } -void PlatformWebView::resizeTo(unsigned width, unsigned height) +void PlatformWebView::setWindowIsKey(bool isKey) { - GtkAllocation size = { 0, 0, static_cast(width), static_cast(height) }; - gtk_widget_size_allocate(m_window, &size); - gtk_window_resize(GTK_WINDOW(m_window), width, height); + m_windowIsKey = isKey; +} - while (gtk_events_pending()) - gtk_main_iteration(); +void PlatformWebView::resizeTo(unsigned width, unsigned height, WebViewSizingMode sizingMode) +{ + WKRect frame = windowFrame(); + frame.size.width = width; + frame.size.height = height; + setWindowFrame(frame, sizingMode); } WKPageRef PlatformWebView::page() @@ -79,14 +86,8 @@ void PlatformWebView::focus() WKRect PlatformWebView::windowFrame() { GtkAllocation geometry; -#ifdef GTK_API_VERSION_2 - gint depth; - gdk_window_get_geometry(gtk_widget_get_window(GTK_WIDGET(m_window)), - &geometry.x, &geometry.y, &geometry.width, &geometry.height, &depth); -#else gdk_window_get_geometry(gtk_widget_get_window(GTK_WIDGET(m_window)), &geometry.x, &geometry.y, &geometry.width, &geometry.height); -#endif WKRect frame; frame.origin.x = geometry.x; @@ -96,10 +97,15 @@ WKRect PlatformWebView::windowFrame() return frame; } -void PlatformWebView::setWindowFrame(WKRect frame) +void PlatformWebView::setWindowFrame(WKRect frame, WebViewSizingMode) { - gtk_window_move(GTK_WINDOW(m_window), frame.origin.x, frame.origin.y); - resizeTo(frame.size.width, frame.size.height); + gdk_window_move_resize(gtk_widget_get_window(GTK_WIDGET(m_window)), + frame.origin.x, frame.origin.y, frame.size.width, frame.size.height); + GtkAllocation size = { 0, 0, static_cast(frame.size.width), static_cast(frame.size.height) }; + gtk_widget_size_allocate(GTK_WIDGET(m_view), &size); + + while (gtk_events_pending()) + gtk_main_iteration(); } void PlatformWebView::addChromeInputField() @@ -110,20 +116,65 @@ void PlatformWebView::removeChromeInputField() { } +void PlatformWebView::addToWindow() +{ +} + +void PlatformWebView::removeFromWindow() +{ +} + void PlatformWebView::makeWebViewFirstResponder() { } +void PlatformWebView::changeWindowScaleIfNeeded(float) +{ +} + WKRetainPtr PlatformWebView::windowSnapshotImage() { - // FIXME: implement to capture pixels in the UI process, - // which may be necessary to capture things like 3D transforms. - return 0; + int width = gtk_widget_get_allocated_width(GTK_WIDGET(m_view)); + int height = gtk_widget_get_allocated_height(GTK_WIDGET(m_view)); + + while (gtk_events_pending()) + gtk_main_iteration(); + + cairo_surface_t* imageSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); + + cairo_t* context = cairo_create(imageSurface); + gtk_widget_draw(GTK_WIDGET(m_view), context); + cairo_destroy(context); + + WKRetainPtr wkImage = adoptWK(WKImageCreateFromCairoSurface(imageSurface, 0 /* options */)); + + cairo_surface_destroy(imageSurface); + return wkImage; } void PlatformWebView::didInitializeClients() { } +bool PlatformWebView::viewSupportsOptions(const TestOptions&) const +{ + return true; +} + +void PlatformWebView::dismissAllPopupMenus() +{ + // gtk_menu_popdown doesn't modify the GList of attached menus, so it should + // be safe to walk this list while calling it. + GList* attachedMenusList = gtk_menu_get_for_attach_widget(GTK_WIDGET(m_view)); + g_list_foreach(attachedMenusList, [] (void* data, void*) { + ASSERT(data); + gtk_menu_popdown(GTK_MENU(data)); + }, nullptr); +} + +void PlatformWebView::setNavigationGesturesEnabled(bool) +{ +} + } // namespace WTR diff --git a/Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp b/Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp index d8fb9f728..62d031a87 100644 --- a/Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp +++ b/Tools/WebKitTestRunner/gtk/TestControllerGtk.cpp @@ -27,52 +27,68 @@ #include "config.h" #include "TestController.h" +#include "PlatformWebView.h" #include #include -#include +#include +#include +#include #include namespace WTR { -static guint gTimeoutSourceId = 0; - -static void cancelTimeout() +static GSource* timeoutSource() { - if (!gTimeoutSourceId) - return; - g_source_remove(gTimeoutSourceId); - gTimeoutSourceId = 0; + static GRefPtr source = nullptr; + if (!source) { + source = adoptGRef(g_timeout_source_new(0)); + g_source_set_ready_time(source.get(), -1); + g_source_set_name(source.get(), "[WTR] Test timeout source"); + g_source_set_callback(source.get(), [](gpointer userData) -> gboolean { + g_source_set_ready_time(static_cast(userData), -1); + fprintf(stderr, "FAIL: TestControllerRunLoop timed out.\n"); + RunLoop::main().stop(); + return G_SOURCE_REMOVE; + }, source.get(), nullptr); + g_source_attach(source.get(), nullptr); + } + return source.get(); } void TestController::notifyDone() { - gtk_main_quit(); - cancelTimeout(); + g_source_set_ready_time(timeoutSource(), -1); + RunLoop::main().stop(); } void TestController::platformInitialize() { } -void TestController::platformDestroy() +WKPreferencesRef TestController::platformPreferences() { + return WKPageGroupGetPreferences(m_pageGroup.get()); } -static gboolean timeoutCallback(gpointer) +void TestController::platformDestroy() { - fprintf(stderr, "FAIL: TestControllerRunLoop timed out.\n"); - gtk_main_quit(); - return FALSE; } void TestController::platformRunUntil(bool&, double timeout) { - cancelTimeout(); - if (timeout != m_noTimeout) { - gTimeoutSourceId = g_timeout_add(timeout * 1000, timeoutCallback, 0); - g_source_set_name_by_id(gTimeoutSourceId, "[WebKit] timeoutCallback"); - } - gtk_main(); + if (timeout > 0) { + // FIXME: This conversion is now repeated in several places, it should be moved to a common place in WTF and used everywhere. + auto timeoutDuration = std::chrono::duration(timeout); + auto safeDuration = std::chrono::microseconds::max(); + if (timeoutDuration < safeDuration) + safeDuration = std::chrono::duration_cast(timeoutDuration); + gint64 currentTime = g_get_monotonic_time(); + gint64 targetTime = currentTime + std::min(G_MAXINT64 - currentTime, safeDuration.count()); + ASSERT(targetTime >= currentTime); + g_source_set_ready_time(timeoutSource(), targetTime); + } else + g_source_set_ready_time(timeoutSource(), -1); + RunLoop::main().run(); } static char* getEnvironmentVariableAsUTF8String(const char* variableName) @@ -102,9 +118,14 @@ void TestController::platformInitializeContext() { } -void TestController::setHidden(bool) +void TestController::setHidden(bool hidden) { - // FIXME: Need to implement this to test visibilityState. + if (!m_mainWebView) + return; + if (hidden) + gtk_widget_unmap(GTK_WIDGET(m_mainWebView->platformView())); + else + gtk_widget_map(GTK_WIDGET(m_mainWebView->platformView())); } void TestController::runModal(PlatformWebView*) @@ -117,4 +138,20 @@ const char* TestController::platformLibraryPathForTesting() return 0; } +void TestController::platformConfigureViewForTest(const TestInvocation&) +{ + WKPageSetApplicationNameForUserAgent(mainWebView()->page(), WKStringCreateWithUTF8CString("WebKitTestRunnerGTK")); +} + +void TestController::platformResetPreferencesToConsistentValues() +{ + if (!m_mainWebView) + return; + m_mainWebView->dismissAllPopupMenus(); +} + +void TestController::updatePlatformSpecificTestOptionsForTest(TestOptions&, const std::string&) const +{ +} + } // namespace WTR diff --git a/Tools/WebKitTestRunner/gtk/fonts/AHEM____.TTF b/Tools/WebKitTestRunner/gtk/fonts/AHEM____.TTF new file mode 100644 index 000000000..ac81cb031 Binary files /dev/null and b/Tools/WebKitTestRunner/gtk/fonts/AHEM____.TTF differ diff --git a/Tools/WebKitTestRunner/gtk/fonts/FontWithNoValidEncoding.fon b/Tools/WebKitTestRunner/gtk/fonts/FontWithNoValidEncoding.fon new file mode 100644 index 000000000..8fff7d9c1 Binary files /dev/null and b/Tools/WebKitTestRunner/gtk/fonts/FontWithNoValidEncoding.fon differ diff --git a/Tools/WebKitTestRunner/gtk/fonts/fonts.conf b/Tools/WebKitTestRunner/gtk/fonts/fonts.conf new file mode 100644 index 000000000..2387e9581 --- /dev/null +++ b/Tools/WebKitTestRunner/gtk/fonts/fonts.conf @@ -0,0 +1,435 @@ + + + + + + + + false + + + + + + + + + FontWithNoValidEncoding + + + + + + + + + serif + + + Liberation Serif + + + + + Times + + + Liberation Serif + + + + + Times New Roman + + + Liberation Serif + + + + + + + cursive + + + Liberation Serif + + + + + fantasy + + + Liberation Serif + + + + + + + sans serif + + + Liberation Sans + + + + + sans + + + Liberation Sans + + + + + + Helvetica + + + Liberation Sans + + + + + Arial + + + Liberation Sans + + + + + Lucida Grande + + + Liberation Sans + + + + + + + monospace + + + Liberation Mono + + + + + mono + + + Liberation Mono + + + + + + Courier + + + Liberation Mono + + + + + Courier New + + + Liberation Mono + + + + + Monaco + + + Liberation Mono + + + + + + + NonAntiAliasedSans + + + Liberation Sans + + + false + + + + + + SlightHintedSerif + + + Liberation Serif + + + true + + + hintslight + + + + + + NonHintedSans + + + Liberation Sans + + + + hintfull + + + false + + + + + + AutohintedSerif + + + Liberation Serif + + + true + + + true + + + hintmedium + + + + + + HintedSerif + + + Liberation Serif + + + true + + + false + + + hintmedium + + + + + + FullAndAutoHintedSerif + + + Liberation Serif + + + true + + + true + + + hintfull + + + + + + SubpixelEnabledSans + + + Liberation Sans + + + rgb + + + + + + SubpixelDisabledSans + + + Liberation Sans + + + none + + + + + + + DejaVu Serif + + + medium + + + medium + + + true + + + bold + + + + + + + DejaVu Serif + + + roman + + + roman + + + + matrix + 10.2 + 01 + + + + + oblique + + + false + + + + + + FamilyStrongAliasedToFreeMono + + FreeMono + + + + + + FamilyWeakAliasedToFreeMono + + FreeMono + + + + + + + + + + DejaVu Sans + + + + + + + 0x0020 + 0x00A0 + 0x00AD + 0x034F + 0x0600 + 0x0601 + 0x0602 + 0x0603 + 0x06DD + 0x070F + 0x115F + 0x1160 + 0x1680 + 0x17B4 + 0x17B5 + 0x180E + 0x2000 + 0x2001 + 0x2002 + 0x2003 + 0x2004 + 0x2005 + 0x2006 + 0x2007 + 0x2008 + 0x2009 + 0x200A + 0x200B + 0x200C + 0x200D + 0x200E + 0x200F + 0x2028 + 0x2029 + 0x202A + 0x202B + 0x202C + 0x202D + 0x202E + 0x202F + 0x205F + 0x2060 + 0x2061 + 0x2062 + 0x2063 + 0x206A + 0x206B + 0x206C + 0x206D + 0x206E + 0x206F + 0x3000 + 0x3164 + 0xFEFF + 0xFFA0 + 0xFFF9 + 0xFFFA + 0xFFFB + + + diff --git a/Tools/WebKitTestRunner/gtk/main.cpp b/Tools/WebKitTestRunner/gtk/main.cpp index d53c6248a..7947ce55c 100644 --- a/Tools/WebKitTestRunner/gtk/main.cpp +++ b/Tools/WebKitTestRunner/gtk/main.cpp @@ -26,12 +26,21 @@ #include "config.h" #include "TestController.h" +#include #include +#include int main(int argc, char** argv) { gtk_init(&argc, &argv); + + GRefPtr languages = adoptGRef(g_ptr_array_new()); + g_ptr_array_add(languages.get(), const_cast(static_cast("en_US"))); + g_ptr_array_add(languages.get(), nullptr); + WKTextCheckerSetSpellCheckingLanguages(reinterpret_cast(languages->pdata)); + // Prefer the not installed web and plugin processes. WTR::TestController controller(argc, const_cast(argv)); + return 0; } -- cgit v1.2.1