scene: port away from manual memory management

src/scene/cursoritem.cpp

@@ -54,7 +54,7 @@ void CursorItem::setImage(const QImage &image)
     m_surfaceItem.reset();
 
     if (!m_imageItem) {
-        m_imageItem.reset(scene()->renderer()->createImageItem(scene(), this));
+        m_imageItem = scene()->renderer()->createImageItem(scene(), this);
     }
     m_imageItem->setImage(image);
     m_imageItem->setSize(image.size() / image.devicePixelRatio());

src/scene/decorationitem.cpp

@@ -91,7 +91,7 @@ DecorationItem::DecorationItem(KDecoration2::Decoration *decoration, Window *win
     : Item(scene, parent)
     , m_window(window)
 {
-    m_renderer.reset(Compositor::self()->scene()->createDecorationRenderer(window->decoratedClient()));
+    m_renderer = Compositor::self()->scene()->createDecorationRenderer(window->decoratedClient());
 
     connect(window, &Window::frameGeometryChanged,
             this, &DecorationItem::handleFrameGeometryChanged);

src/scene/itemrenderer.h

@@ -9,6 +9,7 @@
 #include <kwin_export.h>
 
 #include <QMatrix4x4>
+#include <memory>
 
 class QPainter;
 
@@ -36,7 +37,7 @@ public:
     virtual void renderBackground(const RenderTarget &renderTarget, const RenderViewport &viewport, const QRegion &region) = 0;
     virtual void renderItem(const RenderTarget &renderTarget, const RenderViewport &viewport, Item *item, int mask, const QRegion &region, const WindowPaintData &data) = 0;
 
-    virtual ImageItem *createImageItem(Scene *scene, Item *parent = nullptr) = 0;
+    virtual std::unique_ptr<ImageItem> createImageItem(Scene *scene, Item *parent = nullptr) = 0;
 };
 
 } // namespace KWin

src/scene/itemrenderer_opengl.cpp

@@ -26,9 +26,9 @@ ItemRendererOpenGL::ItemRendererOpenGL()
     }
 }
 
-ImageItem *ItemRendererOpenGL::createImageItem(Scene *scene, Item *parent)
+std::unique_ptr<ImageItem> ItemRendererOpenGL::createImageItem(Scene *scene, Item *parent)
 {
-    return new ImageItemOpenGL(scene, parent);
+    return std::make_unique<ImageItemOpenGL>(scene, parent);
 }
 
 void ItemRendererOpenGL::beginFrame(const RenderTarget &renderTarget, const RenderViewport &viewport)

src/scene/itemrenderer_opengl.h

@@ -48,7 +48,7 @@ public:
     void renderBackground(const RenderTarget &renderTarget, const RenderViewport &viewport, const QRegion &region) override;
     void renderItem(const RenderTarget &renderTarget, const RenderViewport &viewport, Item *item, int mask, const QRegion &region, const WindowPaintData &data) override;
 
-    ImageItem *createImageItem(Scene *scene, Item *parent = nullptr) override;
+    std::unique_ptr<ImageItem> createImageItem(Scene *scene, Item *parent = nullptr) override;
 
 private:
     QVector4D modulate(float opacity, float brightness) const;

src/scene/itemrenderer_qpainter.cpp

@@ -24,9 +24,9 @@ ItemRendererQPainter::~ItemRendererQPainter()
 {
 }
 
-ImageItem *ItemRendererQPainter::createImageItem(Scene *scene, Item *parent)
+std::unique_ptr<ImageItem> ItemRendererQPainter::createImageItem(Scene *scene, Item *parent)
 {
-    return new ImageItem(scene, parent);
+    return std::make_unique<ImageItem>(scene, parent);
 }
 
 QPainter *ItemRendererQPainter::painter() const

src/scene/itemrenderer_qpainter.h

@@ -30,7 +30,7 @@ public:
     void renderBackground(const RenderTarget &renderTarget, const RenderViewport &viewport, const QRegion &region) override;
     void renderItem(const RenderTarget &renderTarget, const RenderViewport &viewport, Item *item, int mask, const QRegion &region, const WindowPaintData &data) override;
 
-    ImageItem *createImageItem(Scene *scene, Item *parent = nullptr) override;
+    std::unique_ptr<ImageItem> createImageItem(Scene *scene, Item *parent = nullptr) override;
 
 private:
     void renderSurfaceItem(QPainter *painter, SurfaceItem *surfaceItem) const;

