diff --git a/firefox.spec b/firefox.spec index 8d7c6bc..96c9d2f 100644 --- a/firefox.spec +++ b/firefox.spec @@ -94,7 +94,7 @@ ExcludeArch: ppc64le Summary: Mozilla Firefox Web browser Name: firefox Version: 69.0.2 -Release: 1%{?pre_tag}%{?dist} +Release: 2%{?pre_tag}%{?dist} URL: https://www.mozilla.org/firefox/ License: MPLv1.1 or GPLv2+ or LGPLv2+ Source0: https://archive.mozilla.org/pub/firefox/releases/%{version}%{?pre_version}/source/firefox-%{version}%{?pre_version}.source.tar.xz @@ -172,6 +172,7 @@ Patch587: mozilla-1580152.patch Patch588: mozilla-1581748.patch Patch589: mozilla-1577024.patch Patch590: firefox-wayland-cache-missing.patch +Patch591: mozilla-1587008.patch # PGO/LTO patches Patch600: pgo.patch @@ -399,6 +400,7 @@ This package contains results of tests executed during build. %patch588 -p1 -b .mozilla-1581748 %patch589 -p1 -b .mozilla-1577024 %patch590 -p1 -b .cache-missing +%patch591 -p1 -b .mozilla-1587008 # PGO patches %patch600 -p1 -b .pgo @@ -983,6 +985,9 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || : #--------------------------------------------------------------------- %changelog +* Thu Oct 3 2019 Martin Stransky - 69.0.2-2 +- Added fix for mozilla#1587008 - flickering during GL resize. + * Thu Oct 3 2019 Martin Stransky - 69.0.2-1 - Updated to 69.0.2 diff --git a/mozilla-1587008.patch b/mozilla-1587008.patch new file mode 100644 index 0000000..8daf72e --- /dev/null +++ b/mozilla-1587008.patch @@ -0,0 +1,189 @@ +changeset: 498019:9961a0e4d424 +tag: tip +parent: 498006:3fa65bda1e50 +user: Martin Stransky +date: Tue Oct 08 13:32:37 2019 +0200 +files: widget/gtk/mozcontainer.cpp +description: +Bug 1587008 - [Wayland/GL] Fixed visual glitches with gl compositor during window resize, r=jhorak + +Recently we update egl_window size only in moz_container_size_allocate() which is leads +to visible visual glitches as moz_container_size_allocate() is not called during window resize but +after it. + +We need to update egl_window size faster which is done in configure-event callback. + +Differential Revision: https://phabricator.services.mozilla.com/D48526 + + +diff --git a/widget/gtk/mozcontainer.cpp b/widget/gtk/mozcontainer.cpp +--- a/widget/gtk/mozcontainer.cpp ++++ b/widget/gtk/mozcontainer.cpp +@@ -136,16 +136,60 @@ void moz_container_put(MozContainer* con + container->children = g_list_append(container->children, child); + + /* we assume that the caller of this function will have already set + the parent GdkWindow because we can have many anonymous children. */ + gtk_widget_set_parent(child_widget, GTK_WIDGET(container)); + } + + /* static methods */ ++#if defined(MOZ_WAYLAND) ++static gint moz_container_get_scale(MozContainer* container) { ++ static auto sGdkWindowGetScaleFactorPtr = ++ (gint(*)(GdkWindow*))dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor"); ++ ++ if (sGdkWindowGetScaleFactorPtr) { ++ GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container)); ++ return (*sGdkWindowGetScaleFactorPtr)(window); ++ } ++ ++ return 1; ++} ++ ++static void moz_container_resize(MozContainer* container, int width, ++ int height) { ++ // Set correct scaled/unscaled mozcontainer offset ++ // especially when wl_egl is used but we don't recreate it as Gtk+ does. ++ if (container->subsurface) { ++ gint x, y; ++ gdk_window_get_position(gtk_widget_get_window(GTK_WIDGET(container)), &x, ++ &y); ++ wl_subsurface_set_position(container->subsurface, x, y); ++ } ++ ++ // Try to only resize wl_egl_window on scale factor change. ++ // It's a bit risky as Gtk+ recreates it at that event. ++ if (container->eglwindow) { ++ gint scale = moz_container_get_scale(container); ++ if (container->surface) { ++ wl_surface_set_buffer_scale(container->surface, scale); ++ } ++ wl_egl_window_resize(container->eglwindow, width * scale, height * scale, 0, ++ 0); ++ } ++} ++ ++static gboolean moz_container_configure_event_cb(GtkWidget* widget, ++ GdkEventConfigure* event) { ++ LOG(("moz_container_egl_window_configure_event_cb [%p] %d %d %d %d\n", ++ (void*)widget, event->x, event->y, event->width, event->height)); ++ moz_container_resize(MOZ_CONTAINER(widget), event->width, event->height); ++ return FALSE; ++} ++#endif + + void moz_container_class_init(MozContainerClass* klass) { + /*GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); */ + GtkContainerClass* container_class = GTK_CONTAINER_CLASS(klass); + GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass); + + widget_class->map = moz_container_map; +@@ -173,16 +217,21 @@ void moz_container_init(MozContainer* co + container->subsurface = nullptr; + container->eglwindow = nullptr; + container->frame_callback_handler = nullptr; + container->frame_callback_handler_surface_id = -1; + // We can draw to x11 window any time. + container->ready_to_draw = GDK_IS_X11_DISPLAY(gdk_display_get_default()); + container->surface_needs_clear = true; + container->inital_draw_cb = nullptr; ++ ++ // We need faster resize response in mozcontainer to avoid visual glitches ++ // during window resize. ++ g_signal_connect(container, "configure_event", ++ G_CALLBACK(moz_container_configure_event_cb), nullptr); + #endif + + LOG(("%s [%p]\n", __FUNCTION__, (void*)container)); + } + + #if defined(MOZ_WAYLAND) + void moz_container_set_initial_draw_callback( + MozContainer* container, std::function inital_draw_cb) { +@@ -285,53 +334,26 @@ static void moz_container_unmap_wayland( + container->frame_callback_handler_surface_id = -1; + + container->surface_needs_clear = true; + container->ready_to_draw = false; + + LOGWAYLAND(("%s [%p]\n", __FUNCTION__, (void*)container)); + } + +-static gint moz_container_get_scale(MozContainer* container) { +- static auto sGdkWindowGetScaleFactorPtr = +- (gint(*)(GdkWindow*))dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor"); +- +- if (sGdkWindowGetScaleFactorPtr) { +- GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(container)); +- return (*sGdkWindowGetScaleFactorPtr)(window); +- } +- +- return 1; +-} +- + void moz_container_scale_changed(MozContainer* container, + GtkAllocation* aAllocation) { + LOGWAYLAND(("%s [%p] surface %p eglwindow %p\n", __FUNCTION__, + (void*)container, (void*)container->surface, + (void*)container->eglwindow)); + + if (!container->surface) { + return; + } +- +- // Set correct scaled/unscaled mozcontainer offset +- // especially when wl_egl is used but we don't recreate it as Gtk+ does. +- gint x, y; +- gdk_window_get_position(gtk_widget_get_window(GTK_WIDGET(container)), &x, &y); +- wl_subsurface_set_position(container->subsurface, x, y); +- +- // Try to only resize wl_egl_window on scale factor change. +- // It's a bit risky as Gtk+ recreates it at that event. +- if (container->eglwindow) { +- gint scale = moz_container_get_scale(container); +- wl_surface_set_buffer_scale(container->surface, +- moz_container_get_scale(container)); +- wl_egl_window_resize(container->eglwindow, aAllocation->width * scale, +- aAllocation->height * scale, 0, 0); +- } ++ moz_container_resize(container, aAllocation->width, aAllocation->height); + } + #endif + + void moz_container_map(GtkWidget* widget) { + MozContainer* container; + GList* tmp_list; + GtkWidget* tmp_child; + +@@ -451,26 +473,18 @@ void moz_container_size_allocate(GtkWidg + allocation->y, allocation->width, + allocation->height); + } + + #if defined(MOZ_WAYLAND) + // We need to position our subsurface according to GdkWindow + // when offset changes (GdkWindow is maximized for instance). + // see gtk-clutter-embed.c for reference. +- if (container->subsurface) { +- gint x, y; +- gdk_window_get_position(gtk_widget_get_window(widget), &x, &y); +- wl_subsurface_set_position(container->subsurface, x, y); +- } +- if (container->eglwindow) { +- gint scale = moz_container_get_scale(container); +- wl_egl_window_resize(container->eglwindow, allocation->width * scale, +- allocation->height * scale, 0, 0); +- } ++ moz_container_resize(MOZ_CONTAINER(widget), allocation->width, ++ allocation->height); + #endif + } + + void moz_container_remove(GtkContainer* container, GtkWidget* child_widget) { + MozContainerChild* child; + MozContainer* moz_container; + GdkWindow* parent_window; + +