3 files changed, 93 insertions, 31 deletions

diff --git a/src/plugins/platforms/cocoa/qcocoabackingstore.h b/src/plugins/platforms/cocoa/qcocoabackingstore.h
index 6db88f923c..71b6015a54 100644
--- a/src/plugins/platforms/cocoa/qcocoabackingstore.h
+++ b/src/plugins/platforms/cocoa/qcocoabackingstore.h
@@ -54,6 +54,7 @@ private:
     bool eventFilter(QObject *watched, QEvent *event) override;
 
     QSize m_requestedSize;
+    QRegion m_staticContents;
 
     class GraphicsBuffer : public QIOSurfaceGraphicsBuffer
     {
@@ -78,7 +79,8 @@ private:
     bool recreateBackBufferIfNeeded();
     void finalizeBackBuffer();
 
-    void preserveFromFrontBuffer(const QRegion &region, const QPoint &offset = QPoint());
+    void blitBuffer(GraphicsBuffer *sourceBuffer, const QRegion &sourceRegion,
+                    GraphicsBuffer *destinationBuffer, const QPoint &destinationOffset = QPoint());
 
     void backingPropertiesChanged();
     QMacNotificationObserver m_backingPropertiesObserver;
diff --git a/src/plugins/platforms/cocoa/qcocoabackingstore.mm b/src/plugins/platforms/cocoa/qcocoabackingstore.mm
index 8f50bc5834..6970c44a12 100644
--- a/src/plugins/platforms/cocoa/qcocoabackingstore.mm
+++ b/src/plugins/platforms/cocoa/qcocoabackingstore.mm
@@ -72,12 +72,11 @@ bool QCALayerBackingStore::eventFilter(QObject *watched, QEvent *event)
 
 void QCALayerBackingStore::resize(const QSize &size, const QRegion &staticContents)
 {
-    qCDebug(lcQpaBackingStore) << "Resize requested to" << size;
-
-    if (!staticContents.isNull())
-        qCWarning(lcQpaBackingStore) << "QCALayerBackingStore does not support static contents";
+    qCDebug(lcQpaBackingStore) << "Resize requested to" << size
+                               << "with static contents" << staticContents;
 
     m_requestedSize = size;
+    m_staticContents = staticContents;
 }
 
 void QCALayerBackingStore::beginPaint(const QRegion &region)
@@ -193,7 +192,45 @@ bool QCALayerBackingStore::recreateBackBufferIfNeeded()
             << "based on requested" << m_requestedSize << "and dpr =" << devicePixelRatio;
 
         static auto pixelFormat = QImage::toPixelFormat(QImage::Format_ARGB32_Premultiplied);
-        m_buffers.back().reset(new GraphicsBuffer(requestedBufferSize, devicePixelRatio, pixelFormat, colorSpace()));
+        auto *newBackBuffer = new GraphicsBuffer(requestedBufferSize, devicePixelRatio, pixelFormat, colorSpace());
+
+        if (!m_staticContents.isEmpty() && m_buffers.back()) {
+            // We implicitly support static backingstore content as a result of
+            // finalizing the back buffer on flush, where we copy any non-painted
+            // areas from the front buffer. But there is no guarantee that a resize
+            // will always come after a flush, where we have a pristine front buffer
+            // to copy from. It may come after a few begin/endPaints, where the back
+            // buffer then contains (part of) the latest state. We also have the case
+            // of single-buffered backingstore, where the front and back buffer is
+            // the same, which means we must do the copy from the old back buffer
+            // to the newly resized buffer now, before we replace it below.
+
+            // If the back buffer has been partially filled already, we need to
+            // copy parts of the static content from that. The rest we copy from
+            // the front buffer.
+            const QRegion backBufferRegion = m_staticContents - m_buffers.back()->dirtyRegion;
+            const QRegion frontBufferRegion = m_staticContents - backBufferRegion;
+
+            qCInfo(lcQpaBackingStore) << "Preserving static content" << backBufferRegion
+                << "from back buffer, and" << frontBufferRegion << "from front buffer";
+
+            newBackBuffer->lock(QPlatformGraphicsBuffer::SWWriteAccess);
+            blitBuffer(m_buffers.back().get(), backBufferRegion, newBackBuffer);
+            Q_ASSERT(frontBufferRegion.isEmpty() || m_buffers.front());
+            blitBuffer(m_buffers.front().get(), frontBufferRegion, newBackBuffer);
+            newBackBuffer->unlock();
+
+            // The new back buffer now is valid for the static contents region.
+            // We don't need to maintain the static contents region for resizes
+            // of any other buffers in the swap chain, as these will finalize
+            // their content on flush from the buffer we just filled, and we
+            // don't need to mark them dirty for the area we just filled, as
+            // new buffers are fully dirty when created.
+            newBackBuffer->dirtyRegion -= m_staticContents;
+            m_staticContents = {};
+        }
+
+        m_buffers.back().reset(newBackBuffer);
         return true;
     }
 
