Use new generic objects wherever possible

osu.Framework/Graphics/BufferedDrawNode.cs

···
         /// </summary>
         /// <param name="frameBuffer">The <see cref="FrameBuffer"/> to bind.</param>
         /// <returns>A token that must be disposed upon finishing use of <paramref name="frameBuffer"/>.</returns>
-        protected ValueInvokeOnDisposal BindFrameBuffer(FrameBuffer frameBuffer)
+        protected IDisposable BindFrameBuffer(FrameBuffer frameBuffer)
         {
             // This setter will also take care of allocating a texture of appropriate size within the frame buffer.
             frameBuffer.Size = frameBufferSize;
 
             frameBuffer.Bind();
 
-            return new ValueInvokeOnDisposal(frameBuffer.Unbind);
+            return new ValueInvokeOnDisposal<FrameBuffer>(frameBuffer, b => b.Unbind());
         }
 
-        private ValueInvokeOnDisposal establishFrameBufferViewport()
+        private IDisposable establishFrameBufferViewport()
         {
             // Disable masking for generating the frame buffer since masking will be re-applied
             // when actually drawing later on anyways. This allows more information to be captured
···
             GLWrapper.PushScissor(new RectangleI(0, 0, (int)frameBufferSize.X, (int)frameBufferSize.Y));
             GLWrapper.PushScissorOffset(screenSpaceMaskingRect.Location);
 
-            return new ValueInvokeOnDisposal(returnViewport);
+            return new ValueInvokeOnDisposal<BufferedDrawNode>(this, d => d.returnViewport());
         }
 
         private void returnViewport()

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 
         protected ScheduledDelegate ScheduleAfterChildren(Action action) => SchedulerAfterChildren.AddDelayed(action, TransformDelay);
 
-        public override InvokeOnDisposal BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false)
+        public override IDisposable BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false)
         {
             var baseDisposalAction = base.BeginAbsoluteSequence(newTransformStartTime, recursive);
             if (!recursive)
                 return baseDisposalAction;
 
-            List<InvokeOnDisposal> disposalActions = new List<InvokeOnDisposal>(internalChildren.Count + 1) { baseDisposalAction };
+            List<IDisposable> disposalActions = new List<IDisposable>(internalChildren.Count + 1) { baseDisposalAction };
             foreach (var c in internalChildren)
                 disposalActions.Add(c.BeginAbsoluteSequence(newTransformStartTime, true));
 
-            return new InvokeOnDisposal(() =>
+            return new InvokeOnDisposal<List<IDisposable>>(disposalActions, actions =>
             {
-                foreach (var a in disposalActions)
+                foreach (var a in actions)
                     a.Dispose();
             });
         }

osu.Framework/Graphics/Transforms/ITransformable.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
+using System;
 using osu.Framework.Timing;
 
 namespace osu.Framework.Graphics.Transforms
 {
     public interface ITransformable
     {
-        InvokeOnDisposal BeginDelayedSequence(double delay, bool recursive = false);
+        IDisposable BeginDelayedSequence(double delay, bool recursive = false);
 
-        InvokeOnDisposal BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false);
+        IDisposable BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false);
 
         /// <summary>
         /// The current frame's time as observed by this class's <see cref="Transform"/>s.

osu.Framework/Graphics/Transforms/Transformable.cs

···
         /// <param name="delay">The offset in milliseconds from current time. Note that this stacks with other nested sequences.</param>
         /// <param name="recursive">Whether this should be applied to all children.</param>
         /// <returns>A <see cref="InvokeOnDisposal"/> to be used in a using() statement.</returns>
-        public InvokeOnDisposal BeginDelayedSequence(double delay, bool recursive = false)
+        public IDisposable BeginDelayedSequence(double delay, bool recursive = false)
         {
             if (delay == 0)
                 return null;
···
             AddDelay(delay, recursive);
             double newTransformDelay = TransformDelay;
 
-            return new InvokeOnDisposal(() =>
+            return new InvokeOnDisposal<(Transformable transformable, double delay, bool recursive, double newTransformDelay)>((this, delay, recursive, newTransformDelay), sender =>
             {
-                if (!Precision.AlmostEquals(newTransformDelay, TransformDelay))
+                if (!Precision.AlmostEquals(sender.newTransformDelay, sender.transformable.TransformDelay))
                 {
                     throw new InvalidOperationException(
-                        $"{nameof(TransformStartTime)} at the end of delayed sequence is not the same as at the beginning, but should be. " +
-                        $"(begin={newTransformDelay} end={TransformDelay})");
+                        $"{nameof(sender.transformable.TransformStartTime)} at the end of delayed sequence is not the same as at the beginning, but should be. " +
+                        $"(begin={sender.newTransformDelay} end={sender.transformable.TransformDelay})");
                 }
 
-                AddDelay(-delay, recursive);
+                AddDelay(-sender.delay, sender.recursive);
             });
         }
 
···
         /// <param name="recursive">Whether this should be applied to all children.</param>
         /// <returns>A <see cref="InvokeOnDisposal"/> to be used in a using() statement.</returns>
         /// <exception cref="InvalidOperationException">Absolute sequences should never be nested inside another existing sequence.</exception>
-        public virtual InvokeOnDisposal BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false)
+        public virtual IDisposable BeginAbsoluteSequence(double newTransformStartTime, bool recursive = false)
         {
             double oldTransformDelay = TransformDelay;
             double newTransformDelay = TransformDelay = newTransformStartTime - (Clock?.CurrentTime ?? 0);
 
-            return new InvokeOnDisposal(() =>
+            return new InvokeOnDisposal<(Transformable transformable, double oldTransformDelay, double newTransformDelay)>((this, oldTransformDelay, newTransformDelay), sender =>
             {
-                if (!Precision.AlmostEquals(newTransformDelay, TransformDelay))
+                if (!Precision.AlmostEquals(sender.newTransformDelay, sender.transformable.TransformDelay))
                 {
                     throw new InvalidOperationException(
-                        $"{nameof(TransformStartTime)} at the end of absolute sequence is not the same as at the beginning, but should be. " +
-                        $"(begin={newTransformDelay} end={TransformDelay})");
+                        $"{nameof(sender.transformable.TransformStartTime)} at the end of absolute sequence is not the same as at the beginning, but should be. " +
+                        $"(begin={sender.newTransformDelay} end={sender.transformable.TransformDelay})");
                 }
 
-                TransformDelay = oldTransformDelay;
+                sender.transformable.TransformDelay = sender.oldTransformDelay;
             });
         }
 

osu.Framework/Platform/NativeMemoryTracker.cs

···
             getStatistic(source).Value += amount;
             GC.AddMemoryPressure(amount);
 
-            return new NativeMemoryLease(() => removeMemory(source, amount));
+            return new NativeMemoryLease((source, amount), sender => removeMemory(sender.source, sender.amount));
         }
 
         /// <summary>
···
         /// <summary>
         /// A leased on a native memory allocation. Should be disposed when the associated memory is freed.
         /// </summary>
-        public class NativeMemoryLease : InvokeOnDisposal
+        public class NativeMemoryLease : InvokeOnDisposal<(object source, long amount)>
         {
-            internal NativeMemoryLease(Action action)
-                : base(action)
+            internal NativeMemoryLease((object source, long amount) sender, Action<(object source, long amount)> action)
+                : base(sender, action)
             {
             }