[wasm] Cancel pending ReadableStream on Dispose or cancelationToken

src/libraries/Common/tests/System/Net/Http/GenericLoopbackServer.cs

@@ -86,6 +86,17 @@ public void Close()
             CloseWebSocket();
         }
 
+        public async Task WaitForCloseAsync(CancellationToken cancellationToken)
+        {
+            while (_websocket != null
+                    ? _websocket.State != WebSocketState.Closed
+                    : !(_socket.Poll(1, SelectMode.SelectRead) && _socket.Available == 0))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                await Task.Delay(100);
+            }
+        }
+
         public void Shutdown(SocketShutdown how)
         {
             _socket?.Shutdown(how);
@@ -138,6 +149,9 @@ public abstract class GenericLoopbackConnection : IDisposable
         /// <summary>Waits for the client to signal cancellation.</summary>
         public abstract Task WaitForCancellationAsync(bool ignoreIncomingData = true);
 
+        /// <summary>Waits for the client to signal cancellation.</summary>
+        public abstract Task WaitForCloseAsync(CancellationToken cancellationToken);
+
         /// <summary>Helper function to make it easier to convert old test with strings.</summary>
         public async Task SendResponseBodyAsync(string content, bool isFinal = true)
         {

src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs

@@ -984,5 +984,10 @@ public override async Task WaitForCancellationAsync(bool ignoreIncomingData = tr
             RstStreamFrame rstStreamFrame = Assert.IsType<RstStreamFrame>(frame);
             Assert.Equal((int)ProtocolErrors.CANCEL, rstStreamFrame.ErrorCode);
         }
+
+        public override Task WaitForCloseAsync(CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/libraries/Common/tests/System/Net/Http/Http3LoopbackConnection.cs

@@ -10,6 +10,7 @@
 using System.Linq;
 using System.Net.Http.Functional.Tests;
 using Xunit;
+using System.Threading;
 
 namespace System.Net.Test.Common
 {
@@ -305,6 +306,11 @@ public override async Task WaitForCancellationAsync(bool ignoreIncomingData = tr
         {
             await GetOpenRequest().WaitForCancellationAsync(ignoreIncomingData).ConfigureAwait(false);
         }
+
+        public override Task WaitForCloseAsync(CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
     }
 
 }

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs

@@ -28,6 +28,7 @@ public HttpClientHandler_Cancellation_Test(ITestOutputHelper output) : base(outp
         [Theory]
         [InlineData(false, CancellationMode.Token)]
         [InlineData(true, CancellationMode.Token)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/36634", TestPlatforms.Browser)] // out of memory
         public async Task PostAsync_CancelDuringRequestContentSend_TaskCanceledQuickly(bool chunkedTransfer, CancellationMode mode)
         {
             if (LoopbackServerFactory.Version >= HttpVersion20.Value && chunkedTransfer)
@@ -228,10 +229,21 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
                         await connection.ReadRequestDataAsync();
                         await connection.SendResponseAsync(HttpStatusCode.OK, headers: headers, isFinal: false);
                         await clientFinished.Task;
+
+#if TARGET_BROWSER
+                        // make sure that the browser closed the connection
+                        await connection.WaitForCloseAsync(CancellationToken.None);
+#endif
                     });
 
                     var req = new HttpRequestMessage(HttpMethod.Get, url) { Version = UseVersion };
                     req.Headers.ConnectionClose = connectionClose;
+
+#if TARGET_BROWSER
+                    var WebAssemblyEnableStreamingResponseKey = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
+                    req.Options.Set(WebAssemblyEnableStreamingResponseKey, true);
+#endif
+
                     Task<HttpResponseMessage> getResponse = client.SendAsync(TestAsync, req, HttpCompletionOption.ResponseHeadersRead, cts.Token);
                     await ValidateClientCancellationAsync(async () =>
                     {
@@ -247,7 +259,6 @@ await ValidateClientCancellationAsync(async () =>
                         cts.Cancel();
                         await readTask;
                     });
-
                     try
                     {
                         clientFinished.SetResult(true);
@@ -256,11 +267,13 @@ await ValidateClientCancellationAsync(async () =>
                 });
             }
         }
+
         [Theory]
         [InlineData(CancellationMode.CancelPendingRequests, false)]
         [InlineData(CancellationMode.DisposeHttpClient, false)]
         [InlineData(CancellationMode.CancelPendingRequests, true)]
         [InlineData(CancellationMode.DisposeHttpClient, true)]
+        [SkipOnPlatform(TestPlatforms.Browser, "Browser doesn't have blocking synchronous Stream.ReadByte and so it waits for whole body")]
         public async Task GetAsync_CancelPendingRequests_DoesntCancelReadAsyncOnResponseStream(CancellationMode mode, bool copyToAsync)
         {
             if (IsWinHttpHandler && UseVersion >= HttpVersion20.Value)

src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs

@@ -1065,6 +1065,11 @@ public override async Task WaitForCancellationAsync(bool ignoreIncomingData = tr
                     }
                 }
             }
+
+            public override Task WaitForCloseAsync(CancellationToken cancellationToken)
+            {
+                return _socket.WaitForCloseAsync(cancellationToken);
+            }
         }
 
         public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")

src/libraries/Common/tests/System/Net/Prerequisites/RemoteLoopServer/Handlers/RemoteLoopHandler.cs

@@ -100,6 +100,11 @@ private static async Task ProcessWebSocketRequest(HttpContext context, WebSocket
                                 var slice = new ArraySegment<byte>(testedBuffer, 0, testedNext.Result);
                                 await control.SendAsync(slice, WebSocketMessageType.Binary, true, cts.Token).ConfigureAwait(false);
                             }
+                            // did we get TCP FIN?
+                            if (!close && (tested.Poll(1, SelectMode.SelectRead) && tested.Available == 0))
+                            {
+                                close = true;
+                            }
                             if (!close)
                             {
                                 testedNext = tested.ReceiveAsync(new Memory<byte>(testedBuffer), SocketFlags.None, cts.Token).AsTask();
@@ -142,14 +147,14 @@ private static async Task ProcessWebSocketRequest(HttpContext context, WebSocket
                     }
                     catch (WebSocketException ex)
                     {
-                        logger.LogWarning("ProcessWebSocketRequest closing failed", ex);
+                        logger.LogWarning("RemoteLoopHandler.ProcessWebSocketRequest closing failed", ex);
                     }
                 }
                 cts.Cancel();
             }
             catch (Exception ex)
             {
-                logger.LogError("ProcessWebSocketRequest failed", ex);
+                logger.LogError("RemoteLoopHandler.ProcessWebSocketRequest failed", ex);
             }
             finally
             {