Fix memory leaks in some cache maps

cmd/fyne_settings/settings/appearance.go

@@ -14,7 +14,7 @@ import (
 	"fyne.io/fyne/v2/app"
 	"fyne.io/fyne/v2/canvas"
 	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/internal/painter"
+	"fyne.io/fyne/v2/internal/cache"
 	"fyne.io/fyne/v2/layout"
 	"fyne.io/fyne/v2/theme"
 	"fyne.io/fyne/v2/tools/playground"
@@ -118,7 +118,7 @@ func (s *Settings) createPreview() image.Image {
 		th = theme.DarkTheme()
 	}
 
-	painter.SvgCacheReset() // reset icon cache
+	cache.ResetSvg() // reset icon cache
 	fyne.CurrentApp().Settings().(overrideTheme).OverrideTheme(th, s.fyneSettings.PrimaryColor)
 
 	empty := widget.NewLabel("")
@@ -136,7 +136,7 @@ func (s *Settings) createPreview() image.Image {
 	time.Sleep(canvas.DurationShort)
 	img := c.Capture()
 
-	painter.SvgCacheReset() // ensure we re-create the correct cached assets
+	cache.ResetSvg() // ensure we re-create the correct cached assets
 	fyne.CurrentApp().Settings().(overrideTheme).OverrideTheme(oldTheme, oldColor)
 	return img
 }

internal/cache/base.go

@@ -0,0 +1,207 @@
+package cache
+
+import (
+	"os"
+	"sync"
+	"time"
+
+	"fyne.io/fyne/v2"
+)
+
+var (
+	cacheDuration     = 1 * time.Minute
+	cleanTaskInterval = cacheDuration / 2
+
+	canvasRefreshCh = make(chan struct{}, 1)
+	expiredObjects  = make([]fyne.CanvasObject, 0, 50)
+	lastClean       time.Time
+)
+
+func init() {
+	if t, err := time.ParseDuration(os.Getenv("FYNE_CACHE")); err == nil {
+		cacheDuration = t
+		cleanTaskInterval = cacheDuration / 2
+	}
+}
+
+// CleanTask run cache clean task, it should be called on paint events.
+func CleanTask() {
+	now := time.Now()
+	// do not run clean task so fast
+	if now.Sub(lastClean) < 10*time.Second {
+		return
+	}
+	canvasRefresh := false
+	select {
+	case <-canvasRefreshCh:
+		canvasRefresh = true
+	default:
+		if now.Sub(lastClean) < cleanTaskInterval {
+			return
+		}
+	}
+	destroyExpiredSvgs(now)
+	if canvasRefresh {
+		// Destroy renderers on canvas refresh to avoid flickering screen.
+		destroyExpiredRenderers(now)
+		// canvases cache should be invalidated only on canvas refresh, otherwise there wouldn't
+		// be a way to recover them later
+		destroyExpiredCanvases(now)
+	}
+	lastClean = time.Now()
+}
+
+// ForceCleanFor forces a complete remove of all the objects that belong to the specified
+// canvas. Usually used to free all objects from a closing windows.
+func ForceCleanFor(canvas fyne.Canvas) {
+	deletingObjs := make([]fyne.CanvasObject, 0, 50)
+
+	// find all objects that belong to the specified canvas
+	canvasesLock.RLock()
+	for obj, cinfo := range canvases {
+		if cinfo.canvas == canvas {
+			deletingObjs = append(deletingObjs, obj)
+		}
+	}
+	canvasesLock.RUnlock()
+	if len(deletingObjs) == 0 {
+		return
+	}
+
+	// remove them from canvas cache
+	canvasesLock.Lock()
+	for _, dobj := range deletingObjs {
+		delete(canvases, dobj)
+	}
+	canvasesLock.Unlock()
+
+	// destroy their renderers and delete them from the renderer
+	// cache if they are widgets
+	renderersLock.Lock()
+	for _, dobj := range deletingObjs {
+		wid, ok := dobj.(fyne.Widget)
+		if !ok {
+			continue
+		}
+		winfo, ok := renderers[wid]
+		if !ok {
+			continue
+		}
+		winfo.renderer.Destroy()
+		delete(renderers, wid)
+	}
+	renderersLock.Unlock()
+}
+
+// NotifyCanvasRefresh notifies to the caches that a canvas refresh was triggered.
+func NotifyCanvasRefresh() {
+	select {
+	case canvasRefreshCh <- struct{}{}:
+	default:
+		return
+	}
+}
+
+// ===============================================================
+// Private functions
+// ===============================================================
+
+// destroyExpiredCanvases deletes objects from the canvases cache.
+func destroyExpiredCanvases(now time.Time) {
+	expiredObjects = expiredObjects[:0]
+	canvasesLock.RLock()
+	for obj, cinfo := range canvases {
+		if cinfo.isExpired(now) {
+			expiredObjects = append(expiredObjects, obj)
+		}
+	}
+	canvasesLock.RUnlock()
+	if len(expiredObjects) > 0 {
+		canvasesLock.Lock()
+		for i, exp := range expiredObjects {
+			delete(canvases, exp)
+			expiredObjects[i] = nil
+		}
+		canvasesLock.Unlock()
+	}
+}
+
+// destroyExpiredRenderers deletes the renderer from the cache and calls
+// renderer.Destroy()
+func destroyExpiredRenderers(now time.Time) {
+	expiredObjects = expiredObjects[:0]
+	renderersLock.RLock()
+	for wid, rinfo := range renderers {
+		if rinfo.isExpired(now) {
+			rinfo.renderer.Destroy()
+			expiredObjects = append(expiredObjects, wid)
+		}
+	}
+	renderersLock.RUnlock()
+	if len(expiredObjects) > 0 {
+		renderersLock.Lock()
+		for i, exp := range expiredObjects {
+			delete(renderers, exp.(fyne.Widget))
+			expiredObjects[i] = nil
+		}
+		renderersLock.Unlock()
+	}
+}
+
+// destroyExpiredSvgs destroys expired svgs cache data.
+func destroyExpiredSvgs(now time.Time) {
+	expiredSvgs := make([]string, 0, 20)
+	svgLock.RLock()
+	for s, sinfo := range svgs {
+		if sinfo.isExpired(now) {
+			expiredSvgs = append(expiredSvgs, s)
+		}
+	}
+	svgLock.RUnlock()
+	if len(expiredSvgs) > 0 {
+		svgLock.Lock()
+		for _, exp := range expiredSvgs {
+			delete(svgs, exp)
+		}
+		svgLock.Unlock()
+	}
+}
+
+// ===============================================================
+// Private types
+// ===============================================================
+
+type expiringCache struct {
+	expireLock sync.RWMutex
+	expires    time.Time
+}
+
+// isExpired check if the cache data is expired.
+func (c *expiringCache) isExpired(now time.Time) bool {
+	c.expireLock.RLock()
+	defer c.expireLock.RUnlock()
+	return c.expires.Before(now)
+}
+
+// setAlive updates expiration time.
+func (c *expiringCache) setAlive() {
+	t := time.Now().Add(cacheDuration)
+	c.expireLock.Lock()
+	c.expires = t
+	c.expireLock.Unlock()
+}
+
+type expiringCacheNoLock struct {
+	expires time.Time
+}
+
+// isExpired check if the cache data is expired.
+func (c *expiringCacheNoLock) isExpired(now time.Time) bool {
+	return c.expires.Before(now)
+}
+
+// setAlive updates expiration time.
+func (c *expiringCacheNoLock) setAlive() {
+	t := time.Now().Add(cacheDuration)
+	c.expires = t
+}

internal/cache/canvases.go

@@ -0,0 +1,36 @@
+package cache
+
+import (
+	"sync"
+
+	"fyne.io/fyne/v2"
+)
+
+var canvasesLock sync.RWMutex
+var canvases = make(map[fyne.CanvasObject]*canvasInfo, 1024)
+
+// GetCanvasForObject returns the canvas for the specified object.
+func GetCanvasForObject(obj fyne.CanvasObject) fyne.Canvas {
+	canvasesLock.RLock()
+	cinfo, ok := canvases[obj]
+	canvasesLock.RUnlock()
+	if cinfo == nil || !ok {
+		return nil
+	}
+	cinfo.setAlive()
+	return cinfo.canvas
+}
+
+// SetCanvasForObject sets the canvas for the specified object.
+func SetCanvasForObject(obj fyne.CanvasObject, canvas fyne.Canvas) {
+	cinfo := &canvasInfo{canvas: canvas}
+	cinfo.setAlive()
+	canvasesLock.Lock()
+	canvases[obj] = cinfo
+	canvasesLock.Unlock()
+}
+
+type canvasInfo struct {
+	expiringCache
+	canvas fyne.Canvas
+}

internal/cache/svg.go

@@ -0,0 +1,47 @@
+package cache
+
+import (
+	"image"
+	"sync"
+)
+
+var svgLock sync.RWMutex
+var svgs = make(map[string]*svgInfo)
+
+// GetSvg gets svg image from cache if it exists.
+func GetSvg(name string, w int, h int) *image.NRGBA {
+	svgLock.RLock()
+	sinfo, ok := svgs[name]
+	svgLock.RUnlock()
+	if !ok || sinfo == nil || sinfo.w != w || sinfo.h != h {
+		return nil
+	}
+	sinfo.setAlive()
+	return sinfo.pix
+}
+
+// ResetSvg clears all the svg cache map
+func ResetSvg() {
+	svgLock.Lock()
+	svgs = make(map[string]*svgInfo)
+	svgLock.Unlock()
+}
+
+// SetSvg sets a svg into the cache map.
+func SetSvg(name string, pix *image.NRGBA, w int, h int) {
+	sinfo := &svgInfo{
+		pix: pix,
+		w:   w,
+		h:   h,
+	}
+	sinfo.setAlive()
+	svgLock.Lock()
+	svgs[name] = sinfo
+	svgLock.Unlock()
+}
+
+type svgInfo struct {
+	expiringCacheNoLock
+	pix  *image.NRGBA
+	w, h int
+}