From d402222f1778fa5e9d43f91354a7d8a6238670fa Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 30 Nov 2017 05:05:07 +0900
Subject: [PATCH] Fix DisposeTrack and improve AsyncLazy to support disposal

---
 osu.Game/Beatmaps/WorkingBeatmap.cs | 63 +++++++++++++++++++++++++----
 osu.Game/OsuGameBase.cs             |  2 +-
 2 files changed, 56 insertions(+), 9 deletions(-)

diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index 2a8178882e..93ba51367a 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -31,7 +31,7 @@ namespace osu.Game.Beatmaps
             Mods.ValueChanged += mods => applyRateAdjustments();
 
             beatmap = new AsyncLazy<Beatmap>(populateBeatmap);
-            background = new AsyncLazy<Texture>(populateBackground);
+            background = new AsyncLazy<Texture>(populateBackground, b => b == null || !b.IsDisposed);
             track = new AsyncLazy<Track>(populateTrack);
             waveform = new AsyncLazy<Waveform>(populateWaveform);
         }
@@ -99,10 +99,11 @@ namespace osu.Game.Beatmaps
             if (WaveformLoaded) Waveform?.Dispose();
         }
 
-        public void DisposeTrack()
-        {
-            if (TrackLoaded) Track?.Dispose();
-        }
+        /// <summary>
+        /// Eagerly dispose of the audio track associated with this <see cref="WorkingBeatmap"/> (if any).
+        /// Accessing track again will load a fresh instance.
+        /// </summary>
+        public void RecycleTrack() => track.Recycle();
 
         private void applyRateAdjustments(Track t = null)
         {
@@ -114,11 +115,57 @@ namespace osu.Game.Beatmaps
                 mod.ApplyToClock(t);
         }
 
-        public class AsyncLazy<T> : Lazy<Task<T>>
+        public class AsyncLazy<T>
         {
-            public AsyncLazy(Func<T> valueFactory)
-                : base(() => Task.Run(valueFactory))
+            private Lazy<Task<T>> lazy;
+            private readonly Func<T> valueFactory;
+            private readonly Func<T, bool> stillValidFunction;
+
+            public AsyncLazy(Func<T> valueFactory, Func<T, bool> stillValidFunction = null)
             {
+                this.valueFactory = valueFactory;
+                this.stillValidFunction = stillValidFunction;
+
+                init();
+            }
+
+            public void Recycle()
+            {
+                if (!IsValueCreated) return;
+
+                (lazy.Value.Result as IDisposable)?.Dispose();
+
+                init();
+            }
+
+            public bool IsValueCreated
+            {
+                get
+                {
+                    ensureValid();
+                    return lazy.IsValueCreated;
+                }
+            }
+
+            public Task<T> Value
+            {
+                get
+                {
+                    ensureValid();
+                    return lazy.Value;
+                }
+            }
+
+            private void ensureValid()
+            {
+                if (!lazy.IsValueCreated || (stillValidFunction?.Invoke(lazy.Value.Result) ?? true)) return;
+
+                init();
+            }
+
+            private void init()
+            {
+                lazy = new Lazy<Task<T>>(() => Task.Run(valueFactory));
             }
         }
     }
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 8eaa20f781..0ddff5e5aa 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -154,7 +154,7 @@ namespace osu.Game
                         Debug.Assert(lastBeatmap != null);
                         Debug.Assert(lastBeatmap.Track != null);
 
-                        lastBeatmap.DisposeTrack();
+                        lastBeatmap.RecycleTrack();
                     }
 
                     Audio.Track.AddItem(b.Track);