diff options
Diffstat (limited to 'mozilla-1656727.patch')
| -rw-r--r-- | mozilla-1656727.patch | 228 |
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. + |