[release/8.0] [Blazor] Fix hot reload memory leak (#53928)

* Resolve change token leak in Blazor hot reload (#53750)

Fix of razor hotreload change token leak. This disposes the
old change tokens after the ClearCache event or before overwriting. 
If something goes wrong and this isn't cleared
before the next invocation of UpdateEndpoints on the
razor data source, clear it and dispose of it then.

* Add unit test to confirm change token is disposed during (#53827)

* Add unit test to confirm change token is disposed during
razer hot reload.

* Per Makinnon's feedback, switch to a callback model
to create the wrapped disposable for this unit test.

* Update src/Components/Endpoints/test/HotReloadServiceTests.cs

---------

Co-authored-by: Mackinnon Buck <[email protected]>

---------

Co-authored-by: jacdavis <[email protected]>

Author: MackinnonBuck

src/Components/Endpoints/src/Builder/RazorComponentEndpointDataSource.cs

@@ -28,6 +28,9 @@ internal class RazorComponentEndpointDataSource<[DynamicallyAccessedMembers(Comp
     private List<Endpoint>? _endpoints;
     private CancellationTokenSource _cancellationTokenSource;
     private IChangeToken _changeToken;
+    private IDisposable? _disposableChangeToken;   // THREADING: protected by _lock
+
+    public Func<IDisposable, IDisposable> SetDisposableChangeTokenAction = disposableChangeToken => disposableChangeToken;
 
     // Internal for testing.
     internal ComponentApplicationBuilder Builder => _builder;
@@ -45,6 +48,7 @@ public RazorComponentEndpointDataSource(
         _renderModeEndpointProviders = renderModeEndpointProviders.ToArray();
         _factory = factory;
         _hotReloadService = hotReloadService;
+        HotReloadService.ClearCacheEvent += OnHotReloadClearCache;
         DefaultBuilder = new RazorComponentsEndpointConventionBuilder(
             _lock,
             builder,
@@ -139,12 +143,23 @@ private void UpdateEndpoints()
             _cancellationTokenSource = new CancellationTokenSource();
             _changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
             oldCancellationTokenSource?.Cancel();
+            oldCancellationTokenSource?.Dispose();
             if (_hotReloadService is { MetadataUpdateSupported : true })
             {
-                ChangeToken.OnChange(_hotReloadService.GetChangeToken, UpdateEndpoints);
+                _disposableChangeToken?.Dispose();
+                _disposableChangeToken = SetDisposableChangeTokenAction(ChangeToken.OnChange(_hotReloadService.GetChangeToken, UpdateEndpoints));
             }
         }
     }
+ 
+    public void OnHotReloadClearCache(Type[]? types)
+    {
+        lock (_lock)
+        {
+            _disposableChangeToken?.Dispose();
+            _disposableChangeToken = null;
+        }
+    }
 
     public override IChangeToken GetChangeToken()
     {

src/Components/Endpoints/src/DependencyInjection/HotReloadService.cs

@@ -18,6 +18,7 @@ public HotReloadService()
 
     private CancellationTokenSource _tokenSource = new();
     private static event Action<Type[]?>? UpdateApplicationEvent;
+    internal static event Action<Type[]?>? ClearCacheEvent;
 
     public bool MetadataUpdateSupported { get; internal set; }
 
@@ -27,11 +28,17 @@ public static void UpdateApplication(Type[]? changedTypes)
     {
         UpdateApplicationEvent?.Invoke(changedTypes);
     }
+    
+    public static void ClearCache(Type[]? types) 
+    { 
+        ClearCacheEvent?.Invoke(types);
+    }
 
     private void NotifyUpdateApplication(Type[]? changedTypes)
     {
         var current = Interlocked.Exchange(ref _tokenSource, new CancellationTokenSource());
         current.Cancel();
+        current.Dispose();
     }
 
     public void Dispose()

src/Components/Endpoints/test/HotReloadServiceTests.cs

@@ -137,6 +137,52 @@ public void NotifiesCompositeEndpointDataSource()
         Assert.Empty(compositeEndpointDataSource.Endpoints);
     }
 
+    private sealed class WrappedChangeTokenDisposable : IDisposable
+    {
+        public bool IsDisposed { get; private set; }
+        private readonly IDisposable _innerDisposable;
+
+        public WrappedChangeTokenDisposable(IDisposable innerDisposable)
+        { 
+            _innerDisposable = innerDisposable;
+        }
+
+        public void Dispose()
+        { 
+             IsDisposed = true;
+             _innerDisposable.Dispose();
+        }
+    }
+
+    [Fact]
+    public void ConfirmChangeTokenDisposedHotReload()
+    {
+        // Arrange
+        var builder = CreateBuilder(typeof(ServerComponent));
+        var services = CreateServices(typeof(MockEndpointProvider));
+        var endpointDataSource = CreateDataSource<App>(builder, services);
+
+        WrappedChangeTokenDisposable wrappedChangeTokenDisposable = null;
+
+        endpointDataSource.SetDisposableChangeTokenAction = (IDisposable disposableChangeToken) => {
+            wrappedChangeTokenDisposable = new WrappedChangeTokenDisposable(disposableChangeToken); 
+            return wrappedChangeTokenDisposable;
+        };
+
+        var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints));
+        Assert.Equal("/server", endpoint.RoutePattern.RawText);
+        Assert.DoesNotContain(endpoint.Metadata, (element) => element is TestMetadata);
+
+        // Make a modification and then perform a hot reload.
+        endpointDataSource.Conventions.Add(builder =>
+            builder.Metadata.Add(new TestMetadata()));
+        HotReloadService.UpdateApplication(null);
+        HotReloadService.ClearCache(null);
+
+        // Confirm the change token is disposed after ClearCache
+        Assert.True(wrappedChangeTokenDisposable.IsDisposed);
+    }
+
     private class TestMetadata { }
 
     private ComponentApplicationBuilder CreateBuilder(params Type[] types)