Use lockCacheBuffer instead of WBufferRenderer::setForceCacheBuffer

Author: zccrs

src/server/qtquick/private/wbufferrenderer.cpp

@@ -124,8 +124,6 @@ class Q_DECL_HIDDEN TextureProvider : public WBufferTextureProvider
     }
 
     void setBuffer(qw_buffer *buffer, const pixman_region32_t *damage = nullptr) {
-        Q_ASSERT(item);
-
         if (buffer && buffer == qwBuffer()) {
             m_texture->qwtexture->update_from_buffer(*buffer, damage);
             Q_EMIT textureChanged();
@@ -136,8 +134,10 @@ class Q_DECL_HIDDEN TextureProvider : public WBufferTextureProvider
             cleanTexture();
 
         Q_ASSERT(!m_texture);
-        if (buffer)
+        if (buffer) {
+            Q_ASSERT(item);
             m_texture = new Texture(item->window(), item->output()->renderer(), buffer);
+        }
 
         Q_EMIT textureChanged();
     }
@@ -195,7 +195,6 @@ class Q_DECL_HIDDEN TextureProvider : public WBufferTextureProvider
 WBufferRenderer::WBufferRenderer(QQuickItem *parent)
     : QQuickItem(parent)
     , m_cacheBuffer(false)
-    , m_forceCacheBuffer(false)
     , m_hideSource(false)
 {
     m_textureProvider.reset(new TextureProvider(this));
@@ -293,6 +292,26 @@ void WBufferRenderer::setCacheBuffer(bool newCacheBuffer)
     Q_EMIT cacheBufferChanged();
 }
 
+void WBufferRenderer::lockCacheBuffer(QObject *owner)
+{
+    if (m_cacheBufferLocker.contains(owner))
+        return;
+    m_cacheBufferLocker.append(owner);
+    connect(owner, &QObject::destroyed, this, [this] {
+        unlockCacheBuffer(sender());
+    });
+    updateTextureProvider();
+}
+
+void WBufferRenderer::unlockCacheBuffer(QObject *owner)
+{
+    auto ok = m_cacheBufferLocker.removeOne(owner);
+    Q_ASSERT(ok);
+    ok = disconnect(owner, &QObject::destroyed, this, nullptr);
+    Q_ASSERT(ok);
+    updateTextureProvider();
+}
+
 QColor WBufferRenderer::clearColor() const
 {
     return m_clearColor;
@@ -690,14 +709,6 @@ void WBufferRenderer::componentComplete()
     QQuickItem::componentComplete();
 }
 
-void WBufferRenderer::setForceCacheBuffer(bool force)
-{
-    if (m_forceCacheBuffer == force)
-        return;
-    m_forceCacheBuffer = force;
-    updateTextureProvider();
-}
-
 void WBufferRenderer::resetTextureProvider()
 {
     if (m_textureProvider)
@@ -706,6 +717,9 @@ void WBufferRenderer::resetTextureProvider()
 
 void WBufferRenderer::updateTextureProvider()
 {
+    if (!m_textureProvider)
+        return;
+
     if (shouldCacheBuffer() && m_textureProvider->qwBuffer() != m_lastBuffer) {
         m_textureProvider->setBuffer(m_lastBuffer);
     } else {

src/server/qtquick/private/wbufferrenderer_p.h

@@ -61,6 +61,9 @@ class WAYLIB_SERVER_EXPORT WBufferRenderer : public QQuickItem
     bool cacheBuffer() const;
     void setCacheBuffer(bool newCacheBuffer);
 
+    void lockCacheBuffer(QObject *owner);
+    void unlockCacheBuffer(QObject *owner);
+
     QColor clearColor() const;
     void setClearColor(const QColor &clearColor);
 
@@ -100,10 +103,9 @@ class WAYLIB_SERVER_EXPORT WBufferRenderer : public QQuickItem
     }
 
     inline bool shouldCacheBuffer() const {
-        return m_cacheBuffer || m_forceCacheBuffer;
+        return m_cacheBuffer || !m_cacheBufferLocker.isEmpty();
     }
 
-    void setForceCacheBuffer(bool force);
     void resetTextureProvider();
     void updateTextureProvider();
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data) override;
@@ -150,9 +152,9 @@ class WAYLIB_SERVER_EXPORT WBufferRenderer : public QQuickItem
     QW_NAMESPACE::qw_damage_ring m_damageRing;
     std::unique_ptr<TextureProvider> m_textureProvider;
     QColor m_clearColor = Qt::transparent;
+    QList<QObject*> m_cacheBufferLocker;
 
     uint m_cacheBuffer:1;
-    uint m_forceCacheBuffer:1;
     uint m_hideSource:1;
 };
 

src/server/qtquick/woutputrenderwindow.cpp

@@ -88,6 +88,34 @@ inline static void resetGlState()
 #endif
 }
 
