summaryrefslogtreecommitdiff
path: root/mozilla-1656727.patch
diff options
context:
space:
mode:
Diffstat (limited to 'mozilla-1656727.patch')
-rw-r--r--mozilla-1656727.patch228
1 files changed, 228 insertions, 0 deletions
diff --git a/mozilla-1656727.patch b/mozilla-1656727.patch
new file mode 100644
index 0000000..3ec60ae
--- /dev/null
+++ b/mozilla-1656727.patch
@@ -0,0 +1,228 @@
+changeset: 553676:ca48ea0dfb91
+tag: tip
+parent: 553673:a42aa9514794
+user: stransky <stransky@redhat.com>
+date: Mon Oct 05 15:06:55 2020 +0200
+files: widget/gtk/WindowSurfaceWayland.cpp widget/gtk/WindowSurfaceWayland.h
+description:
+Bug 1656727 [Wayland] Track delayed commits globally, r?jhorak
+
+Track delayed commits in a global list and don't store them in actual wayland surfaces.
+When a delayed commit is called, check that the associated wayland surface is still valid.
+
+Differential Revision: https://phabricator.services.mozilla.com/D92432
+
+
+diff --git a/widget/gtk/WindowSurfaceWayland.cpp b/widget/gtk/WindowSurfaceWayland.cpp
+--- a/widget/gtk/WindowSurfaceWayland.cpp
++++ b/widget/gtk/WindowSurfaceWayland.cpp
+@@ -159,7 +159,6 @@ We allocate shared memory (shm) by mmap(
+ between us and wayland compositor. We draw our graphics data to the shm and
+ handle to wayland compositor by WindowBackBuffer/WindowSurfaceWayland
+ (wl_buffer/wl_surface).
+-
+ */
+
+ #define EVENT_LOOP_DELAY (1000 / 240)
+@@ -167,6 +166,44 @@ handle to wayland compositor by WindowBa
+ #define BUFFER_BPP 4
+ gfx::SurfaceFormat WindowBackBuffer::mFormat = gfx::SurfaceFormat::B8G8R8A8;
+
++static mozilla::Mutex* gDelayedCommitLock = nullptr;
++static GList* gDelayedCommits = nullptr;
++
++static void DelayedCommitsEnsureMutext() {
++ if (!gDelayedCommitLock) {
++ gDelayedCommitLock = new mozilla::Mutex("DelayedCommit lock");
++ }
++}
++
++static bool DelayedCommitsCheckAndRemoveSurface(
++ WindowSurfaceWayland* aSurface) {
++ MutexAutoLock lock(*gDelayedCommitLock);
++ GList* foundCommit = g_list_find(gDelayedCommits, aSurface);
++ if (foundCommit) {
++ gDelayedCommits = g_list_delete_link(gDelayedCommits, foundCommit);
++ }
++ return foundCommit != nullptr;
++}
++
++static bool DelayedCommitsCheckAndAddSurface(WindowSurfaceWayland* aSurface) {
++ MutexAutoLock lock(*gDelayedCommitLock);
++ GList* foundCommit = g_list_find(gDelayedCommits, aSurface);
++ if (!foundCommit) {
++ gDelayedCommits = g_list_prepend(gDelayedCommits, aSurface);
++ }
++ return foundCommit == nullptr;
++}
++
++// When a new window is created we may not have a valid wl_surface
++// for drawing (Gtk haven't created it yet). All commits are queued
++// and CommitWaylandBuffer() is called by timer when wl_surface is ready
++// for drawing.
++static void WaylandBufferDelayCommitHandler(WindowSurfaceWayland* aSurface) {
++ if (DelayedCommitsCheckAndRemoveSurface(aSurface)) {
++ aSurface->CommitWaylandBuffer();
++ }
++}
++
+ RefPtr<nsWaylandDisplay> WindowBackBuffer::GetWaylandDisplay() {
+ return mWindowSurfaceWayland->GetWaylandDisplay();
+ }
+@@ -400,7 +437,6 @@ WindowSurfaceWayland::WindowSurfaceWayla
+ mWaylandFullscreenDamage(false),
+ mFrameCallback(nullptr),
+ mLastCommittedSurface(nullptr),
+- mDelayedCommitHandle(nullptr),
+ mLastCommitTime(0),
+ mDrawToWaylandBufferDirectly(true),
+ mCanSwitchWaylandBuffer(true),
+@@ -412,6 +448,7 @@ WindowSurfaceWayland::WindowSurfaceWayla
+ for (int i = 0; i < BACK_BUFFER_NUM; i++) {
+ mShmBackupBuffer[i] = nullptr;
+ }
++ DelayedCommitsEnsureMutext();
+ }
+
+ WindowSurfaceWayland::~WindowSurfaceWayland() {
+@@ -419,12 +456,9 @@ WindowSurfaceWayland::~WindowSurfaceWayl
+ NS_WARNING("Deleted WindowSurfaceWayland with a pending commit!");
+ }
+
+- if (mDelayedCommitHandle) {
+- // Delete reference to this to prevent WaylandBufferDelayCommitHandler()
+- // operate on released this. mDelayedCommitHandle itself will
+- // be released at WaylandBufferDelayCommitHandler().
+- *mDelayedCommitHandle = nullptr;
+- }
++ // Delete reference to this to prevent WaylandBufferDelayCommitHandler()
++ // operate on released this.
++ DelayedCommitsCheckAndRemoveSurface(this);
+
+ if (mFrameCallback) {
+ wl_callback_destroy(mFrameCallback);
+@@ -865,23 +899,11 @@ bool WindowSurfaceWayland::CommitImageCa
+ return true;
+ }
+
+-static void WaylandBufferDelayCommitHandler(WindowSurfaceWayland** aSurface) {
+- if (*aSurface) {
+- (*aSurface)->DelayedCommitHandler();
+- } else {
+- // Referenced WindowSurfaceWayland is already deleted.
+- // Do nothing but just release the mDelayedCommitHandle allocated at
+- // WindowSurfaceWayland::CommitWaylandBuffer().
+- free(aSurface);
+- }
+-}
+-
+ void WindowSurfaceWayland::CommitWaylandBuffer() {
+ LOGWAYLAND(("WindowSurfaceWayland::CommitWaylandBuffer [%p]\n", (void*)this));
+ LOGWAYLAND(
+ (" mDrawToWaylandBufferDirectly = %d\n", mDrawToWaylandBufferDirectly));
+ LOGWAYLAND((" mCanSwitchWaylandBuffer = %d\n", mCanSwitchWaylandBuffer));
+- LOGWAYLAND((" mDelayedCommitHandle = %p\n", mDelayedCommitHandle));
+ LOGWAYLAND((" mFrameCallback = %p\n", mFrameCallback));
+ LOGWAYLAND((" mLastCommittedSurface = %p\n", mLastCommittedSurface));
+ LOGWAYLAND((" mBufferPendingCommit = %d\n", mBufferPendingCommit));
+@@ -917,16 +939,10 @@ void WindowSurfaceWayland::CommitWayland
+ MOZ_ASSERT(!mFrameCallback || waylandSurface != mLastCommittedSurface,
+ "Missing wayland surface at frame callback!");
+
+- // Do nothing if there's already mDelayedCommitHandle pending.
+- if (!mDelayedCommitHandle) {
+- mDelayedCommitHandle = static_cast<WindowSurfaceWayland**>(
+- moz_xmalloc(sizeof(*mDelayedCommitHandle)));
+- *mDelayedCommitHandle = this;
+-
++ if (DelayedCommitsCheckAndAddSurface(this)) {
+ MessageLoop::current()->PostDelayedTask(
+ NewRunnableFunction("WaylandBackBufferCommit",
+- &WaylandBufferDelayCommitHandler,
+- mDelayedCommitHandle),
++ &WaylandBufferDelayCommitHandler, this),
+ EVENT_LOOP_DELAY);
+ }
+ return;
+@@ -1039,24 +1055,5 @@ void WindowSurfaceWayland::FrameCallback
+ CommitWaylandBuffer();
+ }
+
+-void WindowSurfaceWayland::DelayedCommitHandler() {
+- MOZ_ASSERT(mIsMainThread == NS_IsMainThread());
+- MOZ_ASSERT(mDelayedCommitHandle != nullptr, "Missing mDelayedCommitHandle!");
+-
+- LOGWAYLAND(
+- ("WindowSurfaceWayland::DelayedCommitHandler [%p]\n", (void*)this));
+-
+- if (!mDelayedCommitHandle) {
+- LOGWAYLAND((" We're missing mDelayedCommitHandle!\n"));
+- return;
+- }
+-
+- *mDelayedCommitHandle = nullptr;
+- free(mDelayedCommitHandle);
+- mDelayedCommitHandle = nullptr;
+-
+- CommitWaylandBuffer();
+-}
+-
+ } // 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
+@@ -161,7 +161,7 @@ class WindowSurfaceWayland : public Wind
+ // If we fail (wayland compositor is busy,
+ // wl_surface is not created yet) we queue the painting
+ // and we send it to wayland compositor in FrameCallbackHandler()/
+- // DelayedCommitHandler/CommitWaylandBuffer().
++ // CommitWaylandBuffer().
+ already_AddRefed<gfx::DrawTarget> Lock(
+ const LayoutDeviceIntRegion& aRegion) override;
+ void Commit(const LayoutDeviceIntRegion& aInvalidRegion) final;
+@@ -171,12 +171,6 @@ class WindowSurfaceWayland : public Wind
+ // queued commits.
+ void FrameCallbackHandler();
+
+- // When a new window is created we may not have a valid wl_surface
+- // for drawing (Gtk haven't created it yet). All commits are queued
+- // and DelayedCommitHandler() is called by timer when wl_surface is ready
+- // for drawing.
+- void DelayedCommitHandler();
+-
+ // Try to commit all queued drawings to Wayland compositor. This is usually
+ // called from other routines but can be used to explicitly flush
+ // all drawings as we do when wl_buffer is released
+@@ -249,17 +243,14 @@ class WindowSurfaceWayland : public Wind
+ wl_callback* mFrameCallback;
+ wl_surface* mLastCommittedSurface;
+
+- // Registered reference to pending DelayedCommitHandler() call.
+- WindowSurfaceWayland** mDelayedCommitHandle;
+-
+ // Cached drawings. If we can't get WaylandBuffer (wl_buffer) at
+ // WindowSurfaceWayland::Lock() we direct gecko rendering to
+ // mImageSurface.
+ // If we can't get WaylandBuffer at WindowSurfaceWayland::Commit()
+ // time, mImageSurface is moved to mDelayedImageCommits which
+ // holds all cached drawings.
+- // mDelayedImageCommits can be drawn by FrameCallbackHandler(),
+- // DelayedCommitHandler() or when WaylandBuffer is detached.
++ // mDelayedImageCommits can be drawn by FrameCallbackHandler()
++ // or when WaylandBuffer is detached.
+ RefPtr<gfxImageSurface> mImageSurface;
+ AutoTArray<WindowImageSurface, 30> mDelayedImageCommits;
+
+@@ -282,8 +273,8 @@ class WindowSurfaceWayland : public Wind
+ // We can't send WaylandBuffer (wl_buffer) to compositor when gecko
+ // is rendering into it (i.e. between WindowSurfaceWayland::Lock() /
+ // WindowSurfaceWayland::Commit()).
+- // Thus we use mBufferCommitAllowed to disable commit by callbacks
+- // (FrameCallbackHandler(), DelayedCommitHandler())
++ // Thus we use mBufferCommitAllowed to disable commit by
++ // CommitWaylandBuffer().
+ bool mBufferCommitAllowed;
+
+ // We need to clear WaylandBuffer when entire transparent window is repainted.
+
bgstack15