@@ -256,7 +293,7 @@ bool QCALayerBackingStore::scroll(const QRegion &region, int dx, int dy)
 
     if (!frontBufferRegion.isEmpty()) {
         qCDebug(lcQpaBackingStore) << "Scrolling" << frontBufferRegion << "by copying from front buffer";
-        preserveFromFrontBuffer(frontBufferRegion, scrollDelta);
+        blitBuffer(m_buffers.front().get(), frontBufferRegion, m_buffers.back().get(), scrollDelta);
     }
 
     m_buffers.back()->unlock();
@@ -475,54 +512,76 @@ void QCALayerBackingStore::finalizeBackBuffer()
     if (!m_buffers.back()->isDirty())
         return;
 
-    m_buffers.back()->lock(QPlatformGraphicsBuffer::SWWriteAccess);
-    preserveFromFrontBuffer(m_buffers.back()->dirtyRegion);
-    m_buffers.back()->unlock();
+    qCDebug(lcQpaBackingStore) << "Finalizing back buffer with dirty region" << m_buffers.back()->dirtyRegion;
+
+    if (m_buffers.back() != m_buffers.front()) {
+        m_buffers.back()->lock(QPlatformGraphicsBuffer::SWWriteAccess);
+        blitBuffer(m_buffers.front().get(), m_buffers.back()->dirtyRegion, m_buffers.back().get());
+        m_buffers.back()->unlock();
+    } else {
+        qCDebug(lcQpaBackingStore) << "Front and back buffer is the same. Can not finalize back buffer.";
+    }
 
     // The back buffer is now completely in sync, ready to be presented
     m_buffers.back()->dirtyRegion = QRegion();
 }
 