src/scene/surfaceitem_wayland.cpp

@@ -116,18 +116,17 @@ void SurfaceItemWayland::handleSurfaceCommitted()
 
 SurfaceItemWayland *SurfaceItemWayland::getOrCreateSubSurfaceItem(KWaylandServer::SubSurfaceInterface *child)
 {
-    SurfaceItemWayland *&item = m_subsurfaces[child];
+    auto &item = m_subsurfaces[child];
     if (!item) {
-        item = new SurfaceItemWayland(child->surface(), scene());
-        item->setParent(this);
+        item = std::make_unique<SurfaceItemWayland>(child->surface(), scene());
         item->setParentItem(this);
     }
-    return item;
+    return item.get();
 }
 
 void SurfaceItemWayland::handleChildSubSurfaceRemoved(KWaylandServer::SubSurfaceInterface *child)
 {
-    delete m_subsurfaces.take(child);
+    m_subsurfaces.erase(child);
 }
 
 void SurfaceItemWayland::handleChildSubSurfacesChanged()

src/scene/surfaceitem_wayland.h

@@ -8,6 +8,8 @@
 
 #include "scene/surfaceitem.h"
 
+#include <unordered_map>
+
 namespace KWaylandServer
 {
 class SubSurfaceInterface;
@@ -56,7 +58,7 @@ private:
     SurfaceItemWayland *getOrCreateSubSurfaceItem(KWaylandServer::SubSurfaceInterface *s);
 
     QPointer<KWaylandServer::SurfaceInterface> m_surface;
-    QHash<KWaylandServer::SubSurfaceInterface *, SurfaceItemWayland *> m_subsurfaces;
+    std::unordered_map<KWaylandServer::SubSurfaceInterface *, std::unique_ptr<SurfaceItemWayland>> m_subsurfaces;
 };
 
 class KWIN_EXPORT SurfacePixmapWayland final : public SurfacePixmap

src/scene/windowitem.cpp

@@ -192,15 +192,15 @@ void WindowItem::addSurfaceItemDamageConnects(Item *item)
     }
 }
 
