diff options
| -rw-r--r-- | firefox.spec | 7 | ||||
| -rw-r--r-- | mozilla-1581748.patch | 574 |
2 files changed, 580 insertions, 1 deletions
diff --git a/firefox.spec b/firefox.spec index 88f5fc6..3e96df4 100644 --- a/firefox.spec +++ b/firefox.spec @@ -94,7 +94,7 @@ ExcludeArch: ppc64le Summary: Mozilla Firefox Web browser Name: firefox Version: 69.0 -Release: 6%{?pre_tag}%{?dist} +Release: 7%{?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 @@ -168,6 +168,7 @@ Patch584: mozilla-1579794-2.patch Patch585: mozilla-1579849.patch Patch586: mozilla-1579823.patch Patch587: mozilla-1580152.patch +Patch588: mozilla-1581748.patch # PGO/LTO patches Patch600: pgo.patch @@ -388,6 +389,7 @@ This package contains results of tests executed during build. %patch422 -p1 -b .1580174-webrtc-popup %patch586 -p1 -b .mozilla-1579823 %patch587 -p1 -b .mozilla-1580152 +%patch588 -p1 -b .mozilla-1581748 # PGO patches %patch600 -p1 -b .pgo @@ -964,6 +966,9 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || : #--------------------------------------------------------------------- %changelog +* Tue Sep 17 2019 Martin Stransky <stransky@redhat.com> - 69.0-7 +- Added fixes for mozbz#1581748 + * Mon Sep 16 2019 Martin Stransky <stransky@redhat.com> - 69.0-6 - Added fixes for mozbz#1579823, mozbz#1580152 diff --git a/mozilla-1581748.patch b/mozilla-1581748.patch new file mode 100644 index 0000000..4fbffa8 --- /dev/null +++ b/mozilla-1581748.patch @@ -0,0 +1,574 @@ +diff -up firefox-69.0/widget/gtk/WindowSurfaceWayland.cpp.mozilla-1581748 firefox-69.0/widget/gtk/WindowSurfaceWayland.cpp +--- firefox-69.0/widget/gtk/WindowSurfaceWayland.cpp.mozilla-1581748 2019-09-17 13:19:47.190908284 +0200 ++++ firefox-69.0/widget/gtk/WindowSurfaceWayland.cpp 2019-09-17 13:19:47.196908262 +0200 +@@ -32,7 +32,7 @@ extern mozilla::LazyLogModule gWidgetWay + # define LOGWAYLAND(args) + #endif /* MOZ_LOGGING */ + +-// Maximal compositin timeout it miliseconds ++// Maximal compositing timeout it miliseconds + #define COMPOSITING_TIMEOUT 200 + + namespace mozilla { +@@ -513,13 +513,15 @@ WindowSurfaceWayland::WindowSurfaceWayla + mDelayedCommitHandle(nullptr), + mLastCommitTime(0), + mDrawToWaylandBufferDirectly(true), ++ mCanSwitchWaylandBuffer(true), + mBufferPendingCommit(false), + mBufferCommitAllowed(false), +- mWholeWindowBufferDamage(false), + mBufferNeedsClear(false), + mIsMainThread(NS_IsMainThread()), + mNeedScaleFactorUpdate(true) { + for (int i = 0; i < BACK_BUFFER_NUM; i++) mBackupBuffer[i] = nullptr; ++ mRenderingCacheMode = 0; ++ + } + + WindowSurfaceWayland::~WindowSurfaceWayland() { +@@ -591,8 +593,6 @@ WindowBackBuffer* WindowSurfaceWayland:: + + // There's no buffer created yet, create a new one. + if (!mWaylandBuffer) { +- MOZ_ASSERT(aCanSwitchBuffer && mWholeWindowBufferDamage, +- "Created new buffer for partial drawing!"); + LOGWAYLAND((" Created new buffer [%d x %d]\n", mBufferScreenRect.width, + mBufferScreenRect.height)); + +@@ -682,9 +682,8 @@ WindowBackBuffer* WindowSurfaceWayland:: + return mWaylandBuffer; + } + +-already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockWaylandBuffer( +- bool aCanSwitchBuffer) { +- WindowBackBuffer* buffer = GetWaylandBufferToDraw(aCanSwitchBuffer); ++already_AddRefed<gfx::DrawTarget> WindowSurfaceWayland::LockWaylandBuffer() { ++ WindowBackBuffer* buffer = GetWaylandBufferToDraw(mCanSwitchWaylandBuffer); + + LOGWAYLAND(("WindowSurfaceWayland::LockWaylandBuffer [%p] Got buffer %p\n", + (void*)this, (void*)buffer)); +@@ -698,7 +697,9 @@ already_AddRefed<gfx::DrawTarget> Window + return nullptr; + } + +- if (mBufferNeedsClear && mWholeWindowBufferDamage) { ++ mCanSwitchWaylandBuffer = false; ++ ++ if (mBufferNeedsClear) { + buffer->Clear(); + mBufferNeedsClear = false; + } +@@ -728,40 +729,30 @@ already_AddRefed<gfx::DrawTarget> Window + WindowBackBuffer::GetSurfaceFormat()); + } + +-static bool IsWindowFullScreenUpdate(LayoutDeviceIntRect& screenRect, +- const LayoutDeviceIntRegion& aRegion) { +- if (aRegion.GetNumRects() > 1) return false; +- +- IntRect rect = aRegion.RectIter().Get().ToUnknownRect(); +- return (rect.x == 0 && rect.y == 0 && screenRect.width == rect.width && +- screenRect.height == rect.height); ++static bool IsWindowFullScreenUpdate( ++ LayoutDeviceIntRect& aScreenRect, ++ const LayoutDeviceIntRegion& aUpdatedRegion) { ++ if (aUpdatedRegion.GetNumRects() > 1) return false; ++ ++ IntRect rect = aUpdatedRegion.RectIter().Get().ToUnknownRect(); ++ return (rect.x == 0 && rect.y == 0 && aScreenRect.width == rect.width && ++ aScreenRect.height == rect.height); + } + +-static bool IsPopupFullScreenUpdate(LayoutDeviceIntRect& screenRect, +- const LayoutDeviceIntRegion& aRegion) { ++static bool IsPopupFullScreenUpdate( ++ LayoutDeviceIntRect& aScreenRect, ++ const LayoutDeviceIntRegion& aUpdatedRegion) { + // We know that popups can be drawn from two parts; a panel and an arrow. + // Assume we redraw whole popups when we have two rects and bounding + // box is equal to window borders. +- if (aRegion.GetNumRects() > 2) return false; ++ if (aUpdatedRegion.GetNumRects() > 2) return false; + +- IntRect lockSize = aRegion.GetBounds().ToUnknownRect(); ++ gfx::IntRect lockSize = aUpdatedRegion.GetBounds().ToUnknownRect(); + return (lockSize.x == 0 && lockSize.y == 0 && +- screenRect.width == lockSize.width && +- screenRect.height == lockSize.height); ++ aScreenRect.width == lockSize.width && ++ aScreenRect.height == lockSize.height); + } + +-/* +- There are some situations which can happen here: +- +- A) Lock() is called to whole surface. In that case we don't need +- to clip/buffer the drawing and we can return wl_buffer directly +- for drawing. +- - mWaylandBuffer is available - that's an ideal situation. +- - mWaylandBuffer is locked by compositor - go B) +- +- 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()); +@@ -777,22 +768,31 @@ already_AddRefed<gfx::DrawTarget> Window + LayoutDeviceIntRect lockedScreenRect = mWindow->GetBounds(); + gfx::IntRect lockSize = aRegion.GetBounds().ToUnknownRect(); + +- // Are we asked for entire nsWindow to draw? + bool isTransparentPopup = + mWindow->IsWaylandPopup() && + (eTransparencyTransparent == mWindow->GetTransparencyMode()); + +- // We have request to lock whole buffer/window. +- mWholeWindowBufferDamage = +- isTransparentPopup ? IsPopupFullScreenUpdate(lockedScreenRect, aRegion) +- : IsWindowFullScreenUpdate(lockedScreenRect, aRegion); +- +- // Clear buffer when we (re)draw new transparent popup window, +- // otherwise leave it as-is, mBufferNeedsClear can be set from previous +- // (already pending) commits which are cached now. +- if (mWholeWindowBufferDamage) { ++ bool windowRedraw = isTransparentPopup ++ ? IsPopupFullScreenUpdate(lockedScreenRect, aRegion) ++ : IsWindowFullScreenUpdate(lockedScreenRect, aRegion); ++ if (windowRedraw) { ++ // Clear buffer when we (re)draw new transparent popup window, ++ // otherwise leave it as-is, mBufferNeedsClear can be set from previous ++ // (already pending) commits which are cached now. + mBufferNeedsClear = + mWindow->WaylandSurfaceNeedsClear() || isTransparentPopup; ++ ++ // Store info that we can switch WaylandBuffer when we flush ++ // mImageSurface / mDelayedImageCommits. Don't clear it - it's cleared ++ // at LockWaylandBuffer() when we actualy switch the buffer. ++ mCanSwitchWaylandBuffer = windowRedraw; ++ ++ // We do full buffer repaint so clear our cached drawings. ++ mDelayedImageCommits.Clear(); ++ mWaylandBufferDamage.SetEmpty(); ++ ++ // Also do scale factor update for whole window updates just to be sure. ++ mNeedScaleFactorUpdate = true; + } + + LOGWAYLAND( +@@ -808,7 +808,7 @@ already_AddRefed<gfx::DrawTarget> Window + LOGWAYLAND((" IsWindowFullScreenUpdate = %d\n", + IsWindowFullScreenUpdate(lockedScreenRect, aRegion))); + LOGWAYLAND((" mBufferNeedsClear = %d\n", mBufferNeedsClear)); +- LOGWAYLAND((" mWholeWindowBufferDamage = %d\n", mWholeWindowBufferDamage)); ++ LOGWAYLAND((" windowRedraw = %d\n", windowRedraw)); + + #if MOZ_LOGGING + if (!(mBufferScreenRect == lockedScreenRect)) { +@@ -822,8 +822,9 @@ already_AddRefed<gfx::DrawTarget> Window + // We can't commit them any more as they're for former window size, so + // scratch them. + mDelayedImageCommits.Clear(); ++ mWaylandBufferDamage.SetEmpty(); + +- if (!mWholeWindowBufferDamage) { ++ if (!windowRedraw) { + NS_WARNING("Partial screen update when window is resized!"); + // This should not happen. Screen size changed but we got only + // partal screen update instead of whole screen. Discard this painting +@@ -833,52 +834,56 @@ already_AddRefed<gfx::DrawTarget> Window + mBufferScreenRect = lockedScreenRect; + } + +- if (mWholeWindowBufferDamage) { +- // We can lock/commit entire buffer direcly. +- mDrawToWaylandBufferDirectly = true; +- +- // If there's any pending image commit scratch them as we're going +- // to redraw the whole sceen anyway. +- mDelayedImageCommits.Clear(); ++ mDrawToWaylandBufferDirectly = ++ (windowRedraw || mRenderingCacheMode != CACHE_ALL); + +- RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer( +- /* aCanSwitchBuffer */ mWholeWindowBufferDamage); ++ if (mDrawToWaylandBufferDirectly) { ++ LOGWAYLAND((" Direct drawing\n")); ++ RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(); + if (dt) { ++ if (!windowRedraw) { ++ DrawDelayedImageCommits(dt, mWaylandBufferDamage); ++ } + return dt.forget(); + } + } + +- // We do indirect drawing due to: +- // +- // 1) We don't have any front buffer available. Try indirect drawing +- // to mImageSurface which is mirrored to front buffer at commit. +- // 2) Only part of the screen is locked. We can't lock entire screen for +- // such drawing as it produces visible artifacts. ++ // Any caching is disabled and we don't have any back buffer available. ++ if (mRenderingCacheMode == CACHE_NONE) { ++ return nullptr; ++ } ++ ++ // We do indirect drawing because there isn't any front buffer available. ++ // Do indirect drawing to mImageSurface which is commited to wayland ++ // wl_buffer by DrawDelayedImageCommits() later. + mDrawToWaylandBufferDirectly = false; + + LOGWAYLAND((" Indirect drawing.\n")); + return LockImageSurface(gfx::IntSize(lockSize.XMost(), lockSize.YMost())); + } + ++bool WindowImageSurface::OverlapsSurface( ++ class WindowImageSurface& aBottomSurface) { ++ return mUpdateRegion.Contains(aBottomSurface.mUpdateRegion); ++} ++ + void WindowImageSurface::Draw(gfx::SourceSurface* aSurface, + gfx::DrawTarget* aDest, + const LayoutDeviceIntRegion& aRegion) { +- uint32_t numRects = aRegion.GetNumRects(); +- if (numRects != 1) { +- AutoTArray<IntRect, 32> rects; +- rects.SetCapacity(numRects); +- for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { +- rects.AppendElement(iter.Get().ToUnknownRect()); +- } +- aDest->PushDeviceSpaceClipRects(rects.Elements(), rects.Length()); +- } +- ++#ifdef MOZ_LOGGING + gfx::IntRect bounds = aRegion.GetBounds().ToUnknownRect(); +- gfx::Rect rect(bounds); +- aDest->DrawSurface(aSurface, rect, rect); ++ LOGWAYLAND(("WindowImageSurface::Draw\n")); ++ LOGWAYLAND((" rects num %d\n", aRegion.GetNumRects())); ++ LOGWAYLAND((" bounds [ %d, %d] -> [%d x %d]\n", bounds.x, bounds.y, ++ bounds.width, bounds.height)); ++#endif + +- if (numRects != 1) { +- aDest->PopClip(); ++ for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) { ++ mozilla::LayoutDeviceIntRect r = iter.Get(); ++ gfx::Rect rect(r.ToUnknownRect()); ++ LOGWAYLAND((" draw rect [%f,%f] -> [%f x %f]\n", rect.x, rect.y, ++ rect.width, rect.height)); ++ aDest->DrawSurface(aSurface, rect, rect); + } + } + +@@ -896,6 +901,18 @@ WindowImageSurface::WindowImageSurface( + mImageSurface->Format()); + } + ++void WindowSurfaceWayland::DrawDelayedImageCommits( ++ gfx::DrawTarget* aDrawTarget, LayoutDeviceIntRegion& aWaylandBufferDamage) { ++ LOGWAYLAND( ++ ("WindowSurfaceWayland::DrawDelayedImageCommits [%p]\n", (void*)this)); ++ MOZ_ASSERT(mDelayedImageCommits.Length() > 0, "Nothing to draw?"); ++ ++ for (unsigned int i = 0; i < mDelayedImageCommits.Length(); i++) { ++ mDelayedImageCommits[i].Draw(aDrawTarget, aWaylandBufferDamage); ++ } ++ mDelayedImageCommits.Clear(); ++} ++ + void WindowSurfaceWayland::CacheImageSurface( + const LayoutDeviceIntRegion& aRegion) { + #ifdef MOZ_LOGGING +@@ -906,8 +923,26 @@ void WindowSurfaceWayland::CacheImageSur + bounds.width, bounds.height)); + #endif + +- mDelayedImageCommits.AppendElement( +- WindowImageSurface(mImageSurface, aRegion)); ++ WindowImageSurface surf = WindowImageSurface(mImageSurface, aRegion); ++ ++ if (mDelayedImageCommits.Length()) { ++ int lastSurf = mDelayedImageCommits.Length() - 1; ++ if (surf.OverlapsSurface(mDelayedImageCommits[lastSurf])) { ++#ifdef MOZ_LOGGING ++ { ++ gfx::IntRect size = mDelayedImageCommits[lastSurf] ++ .GetUpdateRegion() ++ ->GetBounds() ++ .ToUnknownRect(); ++ LOGWAYLAND((" removing [ %d, %d] -> [%d x %d]\n", size.x, size.y, ++ size.width, size.height)); ++ } ++#endif ++ mDelayedImageCommits.RemoveElementAt(lastSurf); ++ } ++ } ++ ++ mDelayedImageCommits.AppendElement(surf); + // mImageSurface is owned by mDelayedImageCommits + mImageSurface = nullptr; + +@@ -915,17 +950,6 @@ void WindowSurfaceWayland::CacheImageSur + (" There's %d cached images\n", int(mDelayedImageCommits.Length()))); + } + +-void WindowSurfaceWayland::DrawDelayedImageCommits( +- gfx::DrawTarget* aDrawTarget, LayoutDeviceIntRegion& aWaylandBufferDamage) { +- LOGWAYLAND( +- ("WindowSurfaceWayland::DrawDelayedImageCommits [%p]\n", (void*)this)); +- +- for (unsigned int i = 0; i < mDelayedImageCommits.Length(); i++) { +- mDelayedImageCommits[i].Draw(aDrawTarget, aWaylandBufferDamage); +- } +- mDelayedImageCommits.Clear(); +-} +- + bool WindowSurfaceWayland::CommitImageCacheToWaylandBuffer() { + if (!mDelayedImageCommits.Length()) { + return false; +@@ -933,8 +957,7 @@ bool WindowSurfaceWayland::CommitImageCa + + MOZ_ASSERT(!mDrawToWaylandBufferDirectly); + +- RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer( +- /* aCanSwitchBuffer */ mWholeWindowBufferDamage); ++ RefPtr<gfx::DrawTarget> dt = LockWaylandBuffer(); + if (!dt) { + return false; + } +@@ -942,7 +965,6 @@ bool WindowSurfaceWayland::CommitImageCa + LOGWAYLAND((" Flushing %ld cached WindowImageSurfaces to Wayland buffer\n", + long(mDelayedImageCommits.Length()))); + +- // Draw any delayed image commits first + DrawDelayedImageCommits(dt, mWaylandBufferDamage); + UnlockWaylandBuffer(); + +@@ -967,7 +989,7 @@ void WindowSurfaceWayland::CommitWayland + LOGWAYLAND(("WindowSurfaceWayland::CommitWaylandBuffer [%p]\n", (void*)this)); + LOGWAYLAND( + (" mDrawToWaylandBufferDirectly = %d\n", mDrawToWaylandBufferDirectly)); +- LOGWAYLAND((" mWholeWindowBufferDamage = %d\n", mWholeWindowBufferDamage)); ++ LOGWAYLAND((" mCanSwitchWaylandBuffer = %d\n", mCanSwitchWaylandBuffer)); + LOGWAYLAND((" mDelayedCommitHandle = %p\n", mDelayedCommitHandle)); + LOGWAYLAND((" mFrameCallback = %p\n", mFrameCallback)); + LOGWAYLAND((" mLastCommittedSurface = %p\n", mLastCommittedSurface)); +@@ -1030,20 +1052,11 @@ void WindowSurfaceWayland::CommitWayland + mLastCommittedSurface = nullptr; + } + +- if (mWholeWindowBufferDamage) { +- LOGWAYLAND((" send whole screen damage\n")); +- wl_surface_damage(waylandSurface, 0, 0, mBufferScreenRect.width, +- mBufferScreenRect.height); +- mWholeWindowBufferDamage = false; +- mNeedScaleFactorUpdate = true; +- } else { +- for (auto iter = mWaylandBufferDamage.RectIter(); !iter.Done(); +- iter.Next()) { +- mozilla::LayoutDeviceIntRect r = iter.Get(); +- LOGWAYLAND((" wl_surface_damage_buffer [%d, %d] -> [%d, %d]\n", r.x, +- r.y, r.width, r.height)); +- wl_surface_damage_buffer(waylandSurface, r.x, r.y, r.width, r.height); +- } ++ for (auto iter = mWaylandBufferDamage.RectIter(); !iter.Done(); iter.Next()) { ++ mozilla::LayoutDeviceIntRect r = iter.Get(); ++ LOGWAYLAND((" wl_surface_damage_buffer [%d, %d] -> [%d, %d]\n", r.x, r.y, ++ r.width, r.height)); ++ wl_surface_damage_buffer(waylandSurface, r.x, r.y, r.width, r.height); + } + + // Clear all back buffer damage as we're committing +@@ -1062,9 +1075,9 @@ void WindowSurfaceWayland::CommitWayland + mLastCommittedSurface = waylandSurface; + mLastCommitTime = g_get_monotonic_time() / 1000; + +- // Ask wl_display to start events synchronization. We're going wait ++ // Ask wl_display to start events synchronization. We're going to wait + // until all events are processed before next WindowSurfaceWayland::Lock() +- // as we need freed wl_buffer there. ++ // as we hope for free wl_buffer there. + mWaylandDisplay->SyncBegin(); + + // There's no pending commit, all changes are sent to compositor. +@@ -1074,9 +1087,6 @@ void WindowSurfaceWayland::CommitWayland + void WindowSurfaceWayland::Commit(const LayoutDeviceIntRegion& aInvalidRegion) { + MOZ_ASSERT(mIsMainThread == NS_IsMainThread()); + +- // Flush all waiting events explicitly as we need +- // mWaylandDisplay->FlushEventQueue(); +- + #ifdef MOZ_LOGGING + { + gfx::IntRect lockSize = aInvalidRegion.GetBounds().ToUnknownRect(); +@@ -1087,17 +1097,12 @@ void WindowSurfaceWayland::Commit(const + mBufferScreenRect.width, mBufferScreenRect.height)); + LOGWAYLAND((" mDrawToWaylandBufferDirectly = %d\n", + mDrawToWaylandBufferDirectly)); +- LOGWAYLAND( +- (" mWholeWindowBufferDamage = %d\n", mWholeWindowBufferDamage)); + } + #endif + + if (mDrawToWaylandBufferDirectly) { + MOZ_ASSERT(mWaylandBuffer->IsLocked()); +- // If we're not at fullscreen damage add drawing area from aInvalidRegion +- if (!mWholeWindowBufferDamage) { +- mWaylandBufferDamage.OrWith(aInvalidRegion); +- } ++ mWaylandBufferDamage.OrWith(aInvalidRegion); + UnlockWaylandBuffer(); + mBufferPendingCommit = true; + } else { +diff -up firefox-69.0/widget/gtk/WindowSurfaceWayland.h.mozilla-1581748 firefox-69.0/widget/gtk/WindowSurfaceWayland.h +--- firefox-69.0/widget/gtk/WindowSurfaceWayland.h.mozilla-1581748 2019-09-17 13:19:47.191908280 +0200 ++++ firefox-69.0/widget/gtk/WindowSurfaceWayland.h 2019-09-17 13:19:47.197908258 +0200 +@@ -161,6 +161,10 @@ class WindowImageSurface { + WindowImageSurface(gfxImageSurface* aImageSurface, + const LayoutDeviceIntRegion& aUpdateRegion); + ++ bool OverlapsSurface(class WindowImageSurface& aBottomSurface); ++ ++ const LayoutDeviceIntRegion* GetUpdateRegion() { return &mUpdateRegion; }; ++ + private: + RefPtr<gfx::SourceSurface> mSurface; + RefPtr<gfxImageSurface> mImageSurface; +@@ -174,20 +178,59 @@ class WindowSurfaceWayland : public Wind + explicit WindowSurfaceWayland(nsWindow* aWindow); + ~WindowSurfaceWayland(); + ++ // Lock() / Commit() are called by gecko when Firefox ++ // wants to display something. Lock() returns a DrawTarget ++ // where gecko paints. When gecko is done it calls Commit() ++ // and we try to send the DrawTarget (backed by wl_buffer) ++ // to wayland compositor. ++ // ++ // 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(). + already_AddRefed<gfx::DrawTarget> Lock( + const LayoutDeviceIntRegion& aRegion) override; + void Commit(const LayoutDeviceIntRegion& aInvalidRegion) final; ++ ++ // It's called from wayland compositor when there's the right ++ // time to send wl_buffer to display. It's no-op if there's no ++ // 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 ++ // (see WindowBackBufferShm::Detach() for instance). + void CommitWaylandBuffer(); + + nsWaylandDisplay* GetWaylandDisplay() { return mWaylandDisplay; }; + ++ // Image cache mode can be set by widget.wayland_cache_mode ++ typedef enum { ++ // Cache and clip all drawings, default. It's slowest ++ // but also without any rendered artifacts. ++ CACHE_ALL = 0, ++ // Cache drawing only when back buffer is missing. May produce ++ // some rendering artifacts and flickering when partial screen update ++ // is rendered. ++ CACHE_MISSING = 1, ++ // Don't cache anything, draw only when back buffer is available. ++ // Suitable for fullscreen content only like fullscreen video playback and ++ // may work well with dmabuf backend. ++ CACHE_NONE = 2 ++ } RenderingCacheMode; ++ + private: + WindowBackBuffer* CreateWaylandBuffer(int aWidth, int aHeight); + WindowBackBuffer* GetWaylandBufferToDraw(bool aCanSwitchBuffer); + +- already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(bool aCanSwitchBuffer); ++ already_AddRefed<gfx::DrawTarget> LockWaylandBuffer(); + void UnlockWaylandBuffer(); + + already_AddRefed<gfx::DrawTarget> LockImageSurface( +@@ -206,23 +249,71 @@ class WindowSurfaceWayland : public Wind + // mBufferScreenRect is window size when our wayland buffer was allocated. + LayoutDeviceIntRect mBufferScreenRect; + nsWaylandDisplay* mWaylandDisplay; ++ ++ // Actual buffer (backed by wl_buffer) where all drawings go into. ++ // Drawn areas are stored at mWaylandBufferDamage and if there's ++ // any uncommited drawings which needs to be send to wayland compositor ++ // the mBufferPendingCommit is set. + WindowBackBuffer* mWaylandBuffer; +- LayoutDeviceIntRegion mWaylandBufferDamage; + WindowBackBuffer* mBackupBuffer[BACK_BUFFER_NUM]; ++ LayoutDeviceIntRegion mWaylandBufferDamage; ++ ++ // After every commit to wayland compositor a frame callback is requested. ++ // Any next commit to wayland compositor will happen when frame callback ++ // comes from wayland compositor back as it's the best time to do the commit. + 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. + RefPtr<gfxImageSurface> mImageSurface; + AutoTArray<WindowImageSurface, 30> mDelayedImageCommits; ++ + int64_t mLastCommitTime; ++ ++ // Indicates that we don't have any cached drawings at mDelayedImageCommits ++ // and WindowSurfaceWayland::Lock() returned WaylandBuffer to gecko ++ // to draw into. + bool mDrawToWaylandBufferDirectly; ++ ++ // Set when our cached drawings (mDelayedImageCommits) contains ++ // full screen damage. That means we can safely switch WaylandBuffer ++ // at LockWaylandBuffer(). ++ bool mCanSwitchWaylandBuffer; ++ ++ // Set when actual WaylandBuffer contains drawings which are not send to ++ // wayland compositor yet. + bool mBufferPendingCommit; ++ ++ // 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()) + bool mBufferCommitAllowed; +- bool mWholeWindowBufferDamage; ++ ++ // We need to clear WaylandBuffer when entire transparent window is repainted. ++ // This typically apply to popup windows. + bool mBufferNeedsClear; ++ + bool mIsMainThread; ++ ++ // When new WaylandBuffer (wl_buffer) is send to wayland compositor ++ // (buffer switch or resize) we also need to set its scale factor. + bool mNeedScaleFactorUpdate; + ++ // Image caching strategy, see RenderingCacheMode for details. ++ RenderingCacheMode mRenderingCacheMode; ++ + static bool UseDMABufBackend(); + static bool mUseDMABufInitialized; + static bool mUseDMABuf; |