[release/7.0.2xx] Revert hot reload script injection response buffering (#29152)

## Summary

Fixes a regression in memory consumption caused by large responses when debugging with hot reload enabled.

## Description

As one of the changes introduced in .NET 7 by #27537, the hot reload script injection middleware now buffers the entire response before performing script injection. This was done to improve script injection reliability, but we recently began receiving reports from customers that were confused by the increase in server memory usage for large responses when debugging with hot reload is enabled.

This PR reverts the buffering behavior but keeps the logging improvements that help customers identify the cause of script injection failures and take steps to fix them.

For .NET 8, we will assess an alternative approach to improve script injection reliability that doesn't involve buffering each response.

## Validation

Manual validation + existing automated tests for this scenario.

## Risk

Low. This PR simply reverts the offending commit and adds back some of the improved logging behavior with no other changes to functionality.

Fixes dotnet/aspnetcore#45037

Author: MackinnonBuck

src/BuiltInTools/BrowserRefresh/BrowserRefreshMiddleware.cs

@@ -3,8 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
@@ -28,10 +26,10 @@ public async Task InvokeAsync(HttpContext context)
             // We only need to support this for requests that could be initiated by a browser.
             if (IsBrowserDocumentRequest(context))
             {
-                // Use a custom stream to buffer the response body for rewriting.
-                using var memoryStream = new MemoryStream();
+                // Use a custom StreamWrapper to rewrite output on Write/WriteAsync
+                using var responseStreamWrapper = new ResponseStreamWrapper(context, _logger);
                 var originalBodyFeature = context.Features.Get<IHttpResponseBodyFeature>();
-                context.Features.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(memoryStream));
+                context.Features.Set<IHttpResponseBodyFeature>(new StreamResponseBodyFeature(responseStreamWrapper));
 
                 try
                 {
@@ -42,35 +40,19 @@ public async Task InvokeAsync(HttpContext context)
                     context.Features.Set(originalBodyFeature);
                 }
 
-                if (memoryStream.TryGetBuffer(out var buffer) && buffer.Count > 0)
+                if (responseStreamWrapper.IsHtmlResponse)
                 {
-                    var response = context.Response;
-                    var baseStream = response.Body;
-
-                    if (IsHtmlResponse(response))
+                    if (responseStreamWrapper.ScriptInjectionPerformed)
+                    {
+                        Log.BrowserConfiguredForRefreshes(_logger);
+                    }
+                    else if (context.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var contentEncodings))
                     {
-                        Log.SetupResponseForBrowserRefresh(_logger);
-
-                        // Since we're changing the markup content, reset the content-length
-                        response.Headers.ContentLength = null;
-
-                        var scriptInjectionPerformed = await WebSocketScriptInjection.TryInjectLiveReloadScriptAsync(baseStream, buffer);
-                        if (scriptInjectionPerformed)
-                        {
-                            Log.BrowserConfiguredForRefreshes(_logger);
-                        }
-                        else if (response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var contentEncodings))
-                        {
-                            Log.ResponseCompressionDetected(_logger, contentEncodings);
-                        }
-                        else
-                        {
-                            Log.FailedToConfiguredForRefreshes(_logger);
-                        }
+                        Log.ResponseCompressionDetected(_logger, contentEncodings);
                     }
                     else
                     {
-                        await baseStream.WriteAsync(buffer);
+                        Log.FailedToConfiguredForRefreshes(_logger);
                     }
                 }
             }
@@ -114,12 +96,6 @@ internal static bool IsBrowserDocumentRequest(HttpContext context)
             return false;
         }
 
