Added fix for mozbz#1468911

2 files changed, 308 insertions, 3 deletions

diff --git a/firefox.spec b/firefox.spec
index 6ff7864..74bc291 100644
--- a/firefox.spec
+++ b/firefox.spec
@@ -1,10 +1,10 @@
 # Set to true if it's going to be submitted as update.
-%global release_build     1
+%global release_build     0
 
 # Disabled arm due to rhbz#1658940
 ExcludeArch: armv7hl
 # Disabled due to https://pagure.io/fedora-infrastructure/issue/7581
-# ExcludeArch: s390x
+ExcludeArch: s390x
 
 %global system_nss        1
 %global system_ffi        1
@@ -95,7 +95,7 @@ ExcludeArch: armv7hl
 Summary:        Mozilla Firefox Web browser
 Name:           firefox
 Version:        66.0
-Release:        4%{?pre_tag}%{?dist}
+Release:        5%{?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
@@ -156,6 +156,7 @@ Patch575:        mozilla-1423598-popup.patch
 Patch576:        mozilla-1532643-popup.patch
 Patch577:        mozilla-1535567.patch
 Patch578:        mozilla-1431399.patch
+Patch579:        mozilla-1468911.patch
 
 # PGO/LTO patches
 Patch600:        pgo.patch
@@ -363,6 +364,7 @@ This package contains results of tests executed during build.
 %patch576 -p1 -b .mozilla-1532643-popup
 %patch577 -p1 -b .mozilla-1535567
 %patch578 -p1 -b .mozilla-1431399
+%patch579 -p1 -b .mozilla-1468911
 
 # PGO patches
 %patch600 -p1 -b .pgo
@@ -910,6 +912,9 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || :
 #---------------------------------------------------------------------
 
 %changelog
+* Mon Mar 18 2019 Martin Stransky <stransky@redhat.com> - 66.0-5
+- Added fix for mozbz#1468911
+
 * Mon Mar 18 2019 Martin Stransky <stransky@redhat.com> - 66.0-4
 - Release build
 
diff --git a/mozilla-1468911.patch b/mozilla-1468911.patch
new file mode 100644
index 0000000..d3177ac
--- /dev/null
+++ b/mozilla-1468911.patch
@@ -0,0 +1,300 @@
+changeset:   465236:be9a6c98a4a7
+tag:         tip
+user:        Martin Stransky <stransky@redhat.com>
+date:        Mon Mar 18 10:42:48 2019 +0100
+summary:     tearing
+
+diff --git a/widget/gtk/WindowSurfaceWayland.cpp b/widget/gtk/WindowSurfaceWayland.cpp
+--- a/widget/gtk/WindowSurfaceWayland.cpp
++++ b/widget/gtk/WindowSurfaceWayland.cpp
+@@ -15,16 +15,32 @@
+ #include "nsTArray.h"
+ #include "base/message_loop.h"  // for MessageLoop
+ #include "base/task.h"          // for NewRunnableMethod, etc
+ 
+ #include <sys/mman.h>
+ #include <fcntl.h>
+ #include <errno.h>
+ 
++#undef LOG
++#ifdef MOZ_LOGGING
++
++#  include "mozilla/Logging.h"
++#  include "nsTArray.h"
++#  include "Units.h"
++
++extern mozilla::LazyLogModule gWidgetWaylandLog;
++#  define LOGWAYLAND(args) MOZ_LOG(gWidgetWaylandLog, mozilla::LogLevel::Debug, args)
++
++#else
++
++#  define LOGWAYLAND(args)
++
++#endif /* MOZ_LOGGING */
++
+ namespace mozilla {
+ namespace widget {
+ 
+ /*
+   Wayland multi-thread rendering scheme
+ 
+   Every rendering thread (main thread, compositor thread) contains its own
+   nsWaylandDisplay object connected to Wayland compositor (Mutter, Weston, etc.)
+@@ -283,23 +299,30 @@ WindowBackBuffer::WindowBackBuffer(nsWay
+   Create(aWidth, aHeight);
+ }
+ 
+ WindowBackBuffer::~WindowBackBuffer() { Release(); }
+ 
+ bool WindowBackBuffer::Resize(int aWidth, int aHeight) {
+   if (aWidth == mWidth && aHeight == mHeight) return true;
+ 
++  LOGWAYLAND(("WindowBackBuffer::Resize [%p] %d %d\n",
++    (void*)this, aWidth, aHeight));
++
+   Release();
+   Create(aWidth, aHeight);
++  Clear();
+ 
+   return (mWaylandBuffer != nullptr);
+ }
+ 
+ void WindowBackBuffer::Attach(wl_surface* aSurface) {
++  LOGWAYLAND(("WindowBackBuffer::Attach [%p] wl_surface %p\n",
++    (void*)this, (void *)aSurface));
++
+   wl_surface_attach(aSurface, mWaylandBuffer, 0, 0);
+   wl_surface_commit(aSurface);
+   wl_display_flush(mWaylandDisplay->GetDisplay());
+   mAttached = true;
+ }
+ 
+ void WindowBackBuffer::Detach() { mAttached = false; }
+ 
+@@ -340,17 +363,18 @@ WindowSurfaceWayland::WindowSurfaceWayla
+       mFrameCallback(nullptr),
+       mLastCommittedSurface(nullptr),
+       mDisplayThreadMessageLoop(MessageLoop::current()),
+       mDelayedCommitHandle(nullptr),
+       mDrawToWaylandBufferDirectly(true),
+       mPendingCommit(false),
+       mWaylandBufferFullScreenDamage(false),
+       mIsMainThread(NS_IsMainThread()),
+-      mNeedScaleFactorUpdate(true) {
++      mNeedScaleFactorUpdate(true),
++      mNeedFullScreenUpdate(true) {
+   for (int i = 0; i < BACK_BUFFER_NUM; i++) mBackupBuffer[i] = nullptr;
+ }
+ 
+ WindowSurfaceWayland::~WindowSurfaceWayland() {
+   if (mPendingCommit) {
+     NS_WARNING("Deleted WindowSurfaceWayland with a pending commit!");
+   }
+ 
+@@ -392,16 +416,17 @@ WindowBackBuffer* WindowSurfaceWayland::
+   }
+ 
+   if (!mWaylandBuffer->IsAttached()) {
+     if (!mWaylandBuffer->IsMatchingSize(aWidth, aHeight)) {
+       mWaylandBuffer->Resize(aWidth, aHeight);
+       // There's a chance that scale factor has been changed
+       // when buffer size changed
+       mNeedScaleFactorUpdate = true;
++      mNeedFullScreenUpdate = true;
+     }
+     return mWaylandBuffer;
+   }
+ 
+   MOZ_ASSERT(!mPendingCommit,
+              "Uncommitted buffer switch, screen artifacts ahead.");
+ 
+   // Front buffer is used by compositor, select a back buffer
+@@ -490,39 +515,36 @@ already_AddRefed<gfx::DrawTarget> Window
+ 
+   B) Lock() is requested for part(s) of screen. We need to provide temporary
+      surface to draw into and copy result (clipped) to target wl_surface.
+  */
+ already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::Lock(
+     const LayoutDeviceIntRegion& aRegion) {
+   MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
+ 
+-  LayoutDeviceIntRect screenRect = mWindow->GetBounds();
+-  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
+-  gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
++  LOGWAYLAND(("WindowSurfaceWayland::Lock [%p]\n", (void*)this));
+ 
+   // Are we asked for entire nsWindow to draw?
+-  mDrawToWaylandBufferDirectly =
+-      (aRegion.GetNumRects() == 1 && bounds.x == 0 && bounds.y == 0 &&
+-       lockSize.width == screenRect.width &&
+-       lockSize.height == screenRect.height);
+-
++  mDrawToWaylandBufferDirectly = IsFullScreenDraw(aRegion);
+   if (mDrawToWaylandBufferDirectly) {
++    LayoutDeviceIntRect screenRect = mWindow->GetBounds();
+     RefPtr<gfx::DrawTarget> dt =
+         LockWaylandBuffer(screenRect.width, screenRect.height,
+                           mWindow->WaylandSurfaceNeedsClear());
+     if (dt) {
+       return dt.forget();
+     }
+ 
+     // We don't have any front buffer available. Try indirect drawing
+     // to mImageSurface which is mirrored to front buffer at commit.
+     mDrawToWaylandBufferDirectly = false;
+   }
+ 
++  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
++  gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
+   return LockImageSurface(lockSize);
+ }
+ 
+ bool WindowSurfaceWayland::CommitImageSurfaceToWaylandBuffer(
+     const LayoutDeviceIntRegion& aRegion) {
+   MOZ_ASSERT(!mDrawToWaylandBufferDirectly);
+ 
+   LayoutDeviceIntRect screenRect = mWindow->GetBounds();
+@@ -611,31 +633,42 @@ void WindowSurfaceWayland::CommitWayland
+     // If our stored wl_surface does not match the actual one it means the frame
+     // callback is no longer active and we should release it.
+     wl_callback_destroy(mFrameCallback);
+     mFrameCallback = nullptr;
+     mLastCommittedSurface = nullptr;
+   }
+ 
+   if (mWaylandBufferFullScreenDamage) {
++    // We know we can safely redraw whole screen.
+     LayoutDeviceIntRect rect = mWindow->GetBounds();
+     wl_surface_damage(waylandSurface, 0, 0, rect.width, rect.height);
+     mWaylandBufferFullScreenDamage = false;
+   } else {
+     gint scaleFactor = mWindow->GdkScaleFactor();
+     for (auto iter = mWaylandBufferDamage.RectIter(); !iter.Done();
+          iter.Next()) {
+       const mozilla::LayoutDeviceIntRect& r = iter.Get();
+       // We need to remove the scale factor because the wl_surface_damage
+       // also multiplies by current  scale factor.
+       wl_surface_damage(waylandSurface, r.x / scaleFactor, r.y / scaleFactor,
+                         r.width / scaleFactor, r.height / scaleFactor);
+     }
++
++    // We have to wait untill whole screen is drawn by Gecko, that happens
++    // when window is created or resized.
++    if (mNeedFullScreenUpdate) {
++      if (!IsFullScreenDraw(mWaylandBufferDamage)) {
++        return;
++      }
++    }
+   }
+ 
++  mNeedFullScreenUpdate = false;
++
+   // Clear all back buffer damage as we're committing
+   // all requested regions.
+   mWaylandBufferDamage.SetEmpty();
+ 
+   mFrameCallback = wl_surface_frame(waylandSurface);
+   wl_callback_add_listener(mFrameCallback, &frame_listener, this);
+ 
+   if (mNeedScaleFactorUpdate || mLastCommittedSurface != waylandSurface) {
+@@ -648,16 +681,18 @@ void WindowSurfaceWayland::CommitWayland
+ 
+   // There's no pending commit, all changes are sent to compositor.
+   mPendingCommit = false;
+ }
+ 
+ void WindowSurfaceWayland::Commit(const LayoutDeviceIntRegion& aInvalidRegion) {
+   MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
+ 
++  LOGWAYLAND(("WindowSurfaceWayland::Commit [%p]\n", (void*)this));
++
+   // We have new content at mImageSurface - copy data to mWaylandBuffer first.
+   if (!mDrawToWaylandBufferDirectly) {
+     CommitImageSurfaceToWaylandBuffer(aInvalidRegion);
+   }
+ 
+   // If we're not at fullscreen damage add drawing area from aInvalidRegion
+   if (!mWaylandBufferFullScreenDamage) {
+     mWaylandBufferDamage.OrWith(aInvalidRegion);
+@@ -690,10 +725,22 @@ void WindowSurfaceWayland::DelayedCommit
+   free(mDelayedCommitHandle);
+   mDelayedCommitHandle = nullptr;
+ 
+   if (mPendingCommit) {
+     CommitWaylandBuffer();
+   }
+ }
+ 
++bool WindowSurfaceWayland::IsFullScreenDraw(
++  const LayoutDeviceIntRegion& aRegion) {
++  LayoutDeviceIntRect screenRect = mWindow->GetBounds();
++  gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect();
++  gfx::IntSize lockSize(bounds.XMost(), bounds.YMost());
++
++  // Are we asked to update entire nsWindow?
++  return (bounds.x == 0 && bounds.y == 0 &&
++       lockSize.width == screenRect.width &&
++       lockSize.height == screenRect.height);
++}
++
+ }  // namespace widget
+ }  // namespace mozilla
+diff --git a/widget/gtk/WindowSurfaceWayland.h b/widget/gtk/WindowSurfaceWayland.h
+--- a/widget/gtk/WindowSurfaceWayland.h
++++ b/widget/gtk/WindowSurfaceWayland.h
+@@ -94,16 +94,17 @@ class WindowSurfaceWayland : public Wind
+ 
+  private:
+   WindowBackBuffer* GetWaylandBufferToDraw(int aWidth, int aHeight);
+ 
+   already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(int aWidth, int aHeight,
+                                                       bool aClearBuffer);
+   already_AddRefed<gfx::DrawTarget> LockImageSurface(
+       const gfx::IntSize& aLockSize);
++  bool IsFullScreenDraw(const LayoutDeviceIntRegion& aRegion);
+   bool CommitImageSurfaceToWaylandBuffer(const LayoutDeviceIntRegion& aRegion);
+   void CommitWaylandBuffer();
+ 
+   // TODO: Do we need to hold a reference to nsWindow object?
+   nsWindow* mWindow;
+   nsWaylandDisplay* mWaylandDisplay;
+   WindowBackBuffer* mWaylandBuffer;
+   LayoutDeviceIntRegion mWaylandBufferDamage;
+@@ -113,14 +114,15 @@ class WindowSurfaceWayland : public Wind
+   wl_surface* mLastCommittedSurface;
+   MessageLoop* mDisplayThreadMessageLoop;
+   WindowSurfaceWayland** mDelayedCommitHandle;
+   bool mDrawToWaylandBufferDirectly;
+   bool mPendingCommit;
+   bool mWaylandBufferFullScreenDamage;
+   bool mIsMainThread;
+   bool mNeedScaleFactorUpdate;
++  bool mNeedFullScreenUpdate;
+ };
+ 
+ }  // namespace widget
+ }  // namespace mozilla
+ 
+ #endif  // _MOZILLA_WIDGET_GTK_WINDOW_SURFACE_WAYLAND_H
+diff --git a/widget/gtk/nsAppShell.cpp b/widget/gtk/nsAppShell.cpp
+--- a/widget/gtk/nsAppShell.cpp
++++ b/widget/gtk/nsAppShell.cpp
+@@ -35,16 +35,17 @@ using mozilla::widget::ScreenHelperGTK;
+ using mozilla::widget::ScreenManager;
+ 
+ #define NOTIFY_TOKEN 0xFA
+ 
+ LazyLogModule gWidgetLog("Widget");
+ LazyLogModule gWidgetFocusLog("WidgetFocus");
+ LazyLogModule gWidgetDragLog("WidgetDrag");
+ LazyLogModule gWidgetDrawLog("WidgetDraw");
++LazyLogModule gWidgetWaylandLog("WidgetWayland");
+ 
+ static GPollFunc sPollFunc;
+ 
+ // Wrapper function to disable hang monitoring while waiting in poll().
+ static gint PollWrapper(GPollFD* ufds, guint nfsd, gint timeout_) {
+   mozilla::BackgroundHangMonitor().NotifyWait();
+   gint result;
+   {
+