-void QCALayerBackingStore::preserveFromFrontBuffer(const QRegion &region, const QPoint &offset)
+/*
+    \internal
+
+    Blits \a sourceRegion from \a sourceBuffer to \a destinationBuffer,
+    at offset \a destinationOffset.
+
+    The source buffer is automatically locked for read only access
+    during the blit.
+
+    The destination buffer has to be locked for write access by the
+    caller.
+*/
+
+void QCALayerBackingStore::blitBuffer(GraphicsBuffer *sourceBuffer, const QRegion &sourceRegion,
+                                      GraphicsBuffer *destinationBuffer, const QPoint &destinationOffset)
 {
+    Q_ASSERT(sourceBuffer && destinationBuffer);
+    Q_ASSERT(sourceBuffer != destinationBuffer);
 
-    if (m_buffers.front() == m_buffers.back())
-        return; // Nothing to preserve from
+    if (sourceRegion.isEmpty())
+        return;
 
-    qCDebug(lcQpaBackingStore) << "Preserving" << region << "of front buffer to"
-        << region.translated(offset) << "of back buffer";
+    qCDebug(lcQpaBackingStore) << "Blitting" << sourceRegion << "of" << sourceBuffer
+        << "to" << sourceRegion.translated(destinationOffset) << "of" << destinationBuffer;
 
-    Q_ASSERT(m_buffers.back()->isLocked() == QPlatformGraphicsBuffer::SWWriteAccess);
+    Q_ASSERT(destinationBuffer->isLocked() == QPlatformGraphicsBuffer::SWWriteAccess);
 
-    m_buffers.front()->lock(QPlatformGraphicsBuffer::SWReadAccess);
-    const QImage *frontBuffer = m_buffers.front()->asImage();
+    sourceBuffer->lock(QPlatformGraphicsBuffer::SWReadAccess);
+    const QImage *sourceImage = sourceBuffer->asImage();
 
-    const QRect frontSurfaceBounds(QPoint(0, 0), m_buffers.front()->size());
-    const qreal sourceDevicePixelRatio = frontBuffer->devicePixelRatio();
+    const QRect sourceBufferBounds(QPoint(0, 0), sourceBuffer->size());
+    const qreal sourceDevicePixelRatio = sourceImage->devicePixelRatio();
 
-    QPainter painter(m_buffers.back()->asImage());
+    QPainter painter(destinationBuffer->asImage());
     painter.setCompositionMode(QPainter::CompositionMode_Source);
 
     // Let painter operate in device pixels, to make it easier to compare coordinates
-    const qreal targetDevicePixelRatio = painter.device()->devicePixelRatio();
-    painter.scale(1.0 / targetDevicePixelRatio, 1.0 / targetDevicePixelRatio);
+    const qreal destinationDevicePixelRatio = painter.device()->devicePixelRatio();
+    painter.scale(1.0 / destinationDevicePixelRatio, 1.0 / destinationDevicePixelRatio);
 
-    for (const QRect &rect : region) {
+    for (const QRect &rect : sourceRegion) {
         QRect sourceRect(rect.topLeft() * sourceDevicePixelRatio,
                          rect.size() * sourceDevicePixelRatio);
-        QRect targetRect((rect.topLeft() + offset) * targetDevicePixelRatio,
-                          rect.size() * targetDevicePixelRatio);
+        QRect destinationRect((rect.topLeft() + destinationOffset) * destinationDevicePixelRatio,
+                               rect.size() * destinationDevicePixelRatio);
 
 #ifdef QT_DEBUG
-        if (Q_UNLIKELY(!frontSurfaceBounds.contains(sourceRect.bottomRight()))) {
-            qCWarning(lcQpaBackingStore) << "Front buffer too small to preserve"
-                << QRegion(sourceRect).subtracted(frontSurfaceBounds);
+        if (Q_UNLIKELY(!sourceBufferBounds.contains(sourceRect.bottomRight()))) {
+            qCWarning(lcQpaBackingStore) << "Source buffer of size" << sourceBuffer->size()
+                                         << "is too small to blit" << sourceRect;
         }
 #endif
-        painter.drawImage(targetRect, *frontBuffer, sourceRect);
+        painter.drawImage(destinationRect, *sourceImage, sourceRect);
     }
 
-    m_buffers.front()->unlock();
+    sourceBuffer->unlock();
 }
 
 // ----------------------------------------------------------------------------
diff --git a/src/plugins/platforms/cocoa/qcocoaintegration.mm b/src/plugins/platforms/cocoa/qcocoaintegration.mm
index 8d5645f8bb..f21e683c00 100644
--- a/src/plugins/platforms/cocoa/qcocoaintegration.mm
+++ b/src/plugins/platforms/cocoa/qcocoaintegration.mm
@@ -232,6 +232,7 @@ bool QCocoaIntegration::hasCapability(QPlatformIntegration::Capability cap) cons
     case RasterGLSurface:
     case ApplicationState:
     case ApplicationIcon:
+    case BackingStoreStaticContents:
         return true;
     default:
         return QPlatformIntegration::hasCapability(cap);