-        private bool IsHtmlResponse(HttpResponse response)
-            => (response.StatusCode == StatusCodes.Status200OK || response.StatusCode == StatusCodes.Status500InternalServerError) &&
-                MediaTypeHeaderValue.TryParse(response.ContentType, out var mediaType) &&
-                mediaType.IsSubsetOf(_textHtmlMediaType) &&
-                (!mediaType.Charset.HasValue || mediaType.Charset.Equals("utf-8", StringComparison.OrdinalIgnoreCase));
-
         internal static class Log
         {
             private static readonly Action<ILogger, Exception?> _setupResponseForBrowserRefresh = LoggerMessage.Define(

src/BuiltInTools/BrowserRefresh/ReadOnlySpanOfByteExtensions.cs

@@ -0,0 +1,153 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+// Based on https://github.com/RickStrahl/Westwind.AspnetCore.LiveReload/blob/128b5f524e86954e997f2c453e7e5c1dcc3db746/Westwind.AspnetCore.LiveReload/ResponseStreamWrapper.cs
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Net.Http.Headers;
+
+namespace Microsoft.AspNetCore.Watch.BrowserRefresh
+{
+    /// <summary>
+    /// Wraps the Response Stream to inject the WebSocket HTML into
+    /// an HTML Page.
+    /// </summary>
+    public class ResponseStreamWrapper : Stream
+    {
+        private static readonly MediaTypeHeaderValue _textHtmlMediaType = new MediaTypeHeaderValue("text/html");
+        private readonly Stream _baseStream;
+        private readonly HttpContext _context;
+        private readonly ILogger _logger;
+        private bool? _isHtmlResponse;
+
+        public ResponseStreamWrapper(HttpContext context, ILogger logger)
+        {
+            _context = context;
+            _baseStream = context.Response.Body;
+            _logger = logger;
+        }
+
+        public override bool CanRead => false;
+        public override bool CanSeek => false;
+        public override bool CanWrite => true;
+        public override long Length { get; }
+        public override long Position { get; set; }
+        public bool ScriptInjectionPerformed { get; private set; }
+
+        public bool IsHtmlResponse => _isHtmlResponse ?? false;
+
+        public override void Flush()
+        {
+            OnWrite();
+            _baseStream.Flush();
+        }
+
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            OnWrite();
+            return _baseStream.FlushAsync(cancellationToken);
+        }
+
+        public override void Write(ReadOnlySpan<byte> buffer)
+        {
+            OnWrite();
+            if (IsHtmlResponse && !ScriptInjectionPerformed)
+            {
+                ScriptInjectionPerformed = WebSocketScriptInjection.TryInjectLiveReloadScript(_baseStream, buffer);
+            }
+            else
+            {
+                _baseStream.Write(buffer);
+            }
+        }
+
+        public override void WriteByte(byte value)
+        {
+            OnWrite();
+            _baseStream.WriteByte(value);
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            OnWrite();
+
+            if (IsHtmlResponse && !ScriptInjectionPerformed)
+            {
+                ScriptInjectionPerformed = WebSocketScriptInjection.TryInjectLiveReloadScript(_baseStream, buffer.AsSpan(offset, count));
+            }
+            else
+            {
+                _baseStream.Write(buffer, offset, count);
+            }
+        }
+
+        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            OnWrite();
+
+            if (IsHtmlResponse && !ScriptInjectionPerformed)
+            {
+                ScriptInjectionPerformed = await WebSocketScriptInjection.TryInjectLiveReloadScriptAsync(_baseStream, buffer.AsMemory(offset, count), cancellationToken);
+            }
+            else
+            {
+                await _baseStream.WriteAsync(buffer, offset, count, cancellationToken);
+            }
+        }
+
+        public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            OnWrite();
+
+            if (IsHtmlResponse && !ScriptInjectionPerformed)
+            {
+                ScriptInjectionPerformed = await WebSocketScriptInjection.TryInjectLiveReloadScriptAsync(_baseStream, buffer, cancellationToken);
+            }
+            else
+            {
+                await _baseStream.WriteAsync(buffer, cancellationToken);
+            }
+        }
+
+        private void OnWrite()
+        {
+            if (_isHtmlResponse.HasValue)
+            {
+                return;
+            }
+
+            var response = _context.Response;
+
+            _isHtmlResponse =
+                (response.StatusCode == StatusCodes.Status200OK || response.StatusCode == StatusCodes.Status500InternalServerError) &&
+                MediaTypeHeaderValue.TryParse(response.ContentType, out var mediaType) &&
+                mediaType.IsSubsetOf(_textHtmlMediaType) &&
+                (!mediaType.Charset.HasValue || mediaType.Charset.Equals("utf-8", StringComparison.OrdinalIgnoreCase));
+
+            if (_isHtmlResponse.Value)
+            {
+                BrowserRefreshMiddleware.Log.SetupResponseForBrowserRefresh(_logger);
+
+                // Since we're changing the markup content, reset the content-length
+                response.Headers.ContentLength = null;
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+             => throw new NotSupportedException();
+
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+             => throw new NotSupportedException();
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+    }
+}

src/BuiltInTools/BrowserRefresh/ResponseStreamWrapper.cs

@@ -15,81 +15,59 @@ namespace Microsoft.AspNetCore.Watch.BrowserRefresh
     /// </summary>
     public static class WebSocketScriptInjection
     {
-        private static readonly byte[] s_closingTagStartIndicator = "</"u8.ToArray();
-        private static readonly byte[] s_bodyElementName = "body"u8.ToArray();
-        private static readonly byte[] s_closingTagEndIndicator = ">"u8.ToArray();
+        private const string BodyMarker = "</body>";
+
+        private static readonly byte[] _bodyBytes = Encoding.UTF8.GetBytes(BodyMarker);
 
         internal static string InjectedScript { get; } = $"<script src=\"{ApplicationPaths.BrowserRefreshJS}\"></script>";
 
-        private static readonly byte[] s_injectedScriptBytes = Encoding.UTF8.GetBytes(InjectedScript);
+        private static readonly byte[] _injectedScriptBytes = Encoding.UTF8.GetBytes(InjectedScript);
 
-        public static async ValueTask<bool> TryInjectLiveReloadScriptAsync(Stream baseStream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        public static bool TryInjectLiveReloadScript(Stream baseStream, ReadOnlySpan<byte> buffer)
         {
-            var index = LastIndexOfClosingBodyTag(buffer.Span);
+            var index = buffer.LastIndexOf(_bodyBytes);
             if (index == -1)
             {
-                await baseStream.WriteAsync(buffer, cancellationToken);
+                baseStream.Write(buffer);
                 return false;
             }
 
             if (index > 0)
             {
-                await baseStream.WriteAsync(buffer.Slice(0, index), cancellationToken);
+                baseStream.Write(buffer.Slice(0, index));
                 buffer = buffer[index..];
             }
 
             // Write the injected script
-            await baseStream.WriteAsync(s_injectedScriptBytes, cancellationToken);
+            baseStream.Write(_injectedScriptBytes);
 
             // Write the rest of the buffer/HTML doc
-            await baseStream.WriteAsync(buffer, cancellationToken);
+            baseStream.Write(buffer);
             return true;
         }
 
-        private static int LastIndexOfClosingBodyTag(ReadOnlySpan<byte> buffer)
+        public static async ValueTask<bool> TryInjectLiveReloadScriptAsync(Stream baseStream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
         {
-            while (true)
+            var index = buffer.Span.LastIndexOf(_bodyBytes);
+            if (index == -1)
             {
-                // Find the character sequence for the end of the closing tag.
-                var index = buffer.LastIndexOf(s_closingTagEndIndicator);
-                if (index == -1)
-                {
-                    return -1;
-                }
-                buffer = buffer[..index];
-
-                // Find the first non-whitespace character inside the tag.
-                index = buffer.LastIndexOfNonWhiteSpace();
-                if (index == -1)
-                {
-                    return -1;
-                }
-                buffer = buffer[..(index + 1)];
-
-                // Determine if the characters inside the tag match "body".
-                if (!buffer.EndsWithIgnoreCase(s_bodyElementName))
-                {
-                    continue;
-                }
-                buffer = buffer[..^s_bodyElementName.Length];
+                await baseStream.WriteAsync(buffer, cancellationToken);
+                return false;
+            }
 
-                // Find the first non-whitespace character before the tag name.
-                index = buffer.LastIndexOfNonWhiteSpace();
-                if (index == -1)
-                {
-                    return -1;
-                }
-                buffer = buffer[..(index + 1)];
+            if (index > 0)
+            {
+                await baseStream.WriteAsync(buffer.Slice(0, index), cancellationToken);
+                buffer = buffer[index..];
+            }
 
-                // Determine if the characters preceding tag name match the closing tag start indicator.
-                if (!buffer.EndsWith(s_closingTagStartIndicator))
-                {
-                    continue;
-                }
-                buffer = buffer[..^s_closingTagStartIndicator.Length];
+            // Write the injected script
+            await baseStream.WriteAsync(_injectedScriptBytes, cancellationToken);
 
-                return buffer.Length;
-            }
+            // Write the rest of the buffer/HTML doc
+            await baseStream.WriteAsync(buffer, cancellationToken);
+            return true;
         }
+
     }
 }