-void WindowItem::updateSurfaceItem(SurfaceItem *surfaceItem)
+void WindowItem::updateSurfaceItem(std::unique_ptr<SurfaceItem> &&surfaceItem)
 {
-    m_surfaceItem.reset(surfaceItem);
+    m_surfaceItem = std::move(surfaceItem);
 
     if (m_surfaceItem) {
         connect(m_window, &Window::shadeChanged, this, &WindowItem::updateSurfaceVisibility);
         connect(m_window, &Window::bufferGeometryChanged, this, &WindowItem::updateSurfacePosition);
         connect(m_window, &Window::frameGeometryChanged, this, &WindowItem::updateSurfacePosition);
-        addSurfaceItemDamageConnects(surfaceItem);
+        addSurfaceItemDamageConnects(m_surfaceItem.get());
 
         updateSurfacePosition();
         updateSurfaceVisibility();
@@ -229,7 +229,7 @@ void WindowItem::updateShadowItem()
     Shadow *shadow = m_window->shadow();
     if (shadow) {
         if (!m_shadowItem || m_shadowItem->shadow() != shadow) {
-            m_shadowItem.reset(new ShadowItem(shadow, m_window, scene(), this));
+            m_shadowItem = std::make_unique<ShadowItem>(shadow, m_window, scene(), this);
         }
         if (m_decorationItem) {
             m_shadowItem->stackBefore(m_decorationItem.get());
@@ -248,7 +248,7 @@ void WindowItem::updateDecorationItem()
         return;
     }
     if (m_window->decoration()) {
-        m_decorationItem.reset(new DecorationItem(m_window->decoration(), m_window, scene(), this));
+        m_decorationItem = std::make_unique<DecorationItem>(m_window->decoration(), m_window, scene(), this);
         if (m_shadowItem) {
             m_decorationItem->stackAfter(m_shadowItem.get());
         } else if (m_surfaceItem) {
@@ -293,13 +293,13 @@ void WindowItemX11::initialize()
 {
     switch (kwinApp()->operationMode()) {
     case Application::OperationModeX11:
-        updateSurfaceItem(new SurfaceItemX11(static_cast<X11Window *>(window()), scene(), this));
+        updateSurfaceItem(std::make_unique<SurfaceItemX11>(static_cast<X11Window *>(window()), scene(), this));
         break;
     case Application::OperationModeXwayland:
         if (!window()->surface()) {
             updateSurfaceItem(nullptr);
         } else {
-            updateSurfaceItem(new SurfaceItemXwayland(static_cast<X11Window *>(window()), scene(), this));
+            updateSurfaceItem(std::make_unique<SurfaceItemXwayland>(static_cast<X11Window *>(window()), scene(), this));
         }
         break;
     case Application::OperationModeWaylandOnly:
@@ -310,13 +310,13 @@ void WindowItemX11::initialize()
 WindowItemWayland::WindowItemWayland(Window *window, Scene *scene, Item *parent)
     : WindowItem(window, scene, parent)
 {
-    updateSurfaceItem(new SurfaceItemWayland(window->surface(), scene, this));
+    updateSurfaceItem(std::make_unique<SurfaceItemWayland>(window->surface(), scene, this));
 }
 
 WindowItemInternal::WindowItemInternal(InternalWindow *window, Scene *scene, Item *parent)
     : WindowItem(window, scene, parent)
 {
-    updateSurfaceItem(new SurfaceItemInternal(window, scene, this));
+    updateSurfaceItem(std::make_unique<SurfaceItemInternal>(window, scene, this));
 }
 
 } // namespace KWin

src/scene/windowitem.h

@@ -56,7 +56,7 @@ public:
 
 protected:
     explicit WindowItem(Window *window, Scene *scene, Item *parent = nullptr);
-    void updateSurfaceItem(SurfaceItem *surfaceItem);
+    void updateSurfaceItem(std::unique_ptr<SurfaceItem> &&surfaceItem);
 
 private Q_SLOTS:
     void updateDecorationItem();

src/scene/workspacescene.h

@@ -65,7 +65,7 @@ public:
     virtual void doneOpenGLContextCurrent();
     virtual bool supportsNativeFence() const;
 
-    virtual DecorationRenderer *createDecorationRenderer(Decoration::DecoratedClientImpl *) = 0;
+    virtual std::unique_ptr<DecorationRenderer> createDecorationRenderer(Decoration::DecoratedClientImpl *) = 0;
     virtual std::unique_ptr<ShadowTextureProvider> createShadowTextureProvider(Shadow *shadow) = 0;
 
     /**

src/scene/workspacescene_opengl.cpp

@@ -70,9 +70,9 @@ bool WorkspaceSceneOpenGL::supportsNativeFence() const
     return m_backend->supportsNativeFence();
 }
 
-DecorationRenderer *WorkspaceSceneOpenGL::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
+std::unique_ptr<DecorationRenderer> WorkspaceSceneOpenGL::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
 {
-    return new SceneOpenGLDecorationRenderer(impl);
+    return std::make_unique<SceneOpenGLDecorationRenderer>(impl);
 }
 
 std::unique_ptr<ShadowTextureProvider> WorkspaceSceneOpenGL::createShadowTextureProvider(Shadow *shadow)

src/scene/workspacescene_opengl.h

@@ -33,7 +33,7 @@ public:
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
     bool supportsNativeFence() const override;
-    DecorationRenderer *createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
+    std::unique_ptr<DecorationRenderer> createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
     std::unique_ptr<ShadowTextureProvider> createShadowTextureProvider(Shadow *shadow) override;
     bool animationsSupported() const override;
 

src/scene/workspacescene_qpainter.cpp

@@ -36,9 +36,9 @@ WorkspaceSceneQPainter::~WorkspaceSceneQPainter()
 {
 }
 
-DecorationRenderer *WorkspaceSceneQPainter::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
+std::unique_ptr<DecorationRenderer> WorkspaceSceneQPainter::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
 {
-    return new SceneQPainterDecorationRenderer(impl);
+    return std::make_unique<SceneQPainterDecorationRenderer>(impl);
 }
 
 std::unique_ptr<ShadowTextureProvider> WorkspaceSceneQPainter::createShadowTextureProvider(Shadow *shadow)

src/scene/workspacescene_qpainter.h

@@ -25,7 +25,7 @@ public:
     explicit WorkspaceSceneQPainter(QPainterBackend *backend);
     ~WorkspaceSceneQPainter() override;
 
-    DecorationRenderer *createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
+    std::unique_ptr<DecorationRenderer> createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
     std::unique_ptr<ShadowTextureProvider> createShadowTextureProvider(Shadow *shadow) override;
 
     bool animationsSupported() const override