+class Q_DECL_HIDDEN BufferRendererProxy : public WQuickTextureProxy
+{
+public:
+    BufferRendererProxy(QQuickItem *parent = nullptr)
+        : WQuickTextureProxy(parent) {}
+
+    inline WBufferRenderer *renderer() const {
+        auto r = qobject_cast<WBufferRenderer*>(sourceItem());
+        if (sourceItem())
+            Q_ASSERT(r);
+        return r;
+    }
+
+    void setRenderer(WBufferRenderer *renderer) {
+        auto oldRenderer = this->renderer();
+        if (oldRenderer == renderer)
+            return;
+        if (oldRenderer)
+            oldRenderer->unlockCacheBuffer(this);
+        if (renderer)
+            renderer->lockCacheBuffer(this);
+        setSourceItem(renderer);
+    }
+
+private:
+    using WQuickTextureProxy::setSourceItem;
+};
+
 class OutputLayer;
 class Q_DECL_HIDDEN OutputHelper : public WOutputHelper
 {
@@ -216,13 +244,13 @@ class Q_DECL_HIDDEN OutputHelper : public WOutputHelper
     WBufferRenderer *m_lastCommitBuffer = nullptr;
     // only for render cursor
     QPointer<WBufferRenderer> m_cursorRenderer;
-    WQuickTextureProxy *m_cursorLayerProxy = nullptr;
+    BufferRendererProxy *m_cursorLayerProxy = nullptr;
     bool m_cursorDirty = false;
 
     // for compositeLayers
     QPointer<WOutputViewport> m_output2;
     QPointer<QQuickItem> m_layerPorxyContainer;
-    QList<QPointer<WQuickTextureProxy>> m_layerProxys;
+    QList<QPointer<BufferRendererProxy>> m_layerProxys;
 };
 
 class Q_DECL_HIDDEN OutputLayer
@@ -503,18 +531,17 @@ void OutputHelper::sortLayers()
 
 void OutputHelper::cleanLayerCompositor()
 {
-    QList<QPointer<WQuickTextureProxy>> tmpList;
+    QList<QPointer<BufferRendererProxy>> tmpList;
     std::swap(m_layerProxys, tmpList);
 
     for (auto proxy : std::as_const(tmpList)) {
         if (!proxy)
             continue;
 
         WBufferRenderer *source = qobject_cast<WBufferRenderer*>(proxy->sourceItem());
-        proxy->setSourceItem(nullptr);
+        proxy->setRenderer(nullptr);
 
         if (source) {
-            source->setForceCacheBuffer(false);
             source->resetTextureProvider();
         }
     }
@@ -843,7 +870,6 @@ WBufferRenderer *OutputHelper::afterRender()
                 // try fallback to cursor plane
                 Q_ASSERT(needsSoftwareCompositeEndIndex == -1);
                 const auto layerData = needsCompositeLayers.at(i);
-                layerData->renderer->setForceCacheBuffer(!hasHardwareCursor && isCursor);
                 if (!hasHardwareCursor && isCursor
                     && tryToHardwareCursor(layerData)) {
                     Q_ASSERT(layerData->renderer->lastBuffer()->handle() == state.buffer);
@@ -945,11 +971,10 @@ WBufferRenderer *OutputHelper::compositeLayers(const QList<LayerData*> layers, b
             m_layerProxys.reserve(layers.size() + 1);
 
         if (m_layerProxys.isEmpty())
-            m_layerProxys.append(new WQuickTextureProxy(m_layerPorxyContainer));
+            m_layerProxys.append(new BufferRendererProxy(m_layerPorxyContainer));
 
         auto outputProxy = m_layerProxys.first();
-        bufferRenderer()->setForceCacheBuffer(true);
-        outputProxy->setSourceItem(bufferRenderer());
+        outputProxy->setRenderer(bufferRenderer());
         outputProxy->setSize(output->size());
     } else {
         output = m_output;
@@ -964,19 +989,18 @@ WBufferRenderer *OutputHelper::compositeLayers(const QList<LayerData*> layers, b
 
     for (int i = 0; i < layers.count(); ++i) {
         const int j = i + (usingShadowRenderer ? 1 : 0);
-        WQuickTextureProxy *proxy = nullptr;
+        BufferRendererProxy *proxy = nullptr;
         if (j < m_layerProxys.size()) {
             proxy = m_layerProxys.at(j);
         } else {
-            proxy = new WQuickTextureProxy(m_layerPorxyContainer);
+            proxy = new BufferRendererProxy(m_layerPorxyContainer);
             if (visualizeLayers())
                 createVisualRectangle(proxy, Qt::red);
             m_layerProxys.append(proxy);
         }
 
         LayerData *layer = layers.at(i);
-        layer->renderer->setForceCacheBuffer(true);
-        proxy->setSourceItem(layer->renderer);
+        proxy->setRenderer(layer->renderer);
         proxy->setPosition(layer->mapRect.topLeft());
         proxy->setSize(layer->mapRect.size());
         proxy->setZ(layer->layer->layer->z());
@@ -1076,7 +1100,7 @@ bool OutputHelper::tryToHardwareCursor(const LayerData *layer)
                 m_cursorRenderer = new WBufferRenderer(renderWindow()->contentItem());
                 if (visualizeLayers())
                     m_cursorRenderer->setClearColor(Qt::cyan);
-                m_cursorLayerProxy = new WQuickTextureProxy(m_cursorRenderer);
+                m_cursorLayerProxy = new BufferRendererProxy(m_cursorRenderer);
                 m_cursorRenderer->setSourceList({m_cursorLayerProxy}, false);
                 m_cursorRenderer->setOutput(m_output->output());
                 m_cursorRenderer->setVisible(false);
@@ -1087,7 +1111,7 @@ bool OutputHelper::tryToHardwareCursor(const LayerData *layer)
                     m_cursorDirty = true;
                 });
             }
-            m_cursorLayerProxy->setSourceItem(layer->renderer);
+            m_cursorLayerProxy->setRenderer(layer->renderer);
             // Ensure render size same as source buffer size
             m_cursorLayerProxy->setWidth(buffer->width);
             m_cursorLayerProxy->setHeight(buffer->height);